From 16dd04efc73e4093a991a517f786ebaf03f3f6d1 Mon Sep 17 00:00:00 2001 From: assiduous Date: Fri, 24 Jul 2020 21:18:48 -0700 Subject: Added framebuffer object implementation stubs --- Graphics/GraphicsEngine/CMakeLists.txt | 1 + .../GraphicsEngine/include/FramebufferBase.hpp | 77 ++++++++++++++++++++++ .../GraphicsEngine/include/RenderDeviceBase.hpp | 29 ++++---- Graphics/GraphicsEngine/include/RenderPassBase.hpp | 2 +- Graphics/GraphicsEngine/interface/RenderDevice.h | 14 ++++ Graphics/GraphicsEngineD3D11/CMakeLists.txt | 2 + .../include/FramebufferD3D11Impl.hpp | 54 +++++++++++++++ .../include/RenderDeviceD3D11Impl.hpp | 4 ++ .../src/FramebufferD3D11Impl.cpp | 47 +++++++++++++ .../src/RenderDeviceD3D11Impl.cpp | 15 ++++- Graphics/GraphicsEngineD3D12/CMakeLists.txt | 2 + .../include/FramebufferD3D12Impl.hpp | 54 +++++++++++++++ .../include/RenderDeviceD3D12Impl.hpp | 4 ++ .../src/FramebufferD3D12Impl.cpp | 47 +++++++++++++ .../src/RenderDeviceD3D12Impl.cpp | 15 ++++- .../include/FramebufferMtlImpl.h | 54 +++++++++++++++ .../include/RenderDeviceMtlImpl.h | 2 + .../GraphicsEngineMetal/src/FramebufferMtlImpl.mm | 41 ++++++++++++ .../GraphicsEngineMetal/src/RenderDeviceMtlImpl.mm | 17 ++++- Graphics/GraphicsEngineOpenGL/CMakeLists.txt | 2 + .../include/FramebufferGLImpl.hpp | 54 +++++++++++++++ .../include/RenderDeviceGLImpl.hpp | 4 ++ .../GraphicsEngineOpenGL/src/FramebufferGLImpl.cpp | 47 +++++++++++++ .../src/RenderDeviceGLImpl.cpp | 15 ++++- Graphics/GraphicsEngineVulkan/CMakeLists.txt | 2 + .../include/FramebufferVkImpl.hpp | 53 +++++++++++++++ .../include/RenderDeviceVkImpl.hpp | 4 ++ .../GraphicsEngineVulkan/src/FramebufferVkImpl.cpp | 47 +++++++++++++ .../src/RenderDeviceVkImpl.cpp | 15 ++++- 29 files changed, 706 insertions(+), 18 deletions(-) create mode 100644 Graphics/GraphicsEngine/include/FramebufferBase.hpp create mode 100644 Graphics/GraphicsEngineD3D11/include/FramebufferD3D11Impl.hpp create mode 100644 Graphics/GraphicsEngineD3D11/src/FramebufferD3D11Impl.cpp create mode 100644 Graphics/GraphicsEngineD3D12/include/FramebufferD3D12Impl.hpp create mode 100644 Graphics/GraphicsEngineD3D12/src/FramebufferD3D12Impl.cpp create mode 100644 Graphics/GraphicsEngineMetal/include/FramebufferMtlImpl.h create mode 100644 Graphics/GraphicsEngineMetal/src/FramebufferMtlImpl.mm create mode 100644 Graphics/GraphicsEngineOpenGL/include/FramebufferGLImpl.hpp create mode 100644 Graphics/GraphicsEngineOpenGL/src/FramebufferGLImpl.cpp create mode 100644 Graphics/GraphicsEngineVulkan/include/FramebufferVkImpl.hpp create mode 100644 Graphics/GraphicsEngineVulkan/src/FramebufferVkImpl.cpp (limited to 'Graphics') diff --git a/Graphics/GraphicsEngine/CMakeLists.txt b/Graphics/GraphicsEngine/CMakeLists.txt index 7a8a4715..daafe96e 100644 --- a/Graphics/GraphicsEngine/CMakeLists.txt +++ b/Graphics/GraphicsEngine/CMakeLists.txt @@ -13,6 +13,7 @@ set(INCLUDE include/EngineFactoryBase.hpp include/EngineMemory.h include/FenceBase.hpp + include/FramebufferBase.hpp include/pch.h include/PipelineStateBase.hpp include/QueryBase.hpp diff --git a/Graphics/GraphicsEngine/include/FramebufferBase.hpp b/Graphics/GraphicsEngine/include/FramebufferBase.hpp new file mode 100644 index 00000000..ad33e9c0 --- /dev/null +++ b/Graphics/GraphicsEngine/include/FramebufferBase.hpp @@ -0,0 +1,77 @@ +/* + * Copyright 2019-2020 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 + +/// \file +/// Implementation of the Diligent::FramebufferBase template class + +#include "Framebuffer.h" +#include "DeviceObjectBase.hpp" +#include "RenderDeviceBase.hpp" + +namespace Diligent +{ + +void ValidateFramebufferDesc(const FramebufferDesc& Desc); + +/// Template class implementing base functionality for the framebuffer object. + +/// \tparam BaseInterface - base interface that this class will inheret +/// (e.g. Diligent::IFramebufferVk). +/// \tparam RenderDeviceImplType - type of the render device implementation +/// (Diligent::RenderDeviceD3D11Impl, Diligent::RenderDeviceD3D12Impl, +/// Diligent::RenderDeviceGLImpl, or Diligent::RenderDeviceVkImpl) +template +class FramebufferBase : public DeviceObjectBase +{ +public: + using TDeviceObjectBase = DeviceObjectBase; + + /// \param pRefCounters - reference counters object that controls the lifetime of this framebuffer pass. + /// \param pDevice - pointer to the device. + /// \param Desc - Framebuffer description. + /// \param bIsDeviceInternal - flag indicating if the Framebuffer is an internal device object and + /// must not keep a strong reference to the device. + FramebufferBase(IReferenceCounters* pRefCounters, + RenderDeviceImplType* pDevice, + const FramebufferDesc& Desc, + bool bIsDeviceInternal = false) : + TDeviceObjectBase{pRefCounters, pDevice, Desc, bIsDeviceInternal} + { + } + + ~FramebufferBase() + { + } + + IMPLEMENT_QUERY_INTERFACE_IN_PLACE(IID_Framebuffer, TDeviceObjectBase) + +private: +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp b/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp index 854e5ec9..a0ffeda6 100644 --- a/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp +++ b/Graphics/GraphicsEngine/include/RenderDeviceBase.hpp @@ -223,6 +223,9 @@ public: /// Size of the render pass object (RenderPassD3D12Impl, RenderPassVkImpl, etc.), in bytes const size_t RenderPassObjSize; + + /// Size of the framebuffer object (FramebufferD3D12Impl, FramebufferVkImpl, etc.), in bytes + const size_t FramebufferObjSize; }; /// \param pRefCounters - reference counters object that controls the lifetime of this render device @@ -246,18 +249,19 @@ public: m_TexFmtInfoInitFlags (TEX_FORMAT_NUM_FORMATS, false, STD_ALLOCATOR_RAW_MEM(bool, RawMemAllocator, "Allocator for vector")), m_wpDeferredContexts (NumDeferredContexts, RefCntWeakPtr(), STD_ALLOCATOR_RAW_MEM(RefCntWeakPtr, RawMemAllocator, "Allocator for vector< RefCntWeakPtr >")), m_RawMemAllocator {RawMemAllocator}, - m_TexObjAllocator {RawMemAllocator, ObjectSizes.TextureObjSize, 64 }, - m_TexViewObjAllocator {RawMemAllocator, ObjectSizes.TexViewObjSize, 64 }, - m_BufObjAllocator {RawMemAllocator, ObjectSizes.BufferObjSize, 128 }, - m_BuffViewObjAllocator {RawMemAllocator, ObjectSizes.BuffViewObjSize, 128 }, - m_ShaderObjAllocator {RawMemAllocator, ObjectSizes.ShaderObjSize, 32 }, - m_SamplerObjAllocator {RawMemAllocator, ObjectSizes.SamplerObjSize, 32 }, - m_PSOAllocator {RawMemAllocator, ObjectSizes.PSOSize, 128 }, - m_SRBAllocator {RawMemAllocator, ObjectSizes.SRBSize, 1024}, - m_ResMappingAllocator {RawMemAllocator, sizeof(ResourceMappingImpl), 16 }, - m_FenceAllocator {RawMemAllocator, ObjectSizes.FenceSize, 16 }, - m_QueryAllocator {RawMemAllocator, ObjectSizes.QuerySize, 16 }, - m_RenderPassAllocator {RawMemAllocator, ObjectSizes.RenderPassObjSize, 16 } + m_TexObjAllocator {RawMemAllocator, ObjectSizes.TextureObjSize, 64 }, + m_TexViewObjAllocator {RawMemAllocator, ObjectSizes.TexViewObjSize, 64 }, + m_BufObjAllocator {RawMemAllocator, ObjectSizes.BufferObjSize, 128 }, + m_BuffViewObjAllocator {RawMemAllocator, ObjectSizes.BuffViewObjSize, 128 }, + m_ShaderObjAllocator {RawMemAllocator, ObjectSizes.ShaderObjSize, 32 }, + m_SamplerObjAllocator {RawMemAllocator, ObjectSizes.SamplerObjSize, 32 }, + m_PSOAllocator {RawMemAllocator, ObjectSizes.PSOSize, 128 }, + m_SRBAllocator {RawMemAllocator, ObjectSizes.SRBSize, 1024}, + m_ResMappingAllocator {RawMemAllocator, sizeof(ResourceMappingImpl), 16 }, + m_FenceAllocator {RawMemAllocator, ObjectSizes.FenceSize, 16 }, + m_QueryAllocator {RawMemAllocator, ObjectSizes.QuerySize, 16 }, + m_RenderPassAllocator {RawMemAllocator, ObjectSizes.RenderPassObjSize, 16 }, + m_FramebufferAllocator {RawMemAllocator, ObjectSizes.FramebufferObjSize, 16 } // clang-format on { // Initialize texture format info @@ -431,6 +435,7 @@ protected: FixedBlockMemoryAllocator m_FenceAllocator; ///< Allocator for fence objects FixedBlockMemoryAllocator m_QueryAllocator; ///< Allocator for query objects FixedBlockMemoryAllocator m_RenderPassAllocator; ///< Allocator for render pass objects + FixedBlockMemoryAllocator m_FramebufferAllocator; ///< Allocator for framebuffer objects }; diff --git a/Graphics/GraphicsEngine/include/RenderPassBase.hpp b/Graphics/GraphicsEngine/include/RenderPassBase.hpp index a8d73dc2..8099abb2 100644 --- a/Graphics/GraphicsEngine/include/RenderPassBase.hpp +++ b/Graphics/GraphicsEngine/include/RenderPassBase.hpp @@ -42,7 +42,7 @@ void ValidateRenderPassDesc(const RenderPassDesc& Desc); /// Template class implementing base functionality for the render pass object. /// \tparam BaseInterface - base interface that this class will inheret -/// (Diligent::IRenderPassVk). +/// (e.g. Diligent::IRenderPassVk). /// \tparam RenderDeviceImplType - type of the render device implementation /// (Diligent::RenderDeviceD3D11Impl, Diligent::RenderDeviceD3D12Impl, /// Diligent::RenderDeviceGLImpl, or Diligent::RenderDeviceVkImpl) diff --git a/Graphics/GraphicsEngine/interface/RenderDevice.h b/Graphics/GraphicsEngine/interface/RenderDevice.h index 24c641bc..ddbc75b2 100644 --- a/Graphics/GraphicsEngine/interface/RenderDevice.h +++ b/Graphics/GraphicsEngine/interface/RenderDevice.h @@ -47,6 +47,7 @@ #include "Fence.h" #include "Query.h" #include "RenderPass.h" +#include "Framebuffer.h" #include "DepthStencilState.h" #include "RasterizerState.h" @@ -201,6 +202,19 @@ DILIGENT_BEGIN_INTERFACE(IRenderDevice, IObject) IRenderPass** ppRenderPass) PURE; + + /// Creates a framebuffer object + + /// \param [in] Desc - Framebuffer description, see Diligent::FramebufferDesc for details. + /// \param [out] ppFramebuffer - Address of the memory location where the pointer to the + /// framebuffer interface will be stored. + /// The function calls AddRef(), so that the new object will contain + /// one reference. + VIRTUAL void METHOD(CreateFramebuffer)(THIS_ + const FramebufferDesc REF Desc, + IFramebuffer** ppFramebuffer) PURE; + + /// Gets the device capabilities, see Diligent::DeviceCaps for details VIRTUAL const DeviceCaps REF METHOD(GetDeviceCaps)(THIS) CONST PURE; diff --git a/Graphics/GraphicsEngineD3D11/CMakeLists.txt b/Graphics/GraphicsEngineD3D11/CMakeLists.txt index 30a48152..ba6aeb46 100644 --- a/Graphics/GraphicsEngineD3D11/CMakeLists.txt +++ b/Graphics/GraphicsEngineD3D11/CMakeLists.txt @@ -14,6 +14,7 @@ set(INCLUDE include/EngineD3D11Defines.h include/pch.h include/FenceD3D11Impl.hpp + include/FramebufferD3D11Impl.hpp include/PipelineStateD3D11Impl.hpp include/QueryD3D11Impl.hpp include/RenderDeviceD3D11Impl.hpp @@ -59,6 +60,7 @@ set(SRC src/DeviceContextD3D11Impl.cpp src/EngineFactoryD3D11.cpp src/FenceD3D11Impl.cpp + src/FramebufferD3D11Impl.cpp src/GUIDDef.cpp src/PipelineStateD3D11Impl.cpp src/QueryD3D11Impl.cpp diff --git a/Graphics/GraphicsEngineD3D11/include/FramebufferD3D11Impl.hpp b/Graphics/GraphicsEngineD3D11/include/FramebufferD3D11Impl.hpp new file mode 100644 index 00000000..5449d4f9 --- /dev/null +++ b/Graphics/GraphicsEngineD3D11/include/FramebufferD3D11Impl.hpp @@ -0,0 +1,54 @@ +/* + * Copyright 2019-2020 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 + +/// \file +/// Declaration of Diligent::FramebufferD3D11Impl class + +#include "RenderDeviceD3D11.h" +#include "FramebufferBase.hpp" +#include "RenderDeviceD3D11Impl.hpp" + +namespace Diligent +{ + +class FixedBlockMemoryAllocator; + +/// Render pass implementation in Direct3D11 backend. +class FramebufferD3D11Impl final : public FramebufferBase +{ +public: + using TFramebufferBase = FramebufferBase; + + FramebufferD3D11Impl(IReferenceCounters* pRefCounters, + RenderDeviceD3D11Impl* pDevice, + const FramebufferDesc& Desc); + ~FramebufferD3D11Impl(); +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3D11/include/RenderDeviceD3D11Impl.hpp b/Graphics/GraphicsEngineD3D11/include/RenderDeviceD3D11Impl.hpp index 8f50f8f8..f041806c 100644 --- a/Graphics/GraphicsEngineD3D11/include/RenderDeviceD3D11Impl.hpp +++ b/Graphics/GraphicsEngineD3D11/include/RenderDeviceD3D11Impl.hpp @@ -85,6 +85,10 @@ public: virtual void DILIGENT_CALL_TYPE CreateRenderPass(const RenderPassDesc& Desc, IRenderPass** ppRenderPass) override final; + /// Implementation of IRenderDevice::CreateFramebuffer() in Direct3D11 backend. + virtual void DILIGENT_CALL_TYPE CreateFramebuffer(const FramebufferDesc& Desc, + IFramebuffer** ppFramebuffer) override final; + /// Implementation of IRenderDeviceD3D11::GetD3D11Device() in Direct3D11 backend. ID3D11Device* DILIGENT_CALL_TYPE GetD3D11Device() override final { return m_pd3d11Device; } diff --git a/Graphics/GraphicsEngineD3D11/src/FramebufferD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/FramebufferD3D11Impl.cpp new file mode 100644 index 00000000..469dc3c5 --- /dev/null +++ b/Graphics/GraphicsEngineD3D11/src/FramebufferD3D11Impl.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2019-2020 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. + */ + +#include "pch.h" + +#include "FramebufferD3D11Impl.hpp" +#include "EngineMemory.h" + +namespace Diligent +{ + +FramebufferD3D11Impl::FramebufferD3D11Impl(IReferenceCounters* pRefCounters, + RenderDeviceD3D11Impl* pDevice, + const FramebufferDesc& Desc) : + TFramebufferBase{pRefCounters, pDevice, Desc} +{ +} + +FramebufferD3D11Impl::~FramebufferD3D11Impl() +{ +} + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3D11/src/RenderDeviceD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/RenderDeviceD3D11Impl.cpp index 729eb687..d413ac5f 100644 --- a/Graphics/GraphicsEngineD3D11/src/RenderDeviceD3D11Impl.cpp +++ b/Graphics/GraphicsEngineD3D11/src/RenderDeviceD3D11Impl.cpp @@ -41,6 +41,7 @@ #include "FenceD3D11Impl.hpp" #include "QueryD3D11Impl.hpp" #include "RenderPassD3D11Impl.hpp" +#include "FramebufferD3D11Impl.hpp" #include "EngineMemory.h" namespace Diligent @@ -99,7 +100,8 @@ RenderDeviceD3D11Impl::RenderDeviceD3D11Impl(IReferenceCounters* pRefCo sizeof(ShaderResourceBindingD3D11Impl), sizeof(FenceD3D11Impl), sizeof(QueryD3D11Impl), - sizeof(RenderPassD3D11Impl) + sizeof(RenderPassD3D11Impl), + sizeof(FramebufferD3D11Impl) } }, m_EngineAttribs{EngineAttribs}, @@ -385,6 +387,17 @@ void RenderDeviceD3D11Impl::CreateRenderPass(const RenderPassDesc& Desc, IRender }); } +void RenderDeviceD3D11Impl::CreateFramebuffer(const FramebufferDesc& Desc, IFramebuffer** ppFramebuffer) +{ + CreateDeviceObject("Framebuffer", Desc, ppFramebuffer, + [&]() // + { + FramebufferD3D11Impl* pFramebufferD3D11(NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferD3D11Impl instance", FramebufferD3D11Impl)(this, Desc)); + pFramebufferD3D11->QueryInterface(IID_Framebuffer, reinterpret_cast(ppFramebuffer)); + OnCreateDeviceObject(pFramebufferD3D11); + }); +} + void RenderDeviceD3D11Impl::IdleGPU() { if (auto pImmediateCtx = m_wpImmediateContext.Lock()) diff --git a/Graphics/GraphicsEngineD3D12/CMakeLists.txt b/Graphics/GraphicsEngineD3D12/CMakeLists.txt index 06c2bfcf..f818813f 100644 --- a/Graphics/GraphicsEngineD3D12/CMakeLists.txt +++ b/Graphics/GraphicsEngineD3D12/CMakeLists.txt @@ -18,6 +18,7 @@ set(INCLUDE include/DeviceContextD3D12Impl.hpp include/D3D12DynamicHeap.hpp include/FenceD3D12Impl.hpp + include/FramebufferD3D12Impl.hpp include/GenerateMips.hpp include/pch.h include/PipelineStateD3D12Impl.hpp @@ -70,6 +71,7 @@ set(SRC src/D3D12DynamicHeap.cpp src/EngineFactoryD3D12.cpp src/FenceD3D12Impl.cpp + src/FramebufferD3D12Impl.cpp src/GenerateMips.cpp src/PipelineStateD3D12Impl.cpp src/QueryD3D12Impl.cpp diff --git a/Graphics/GraphicsEngineD3D12/include/FramebufferD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/FramebufferD3D12Impl.hpp new file mode 100644 index 00000000..59642660 --- /dev/null +++ b/Graphics/GraphicsEngineD3D12/include/FramebufferD3D12Impl.hpp @@ -0,0 +1,54 @@ +/* + * Copyright 2019-2020 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 + +/// \file +/// Declaration of Diligent::FramebufferD3D12Impl class + +#include "RenderDeviceD3D12.h" +#include "FramebufferBase.hpp" +#include "RenderDeviceD3D12Impl.hpp" + +namespace Diligent +{ + +class FixedBlockMemoryAllocator; + +/// Render pass implementation in Direct3D11 backend. +class FramebufferD3D12Impl final : public FramebufferBase +{ +public: + using TFramebufferBase = FramebufferBase; + + FramebufferD3D12Impl(IReferenceCounters* pRefCounters, + RenderDeviceD3D12Impl* pDevice, + const FramebufferDesc& Desc); + ~FramebufferD3D12Impl(); +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp b/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp index 3e0e841b..ddcc4f14 100644 --- a/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp +++ b/Graphics/GraphicsEngineD3D12/include/RenderDeviceD3D12Impl.hpp @@ -96,6 +96,10 @@ public: virtual void DILIGENT_CALL_TYPE CreateRenderPass(const RenderPassDesc& Desc, IRenderPass** ppRenderPass) override final; + /// Implementation of IRenderDevice::CreateFramebuffer() in Direct3D12 backend. + virtual void DILIGENT_CALL_TYPE CreateFramebuffer(const FramebufferDesc& Desc, + IFramebuffer** ppFramebuffer) override final; + /// Implementation of IRenderDeviceD3D12::GetD3D12Device(). virtual ID3D12Device* DILIGENT_CALL_TYPE GetD3D12Device() override final { return m_pd3d12Device; } diff --git a/Graphics/GraphicsEngineD3D12/src/FramebufferD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/FramebufferD3D12Impl.cpp new file mode 100644 index 00000000..38b8b956 --- /dev/null +++ b/Graphics/GraphicsEngineD3D12/src/FramebufferD3D12Impl.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2019-2020 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. + */ + +#include "pch.h" + +#include "FramebufferD3D12Impl.hpp" +#include "EngineMemory.h" + +namespace Diligent +{ + +FramebufferD3D12Impl::FramebufferD3D12Impl(IReferenceCounters* pRefCounters, + RenderDeviceD3D12Impl* pDevice, + const FramebufferDesc& Desc) : + TFramebufferBase{pRefCounters, pDevice, Desc} +{ +} + +FramebufferD3D12Impl::~FramebufferD3D12Impl() +{ +} + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp index f1d00587..381ecb95 100644 --- a/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp +++ b/Graphics/GraphicsEngineD3D12/src/RenderDeviceD3D12Impl.cpp @@ -39,6 +39,7 @@ #include "FenceD3D12Impl.hpp" #include "QueryD3D12Impl.hpp" #include "RenderPassD3D12Impl.hpp" +#include "FramebufferD3D12Impl.hpp" #include "EngineMemory.h" namespace Diligent @@ -111,7 +112,8 @@ RenderDeviceD3D12Impl::RenderDeviceD3D12Impl(IReferenceCounters* pRefCo sizeof(ShaderResourceBindingD3D12Impl), sizeof(FenceD3D12Impl), sizeof(QueryD3D12Impl), - sizeof(RenderPassD3D12Impl) + sizeof(RenderPassD3D12Impl), + sizeof(FramebufferD3D12Impl) } }, m_pd3d12Device {pd3d12Device}, @@ -535,6 +537,17 @@ void RenderDeviceD3D12Impl::CreateRenderPass(const RenderPassDesc& Desc, IRender }); } +void RenderDeviceD3D12Impl::CreateFramebuffer(const FramebufferDesc& Desc, IFramebuffer** ppFramebuffer) +{ + CreateDeviceObject("Framebuffer", Desc, ppFramebuffer, + [&]() // + { + FramebufferD3D12Impl* pFramebufferD3D12(NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferD3D12Impl instance", FramebufferD3D12Impl)(this, Desc)); + pFramebufferD3D12->QueryInterface(IID_Framebuffer, reinterpret_cast(ppFramebuffer)); + OnCreateDeviceObject(pFramebufferD3D12); + }); +} + DescriptorHeapAllocation RenderDeviceD3D12Impl::AllocateDescriptor(D3D12_DESCRIPTOR_HEAP_TYPE Type, UINT Count /*= 1*/) { VERIFY(Type >= D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV && Type < D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES, "Invalid heap type"); diff --git a/Graphics/GraphicsEngineMetal/include/FramebufferMtlImpl.h b/Graphics/GraphicsEngineMetal/include/FramebufferMtlImpl.h new file mode 100644 index 00000000..8bbde9c7 --- /dev/null +++ b/Graphics/GraphicsEngineMetal/include/FramebufferMtlImpl.h @@ -0,0 +1,54 @@ +/* + * Copyright 2019-2020 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 + +/// \file +/// Declaration of Diligent::FramebufferMtlImpl class + +#include "RenderDeviceMtl.h" +#include "FramebufferBase.hpp" +#include "RenderDeviceMtlImpl.hpp" + +namespace Diligent +{ + +class FixedBlockMemoryAllocator; + +/// Render pass implementation in Direct3D11 backend. +class FramebufferMtlImpl final : public FramebufferBase +{ +public: + using TFramebufferBase = FramebufferBase; + + FramebufferMtlImpl(IReferenceCounters* pRefCounters, + RenderDeviceMtlImpl* pDevice, + const FramebufferDesc& Desc); + ~FramebufferMtlImpl(); +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineMetal/include/RenderDeviceMtlImpl.h b/Graphics/GraphicsEngineMetal/include/RenderDeviceMtlImpl.h index 1a5693bb..5080ea59 100644 --- a/Graphics/GraphicsEngineMetal/include/RenderDeviceMtlImpl.h +++ b/Graphics/GraphicsEngineMetal/include/RenderDeviceMtlImpl.h @@ -63,6 +63,8 @@ public: virtual void CreateRenderPass(const RenderPassDesc& Desc, IRenderPass** ppRenderPass) override final; + virtual void CreateFramebuffer(const FramebufferDesc& Desc, IFramebuffer** ppFramebuffer) override final; + virtual void ReleaseStaleResources(bool ForceRelease = false) override final {} virtual void IdleGPU() override final; diff --git a/Graphics/GraphicsEngineMetal/src/FramebufferMtlImpl.mm b/Graphics/GraphicsEngineMetal/src/FramebufferMtlImpl.mm new file mode 100644 index 00000000..6cac14a6 --- /dev/null +++ b/Graphics/GraphicsEngineMetal/src/FramebufferMtlImpl.mm @@ -0,0 +1,41 @@ +/* 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 + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS. + * + * 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. + */ + +#include "FramebufferMtlImpl.h" +#include "EngineMemory.h" + +namespace Diligent +{ + +FramebufferMtlImpl :: FramebufferMtlImpl(IReferenceCounters* pRefCounters, + RenderDeviceMtlImpl* pDevice, + const FramebufferDesc& Desc) : + TQueryBase(pRefCounters, pDevice, Desc) +{ +} + +FramebufferMtlImpl :: ~FramebufferMtlImpl() +{ +} + +} diff --git a/Graphics/GraphicsEngineMetal/src/RenderDeviceMtlImpl.mm b/Graphics/GraphicsEngineMetal/src/RenderDeviceMtlImpl.mm index 7e7e57c5..93a98e6b 100644 --- a/Graphics/GraphicsEngineMetal/src/RenderDeviceMtlImpl.mm +++ b/Graphics/GraphicsEngineMetal/src/RenderDeviceMtlImpl.mm @@ -33,6 +33,7 @@ #include "ShaderResourceBindingMtlImpl.h" #include "FenceMtlImpl.h" #include "RenderPassMtlImpl.h" +#include "FramebufferMtlImpl.h" #include "EngineMemory.h" namespace Diligent @@ -60,7 +61,8 @@ RenderDeviceMtlImpl :: RenderDeviceMtlImpl(IReferenceCounters* pRefCounte sizeof(PipelineStateMtlImpl), sizeof(ShaderResourceBindingMtlImpl), sizeof(FenceMtlImpl), - sizeof(RenderPassMtlImpl) + sizeof(RenderPassMtlImpl), + sizeof(FramebufferMtlImpl) } }, m_EngineAttribs(EngineAttribs) @@ -199,6 +201,19 @@ void RenderDeviceMtlImpl::CreateRenderPass(const RenderPassDesc& Desc, IRenderPa ); } +void RenderDeviceMtlImpl::CreateFramebuffer(const FramebufferDesc& Desc, IFramebuffer** ppFramebuffer) +{ + CreateDeviceObject( "Framebuffer", Desc, ppFramebuffer, + [&]() + { + FramebufferMtlImpl* pFramebufferMtl( NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferMtlImpl instance", FramebufferMtlImpl) + (this, Desc) ); + pFramebufferMtl->QueryInterface( IID_Framebuffer, reinterpret_cast(ppFramebuffer) ); + OnCreateDeviceObject( pFramebufferMtl ); + } + ); +} + void RenderDeviceMtlImpl::IdleGPU() { LOG_ERROR_MESSAGE("RenderDeviceMtlImpl::IdleGPU() is not implemented"); diff --git a/Graphics/GraphicsEngineOpenGL/CMakeLists.txt b/Graphics/GraphicsEngineOpenGL/CMakeLists.txt index 52251b68..76c51a8c 100644 --- a/Graphics/GraphicsEngineOpenGL/CMakeLists.txt +++ b/Graphics/GraphicsEngineOpenGL/CMakeLists.txt @@ -9,6 +9,7 @@ set(INCLUDE include/DeviceContextGLImpl.hpp include/FBOCache.hpp include/FenceGLImpl.hpp + include/FramebufferGLImpl.hpp include/GLContext.hpp include/GLContextState.hpp include/GLObjectWrapper.hpp @@ -63,6 +64,7 @@ set(SOURCE src/EngineFactoryOpenGL.cpp src/FBOCache.cpp src/FenceGLImpl.cpp + src/FramebufferGLImpl.cpp src/GLContextState.cpp src/GLObjectWrapper.cpp src/GLProgramResourceCache.cpp diff --git a/Graphics/GraphicsEngineOpenGL/include/FramebufferGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/FramebufferGLImpl.hpp new file mode 100644 index 00000000..8144ffe3 --- /dev/null +++ b/Graphics/GraphicsEngineOpenGL/include/FramebufferGLImpl.hpp @@ -0,0 +1,54 @@ +/* + * Copyright 2019-2020 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 + +/// \file +/// Declaration of Diligent::FramebufferGLImpl class + +#include "RenderDeviceGL.h" +#include "FramebufferBase.hpp" +#include "RenderDeviceGLImpl.hpp" + +namespace Diligent +{ + +class FixedBlockMemoryAllocator; + +/// Render pass implementation in Direct3D11 backend. +class FramebufferGLImpl final : public FramebufferBase +{ +public: + using TFramebufferBase = FramebufferBase; + + FramebufferGLImpl(IReferenceCounters* pRefCounters, + RenderDeviceGLImpl* pDevice, + const FramebufferDesc& Desc); + ~FramebufferGLImpl(); +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp b/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp index 39084c3e..dbdb51c8 100644 --- a/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp +++ b/Graphics/GraphicsEngineOpenGL/include/RenderDeviceGLImpl.hpp @@ -117,6 +117,10 @@ public: virtual void DILIGENT_CALL_TYPE CreateRenderPass(const RenderPassDesc& Desc, IRenderPass** ppRenderPass) override final; + /// Implementation of IRenderDevice::CreateFramebuffer() in OpenGL backend. + virtual void DILIGENT_CALL_TYPE CreateFramebuffer(const FramebufferDesc& Desc, + IFramebuffer** ppFramebuffer) override final; + /// Implementation of IRenderDeviceGL::CreateTextureFromGLHandle(). virtual void DILIGENT_CALL_TYPE CreateTextureFromGLHandle(Uint32 GLHandle, Uint32 GLBindTarget, diff --git a/Graphics/GraphicsEngineOpenGL/src/FramebufferGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/FramebufferGLImpl.cpp new file mode 100644 index 00000000..6ec1d1f1 --- /dev/null +++ b/Graphics/GraphicsEngineOpenGL/src/FramebufferGLImpl.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2019-2020 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. + */ + +#include "pch.h" + +#include "FramebufferGLImpl.hpp" +#include "EngineMemory.h" + +namespace Diligent +{ + +FramebufferGLImpl::FramebufferGLImpl(IReferenceCounters* pRefCounters, + RenderDeviceGLImpl* pDevice, + const FramebufferDesc& Desc) : + TFramebufferBase{pRefCounters, pDevice, Desc} +{ +} + +FramebufferGLImpl::~FramebufferGLImpl() +{ +} + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp b/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp index bc38d364..6506c5df 100644 --- a/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp +++ b/Graphics/GraphicsEngineOpenGL/src/RenderDeviceGLImpl.cpp @@ -47,6 +47,7 @@ #include "FenceGLImpl.hpp" #include "QueryGLImpl.hpp" #include "RenderPassGLImpl.hpp" +#include "FramebufferGLImpl.hpp" #include "EngineMemory.h" #include "StringTools.hpp" @@ -77,7 +78,8 @@ RenderDeviceGLImpl::RenderDeviceGLImpl(IReferenceCounters* pRefCounters, sizeof(ShaderResourceBindingGLImpl), sizeof(FenceGLImpl), sizeof(QueryGLImpl), - sizeof(RenderPassGLImpl) + sizeof(RenderPassGLImpl), + sizeof(FramebufferGLImpl) } }, // Device caps must be filled in before the constructor of Pipeline Cache is called! @@ -530,6 +532,17 @@ void RenderDeviceGLImpl::CreateRenderPass(const RenderPassDesc& Desc, IRenderPas ); } +void RenderDeviceGLImpl::CreateFramebuffer(const FramebufferDesc& Desc, IFramebuffer** ppFramebuffer) +{ + CreateDeviceObject("Framebuffer", Desc, ppFramebuffer, + [&]() // + { + FramebufferGLImpl* pFramebufferGL(NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferGLImpl instance", FramebufferGLImpl)(this, Desc)); + pFramebufferGL->QueryInterface(IID_Framebuffer, reinterpret_cast(ppFramebuffer)); + OnCreateDeviceObject(pFramebufferGL); + }); +} + bool RenderDeviceGLImpl::CheckExtension(const Char* ExtensionString) { return m_ExtensionStrings.find(ExtensionString) != m_ExtensionStrings.end(); diff --git a/Graphics/GraphicsEngineVulkan/CMakeLists.txt b/Graphics/GraphicsEngineVulkan/CMakeLists.txt index 102044b7..26e89bba 100644 --- a/Graphics/GraphicsEngineVulkan/CMakeLists.txt +++ b/Graphics/GraphicsEngineVulkan/CMakeLists.txt @@ -11,6 +11,7 @@ set(INCLUDE include/DescriptorPoolManager.hpp include/DeviceContextVkImpl.hpp include/FenceVkImpl.hpp + include/FramebufferVkImpl.hpp include/VulkanDynamicHeap.hpp include/FramebufferCache.hpp include/GenerateMipsVkHelper.hpp @@ -80,6 +81,7 @@ set(SRC src/DeviceContextVkImpl.cpp src/EngineFactoryVk.cpp src/FenceVkImpl.cpp + src/FramebufferVkImpl.cpp src/VulkanDynamicHeap.cpp src/FramebufferCache.cpp src/GenerateMipsVkHelper.cpp diff --git a/Graphics/GraphicsEngineVulkan/include/FramebufferVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/FramebufferVkImpl.hpp new file mode 100644 index 00000000..63e56496 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/include/FramebufferVkImpl.hpp @@ -0,0 +1,53 @@ +/* + * Copyright 2019-2020 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 + +/// \file +/// Declaration of Diligent::FramebufferVkImpl class + +#include "FramebufferBase.hpp" +#include "RenderDeviceVkImpl.hpp" + +namespace Diligent +{ + +class FixedBlockMemoryAllocator; + +/// Render pass implementation in Direct3D11 backend. +class FramebufferVkImpl final : public FramebufferBase +{ +public: + using TFramebufferBase = FramebufferBase; + + FramebufferVkImpl(IReferenceCounters* pRefCounters, + RenderDeviceVkImpl* pDevice, + const FramebufferDesc& Desc); + ~FramebufferVkImpl(); +}; + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp index f339e33e..6ec79aad 100644 --- a/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp +++ b/Graphics/GraphicsEngineVulkan/include/RenderDeviceVkImpl.hpp @@ -102,6 +102,10 @@ public: virtual void DILIGENT_CALL_TYPE CreateRenderPass(const RenderPassDesc& Desc, IRenderPass** ppRenderPass) override final; + /// Implementation of IRenderDevice::CreateFramebuffer() in Vulkan backend. + virtual void DILIGENT_CALL_TYPE CreateFramebuffer(const FramebufferDesc& Desc, + IFramebuffer** ppFramebuffer) override final; + /// Implementation of IRenderDeviceVk::GetVkDevice(). virtual VkDevice DILIGENT_CALL_TYPE GetVkDevice() override final { return m_LogicalVkDevice->GetVkDevice(); } diff --git a/Graphics/GraphicsEngineVulkan/src/FramebufferVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/FramebufferVkImpl.cpp new file mode 100644 index 00000000..ba515950 --- /dev/null +++ b/Graphics/GraphicsEngineVulkan/src/FramebufferVkImpl.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2019-2020 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. + */ + +#include "pch.h" + +#include "FramebufferVkImpl.hpp" +#include "EngineMemory.h" + +namespace Diligent +{ + +FramebufferVkImpl::FramebufferVkImpl(IReferenceCounters* pRefCounters, + RenderDeviceVkImpl* pDevice, + const FramebufferDesc& Desc) : + TFramebufferBase{pRefCounters, pDevice, Desc} +{ +} + +FramebufferVkImpl::~FramebufferVkImpl() +{ +} + +} // namespace Diligent diff --git a/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp index 012cb58f..d5f38ade 100644 --- a/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp +++ b/Graphics/GraphicsEngineVulkan/src/RenderDeviceVkImpl.cpp @@ -38,6 +38,7 @@ #include "FenceVkImpl.hpp" #include "QueryVkImpl.hpp" #include "RenderPassVkImpl.hpp" +#include "FramebufferVkImpl.hpp" #include "EngineMemory.h" namespace Diligent @@ -73,7 +74,8 @@ RenderDeviceVkImpl::RenderDeviceVkImpl(IReferenceCounters* sizeof(ShaderResourceBindingVkImpl), sizeof(FenceVkImpl), sizeof(QueryVkImpl), - sizeof(RenderPassVkImpl) + sizeof(RenderPassVkImpl), + sizeof(FramebufferVkImpl) } }, m_VulkanInstance {Instance }, @@ -633,4 +635,15 @@ void RenderDeviceVkImpl::CreateRenderPass(const RenderPassDesc& Desc, IRenderPas ); } +void RenderDeviceVkImpl::CreateFramebuffer(const FramebufferDesc& Desc, IFramebuffer** ppFramebuffer) +{ + CreateDeviceObject("Framebuffer", Desc, ppFramebuffer, + [&]() // + { + FramebufferVkImpl* pFramebufferVk(NEW_RC_OBJ(m_FramebufferAllocator, "FramebufferVkImpl instance", FramebufferVkImpl)(this, Desc)); + pFramebufferVk->QueryInterface(IID_Framebuffer, reinterpret_cast(ppFramebuffer)); + OnCreateDeviceObject(pFramebufferVk); + }); +} + } // namespace Diligent -- cgit v1.2.3