MapHelper.hpp

Go to the documentation of this file.

/*
 *  Copyright 2019-2021 Diligent Graphics LLC
 *  Copyright 2015-2019 Egor Yusov
 *  
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */
 
#pragma once
 
 
#include "../../../Platforms/Basic/interface/DebugUtilities.hpp"
#include "../../../Common/interface/RefCntAutoPtr.hpp"
#include "../../GraphicsEngine/interface/DeviceContext.h"
#include "../../GraphicsEngine/interface/Buffer.h"
 
namespace Diligent
{
 
 
template <typename DataType, bool KeepStrongReferences = false>
class MapHelper
{
public:
    // clang-format off
    MapHelper() :
        m_pBuffer     {nullptr},
        m_pContext    {nullptr},
        m_pMappedData {nullptr},
        m_MapType     {static_cast<MAP_TYPE>(-1)},
        m_MapFlags    {static_cast<Uint32>(-1)  }
    // clang-format on
    {
    }
 
    MapHelper(IDeviceContext* pContext, IBuffer* pBuffer, MAP_TYPE MapType, MAP_FLAGS MapFlags) :
        MapHelper()
    {
        Map(pContext, pBuffer, MapType, MapFlags);
    }
 
    // clang-format off
    MapHelper(MapHelper&& Helper) :
        m_pBuffer       {std::move(Helper.m_pBuffer)    },
        m_pMappedData   {std::move(Helper.m_pMappedData)},
        m_pContext      {std::move(Helper.m_pContext)   },
        m_MapType       {std::move(Helper.m_MapType)    },
        m_MapFlags      {std::move(Helper.m_MapFlags)   }
    // clang-format on
    {
        Helper.m_pBuffer     = nullptr;
        Helper.m_pContext    = nullptr;
        Helper.m_pMappedData = nullptr;
        Helper.m_MapType     = static_cast<MAP_TYPE>(-1);
        Helper.m_MapFlags    = static_cast<Uint32>(-1);
    }
 
    MapHelper& operator=(MapHelper&& Helper)
    {
        m_pBuffer     = std::move(Helper.m_pBuffer);
        m_pMappedData = std::move(Helper.m_pMappedData);
        m_pContext    = std::move(Helper.m_pContext);
        m_MapType     = std::move(Helper.m_MapType);
        m_MapFlags    = std::move(Helper.m_MapFlags);
 
        Helper.m_pBuffer     = nullptr;
        Helper.m_pContext    = nullptr;
        Helper.m_pMappedData = nullptr;
        Helper.m_MapType     = static_cast<MAP_TYPE>(-1);
        Helper.m_MapFlags    = static_cast<Uint32>(-1);
 
        return *this;
    }
 
 
    void Map(IDeviceContext* pContext, IBuffer* pBuffer, MAP_TYPE MapType, MAP_FLAGS MapFlags)
    {
        VERIFY(!m_pBuffer && !m_pMappedData && !m_pContext, "Object already mapped");
        Unmap();
#ifdef DILIGENT_DEBUG
        {
            auto& BuffDesc = pBuffer->GetDesc();
            VERIFY(sizeof(DataType) <= BuffDesc.uiSizeInBytes, "Data type size exceeds buffer size");
        }
#endif
        pContext->MapBuffer(pBuffer, MapType, MapFlags, (PVoid&)m_pMappedData);
        if (m_pMappedData != nullptr)
        {
            m_pContext = pContext;
            m_pBuffer  = pBuffer;
            m_MapType  = MapType;
            m_MapFlags = MapFlags;
        }
    }
 
    void Unmap()
    {
        if (m_pBuffer)
        {
            m_pContext->UnmapBuffer(m_pBuffer, m_MapType);
            m_pBuffer  = nullptr;
            m_MapType  = static_cast<MAP_TYPE>(-1);
            m_MapFlags = static_cast<Uint32>(-1);
        }
        m_pContext    = nullptr;
        m_pMappedData = nullptr;
    }
 
    operator DataType*() { return m_pMappedData; }
 
    operator const DataType*() const { return m_pMappedData; }
 
    DataType* operator->() { return m_pMappedData; }
 
    const DataType* operator->() const { return m_pMappedData; }
 
    ~MapHelper()
    {
        Unmap();
    }
 
private:
    MapHelper(const MapHelper&) = delete;
    MapHelper& operator=(const MapHelper&) = delete;
 
    template <typename PtrType, bool UseStrongReference>
    struct PtrTypeSelector
    {};
 
    template <typename PtrType>
    struct PtrTypeSelector<PtrType, true>
    {
        typedef RefCntAutoPtr<PtrType> Type;
    };
 
    template <typename PtrType>
    struct PtrTypeSelector<PtrType, false>
    {
        typedef PtrType* Type;
    };
 
    typename PtrTypeSelector<IBuffer, KeepStrongReferences>::Type m_pBuffer;
 
    typename PtrTypeSelector<IDeviceContext, KeepStrongReferences>::Type m_pContext;
 
    DataType* m_pMappedData;
 
    MAP_TYPE m_MapType;
 
    Uint32 m_MapFlags;
};
 
} // namespace Diligent