├── .gitignore
├── CMakeLists.txt
├── LICENSE
├── README.md
├── cmake
    └── InitUCMake.cmake
├── config
    └── Config.cmake.in
├── include
    └── UDX12
    │   ├── Blob.h
    │   ├── CmdQueue.h
    │   ├── D3DInclude.h
    │   ├── Desc.h
    │   ├── DescriptorHeap
    │       ├── CPUDescriptorHeap.h
    │       ├── DescriptorHeapAllocMngr.h
    │       ├── DescriptorHeapAllocation.h
    │       ├── DescriptorHeapWrapper.h
    │       ├── DynamicSuballocMngr.h
    │       ├── GPUDescriptorHeap.h
    │       └── IDescriptorAllocator.h
    │   ├── DescriptorHeapMngr.h
    │   ├── Device.h
    │   ├── FrameGraph
    │       ├── Executor.h
    │       ├── FrameGraph.h
    │       ├── Rsrc.h
    │       └── RsrcMngr.h
    │   ├── FrameResource.h
    │   ├── FrameResourceMngr.h
    │   ├── GCmdList.h
    │   ├── MeshGPUBuffer.h
    │   ├── ResourceDeleteBatch.h
    │   ├── UDX12.h
    │   ├── UploadBuffer.h
    │   ├── Util.h
    │   ├── VarSizeAllocMngr.h
    │   ├── _deps
    │       ├── CMakeLists.txt
    │       └── DirectXTK12
    │       │   └── DirectXTK12.h
    │   └── details
    │       ├── FrameRsrcMngr.inl
    │       ├── GCmdList.inl
    │       └── UploadBuffer.inl
└── src
    ├── core
        ├── Blob.cpp
        ├── CMakeLists.txt
        ├── CmdQueue.cpp
        ├── D3DInclude.cpp
        ├── Desc.cpp
        ├── DescriptorHeap
        │   ├── CPUDescriptorHeap.cpp
        │   ├── DescriptorHeapAllocMngr.cpp
        │   ├── DescriptorHeapAllocation.cpp
        │   ├── DescriptorHeapWrapper.cpp
        │   ├── DynamicSuballocMngr.cpp
        │   ├── GPUDescriptorHeap.cpp
        │   └── IDescriptorAllocator.cpp
        ├── DescriptorHeapMngr.cpp
        ├── Device.cpp
        ├── FrameGraph
        │   ├── Executor.cpp
        │   └── RsrcMngr.cpp
        ├── FrameResource.cpp
        ├── FrameResourceMngr.cpp
        ├── GCmdList.cpp
        ├── MeshGPUBuffer.cpp
        ├── ResourceDeleteBatch.cpp
        ├── UploadBuffer.cpp
        ├── Util.cpp
        ├── VarSizeAllocMngr.cpp
        └── dxcapi.use.h
    └── test
        ├── 00_init
            ├── CMakeLists.txt
            └── InitDirect3DApp.cpp
        └── common
            ├── CMakeLists.txt
            ├── Camera.cpp
            ├── Camera.h
            ├── GameTimer.cpp
            ├── GameTimer.h
            ├── GeometryGenerator.cpp
            ├── GeometryGenerator.h
            ├── MathHelper.cpp
            ├── MathHelper.h
            ├── UploadBuffer.h
            ├── d3dApp.cpp
            ├── d3dApp.h
            ├── d3dUtil.cpp
            └── d3dUtil.h


/.gitignore:
--------------------------------------------------------------------------------
 1 | # antlr4 fils
 2 | *.java
 3 | *.interp
 4 | *.tokens
 5 | *.class
 6 | 
 7 | _deps/
 8 | 
 9 | # binary files
10 | *.png
11 | *.jpg
12 | *.bmp
13 | *.gif
14 | *.dds
15 | 
16 | *.zip
17 | *.7z
18 | *.rar
19 | 
20 | *.pdf
21 | 
22 | *.mp4
23 | 
24 | # directories
25 | resources/
26 | bin/
27 | lib/
28 | build/
29 | _deps/
30 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 2 | 
 3 | project(UDX12 VERSION 0.2.1)
 4 | message(STATUS "[Project] ${PROJECT_NAME}")
 5 | 
 6 | include(cmake/InitUCMake.cmake)
 7 | Ubpa_InitUCMake(VERSION 0.6.4)
 8 | 
 9 | Ubpa_InitProject()
10 | 
11 | Ubpa_DownloadZip(
12 |   https://udata-1308066321.cos.ap-guangzhou.myqcloud.com/DirectXTK12_20200603.zip
13 |   DirectXTK12.zip
14 |   SHA256 7AD7FF6131B72D223945BA66AC610230DD492D39D58AF94E839CED5CC7CA3085
15 | )
16 | 
17 | Ubpa_DownloadZip_Pro(
18 |   https://udata-1308066321.cos.ap-guangzhou.myqcloud.com/DXCompiler_20210512.zip
19 |   DXCompiler_20210512.zip
20 |   ${CMAKE_CURRENT_SOURCE_DIR}/bin
21 |   SHA256 86FC3DBD3086A0B2C5B0D1B9A79BCDE5D2D302FCA6441559BA3145FF5922EA6E
22 | )
23 | 
24 | Ubpa_AddDep(UTemplate 0.7.2)
25 | Ubpa_AddDep(UFG 0.6.0)
26 | Ubpa_AddDep(UThreadPool 0.1.0)
27 | 
28 | Ubpa_AddSubDirsRec(include)
29 | Ubpa_AddSubDirsRec(src)
30 | 
31 | Ubpa_Export(
32 |   TARGET
33 |   DIRECTORIES
34 |     "include"
35 | )
36 | 
37 | install(
38 |   FILES
39 |     "bin/dxcompiler.dll"
40 |     "bin/dxil.dll"
41 |   DESTINATION "bin"
42 | )
43 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Ubpa
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # UDX12
2 | Ubpa DirectX 12 C++ Wrapper
3 | 
4 | > 注意：VS2022 需要额外手动安装 ATL
5 | >
6 | > VS2022 -> 菜单栏 -> 工具 -> 获取工具和功能 -> 单个组件 -> 单个组件 -> 搜索 "ATL" -> 选择“适用于最新v143生成工具的 C++ ATL (x86 和 x64)”（其中 v143 应是最新版本的）
7 | 
8 | 


--------------------------------------------------------------------------------
/cmake/InitUCMake.cmake:
--------------------------------------------------------------------------------
 1 | macro(Ubpa_InitUCMake)
 2 |   cmake_parse_arguments(
 3 |     "ARG" # prefix
 4 |     "" #<options> # TRUE / FALSE
 5 |     "VERSION" # <one_value_keywords>
 6 |     "" #<multi_value_keywords> # list
 7 |     ${ARGN}
 8 |   )
 9 |   # 结果为 ARG_*
10 |   # - ARG_<option>
11 |   # - ARG_<one_value_keyword>
12 |   # - ARG_<multi_value_keyword>
13 |   
14 |   if("${ARG_VERSION}" STREQUAL "")
15 |     message(FATAL_ERROR "not provide argument <VERSION>")
16 |   endif()
17 |   
18 |   include(FetchContent)
19 |   set(UCMake_VERSION ${ARG_VERSION})
20 |   message(STATUS "find package: UCMake ${UCMake_VERSION}")
21 |   find_package(UCMake ${UCMake_VERSION} EXACT QUIET)
22 |   if(NOT UCMake_FOUND)
23 |     message(STATUS "UCMake ${UCMake_VERSION} not found")
24 |     set(_address "https://github.com/Ubpa/UCMake")
25 |     message(STATUS "fetch: ${_address} with tag ${UCMake_VERSION}")
26 |     FetchContent_Declare(
27 |       UCMake
28 |       GIT_REPOSITORY ${_address}
29 |       GIT_TAG ${UCMake_VERSION}
30 |     )
31 |     FetchContent_MakeAvailable(UCMake)
32 |     message(STATUS "UCMake ${UCMake_VERSION} build done")
33 |   endif()
34 | endmacro()
35 | 


--------------------------------------------------------------------------------
/config/Config.cmake.in:
--------------------------------------------------------------------------------
 1 | message(STATUS "config @PROJECT_NAME@ @PROJECT_VERSION@...")
 2 | 
 3 | @PACKAGE_INIT@
 4 | 
 5 | @UBPA_PACKAGE_INIT@
 6 | 
 7 | include ( "${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake" )
 8 | 
 9 | message(STATUS "config @PROJECT_NAME@ @PROJECT_VERSION@ done")
10 | 


--------------------------------------------------------------------------------
/include/UDX12/Blob.h:
--------------------------------------------------------------------------------
 1 | #pragma once 
 2 | 
 3 | #include "Util.h"
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 |     // ID3DBlob is a CPU buffer wrapper
 7 |     // raw : Microsoft::WRL::ComPtr<ID3DBlob>
 8 |     // .   : simple API
 9 |     // ->  : raw API
10 |     struct Blob : Util::ComPtrHolder<ID3DBlob> {
11 |         using Util::ComPtrHolder<ID3DBlob>::ComPtrHolder;
12 | 
13 |         void Create(SIZE_T size);
14 |         void Copy(const void* data, SIZE_T size);
15 |         void Create(const void* data, SIZE_T size);
16 |     };
17 | }
18 | 


--------------------------------------------------------------------------------
/include/UDX12/CmdQueue.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Util.h"
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 | 	struct CmdQueue : Util::ComPtrHolder<ID3D12CommandQueue> {
 7 | 		using Util::ComPtrHolder<ID3D12CommandQueue>::ComPtrHolder;
 8 | 		void Execute(ID3D12GraphicsCommandList* list);
 9 | 	};
10 | }
11 | 


--------------------------------------------------------------------------------
/include/UDX12/D3DInclude.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Util.h"
 4 | #include <fstream>
 5 | #include <filesystem>
 6 | 
 7 | namespace Ubpa::UDX12 {
 8 | 	// ref: http://nikvoss.com/2013/03/implementing-id3dinclude/
 9 | 	// TODO: multi system dir
10 | 	class D3DInclude : public ID3DInclude {
11 | 	public:
12 | 		D3DInclude(std::string localDir, std::string systemDir)
13 | 			: localDir(std::move(localDir)), systemDir(std::move(systemDir)) {}
14 | 
15 | 		HRESULT __stdcall Open(
16 | 			D3D_INCLUDE_TYPE IncludeType,
17 | 			LPCSTR pFileName,
18 | 			LPCVOID pParentData,
19 | 			LPCVOID* ppData,
20 | 			UINT* pBytes
21 | 		);
22 | 
23 | 		HRESULT __stdcall Close(LPCVOID pData);
24 | 	private:
25 | 		std::string localDir;
26 | 		std::string systemDir;
27 | 	};
28 | 
29 | 	class __declspec(uuid("22cbd10c-cf07-4d0a-81d6-54654278f83b"))
30 | 	DxcInclude : public IDxcIncludeHandler {
31 | 	public:
32 | 		static DxcInclude* New(ComPtr<IDxcLibrary> lib, std::string dir) {
33 | 			return new DxcInclude(lib, std::move(dir));
34 | 		}
35 | 
36 | 		virtual HRESULT __stdcall LoadSource(
37 | 			LPCWSTR pFilename,                                   // Candidate filename.
38 | 			IDxcBlob** ppIncludeSource  // Resultant source object for included file, nullptr if not found.
39 | 		) override;
40 | 
41 | 		HRESULT QueryInterface(REFIID riid, LPVOID* ppvObj) override;
42 | 
43 | 		virtual ULONG STDMETHODCALLTYPE AddRef(void) override;
44 | 
45 | 		virtual ULONG STDMETHODCALLTYPE Release(void) override;
46 | 
47 | 		void Clear();
48 | 	private:
49 | 		DxcInclude(ComPtr<IDxcLibrary> lib, std::string dir) : lib{ lib }, dir(std::move(dir)) {}
50 | 		~DxcInclude() { Clear(); }
51 | 
52 | 		std::atomic<ULONG> m_cRef{ 1 };
53 | 		ComPtr<IDxcLibrary> lib;
54 | 		std::string dir;
55 | 		std::vector<char*> buffers;
56 | 	};
57 | }
58 | 


--------------------------------------------------------------------------------
/include/UDX12/Desc.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Util.h"
 4 | 
 5 | namespace Ubpa::UDX12::Desc {
 6 |     namespace SRV {
 7 |         D3D12_SHADER_RESOURCE_VIEW_DESC Tex2D(DXGI_FORMAT format, UINT MipLevels = 1);
 8 |         D3D12_SHADER_RESOURCE_VIEW_DESC Tex3D(DXGI_FORMAT format, UINT MipLevels = 1);
 9 | 		D3D12_SHADER_RESOURCE_VIEW_DESC TexCube(DXGI_FORMAT format, UINT MipLevels = 1);
10 |     }
11 | 
12 |     namespace DSV {
13 |         D3D12_DEPTH_STENCIL_VIEW_DESC Basic(DXGI_FORMAT format);
14 |     }
15 | 
16 | 	namespace PSO {
17 | 		D3D12_GRAPHICS_PIPELINE_STATE_DESC Basic(
18 | 			ID3D12RootSignature* rootSig,
19 | 			const D3D12_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements,
20 |             const ID3DBlob* VS,
21 |             const ID3DBlob* PS,
22 | 			DXGI_FORMAT rtvFormat,
23 | 			DXGI_FORMAT dsvFormat = DXGI_FORMAT_D24_UNORM_S8_UINT);
24 | 
25 |         D3D12_GRAPHICS_PIPELINE_STATE_DESC MRT(
26 |             ID3D12RootSignature* rootSig,
27 |             const D3D12_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements,
28 |             const ID3DBlob* VS,
29 |             const ID3DBlob* PS,
30 |             UINT rtNum,
31 |             DXGI_FORMAT rtvFormat,
32 |             DXGI_FORMAT dsvFormat = DXGI_FORMAT_D24_UNORM_S8_UINT);
33 |     }
34 | 
35 |     namespace RTV {
36 | 		D3D12_RENDER_TARGET_VIEW_DESC Tex2DofTexCube(
37 | 			DXGI_FORMAT format,
38 | 			UINT Index,
39 | 			UINT MipSlice = 0
40 |         );
41 |     }
42 | 
43 | 	namespace RSRC {
44 |         D3D12_RESOURCE_DESC Basic(
45 |             D3D12_RESOURCE_DIMENSION dimension,
46 |             UINT64 Width,
47 |             UINT Height,
48 |             DXGI_FORMAT format,
49 |             D3D12_RESOURCE_FLAGS flags);
50 | 
51 |         D3D12_RESOURCE_DESC RT2D(
52 |             UINT64 Width,
53 |             UINT Height,
54 |             DXGI_FORMAT format);
55 | 
56 | 		D3D12_RESOURCE_DESC TextureCube(
57 | 			UINT64 Width,
58 | 			UINT Height,
59 | 			UINT MipLevels,
60 | 			DXGI_FORMAT format,
61 | 			D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET
62 | 		);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/CPUDescriptorHeap.h:
--------------------------------------------------------------------------------
 1 | // ref
 2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/
 3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/include/DescriptorHeap.hpp
 4 | // 3. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/src/DescriptorHeap.cpp
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "IDescriptorAllocator.h"
 9 | #include "DescriptorHeapAllocMngr.h"
10 | 
11 | #include <unordered_set>
12 | 
13 | namespace Ubpa::UDX12 {
14 | 	// CPU descriptor heap is intended to provide storage for resource view descriptor handles.
15 |     // It contains a pool of DescriptorHeapAllocationManager object instances, where every instance manages
16 |     // its own CPU-only D3D12 descriptor heap:
17 |     //
18 |     //           m_HeapPool[0]                m_HeapPool[1]                 m_HeapPool[2]
19 |     //   |  X  X  X  X  X  X  X  X |, |  X  X  X  O  O  X  X  O  |, |  X  O  O  O  O  O  O  O  |
20 |     //
21 |     //    X - used descriptor                m_AvailableHeaps = {1,2}
22 |     //    O - available descriptor
23 |     //
24 |     // Allocation routine goes through the list of managers that have available descriptors and tries to process
25 |     // the request using every manager. If there are no available managers or no manager was able to handle the request,
26 |     // the function creates a new descriptor heap manager and lets it handle the request
27 |     //
28 |     // Render device contains four CPUDescriptorHeap object instances (one for each D3D12 heap type). The heaps are accessed
29 |     // when a texture or a buffer view is created.
30 |     //
31 |     class CPUDescriptorHeap final : public IDescriptorAllocator {
32 |     public:
33 |         // Initializes the heap
34 |         CPUDescriptorHeap(ID3D12Device*               pDevice,
35 |                           uint32_t                    NumDescriptorsInHeap,
36 |                           D3D12_DESCRIPTOR_HEAP_TYPE  Type,
37 |                           D3D12_DESCRIPTOR_HEAP_FLAGS Flags);
38 | 
39 |         CPUDescriptorHeap            (const CPUDescriptorHeap&) = delete;
40 |         CPUDescriptorHeap            (CPUDescriptorHeap&&)      = delete;
41 |         CPUDescriptorHeap& operator= (const CPUDescriptorHeap&) = delete;
42 |         CPUDescriptorHeap& operator= (CPUDescriptorHeap&&)      = delete;
43 | 
44 |         ~CPUDescriptorHeap();
45 | 
46 |         virtual DescriptorHeapAllocation Allocate(uint32_t Count) override final;
47 |         virtual void                     Free(DescriptorHeapAllocation&& Allocation) override final;
48 |         virtual uint32_t                 GetDescriptorSize() const noexcept override final { return m_DescriptorSize; }
49 | 
50 |     private:
51 |         ID3D12Device* m_pDevice;
52 | 
53 |         // Pool of descriptor heap managers
54 |         std::mutex                                    m_HeapPoolMutex;
55 |         std::vector<DescriptorHeapAllocMngr>          m_HeapPool;
56 |         // Indices of available descriptor heap managers
57 |         std::unordered_set<size_t>                    m_AvailableHeaps;
58 | 
59 |         D3D12_DESCRIPTOR_HEAP_DESC m_HeapDesc;
60 |         const UINT                 m_DescriptorSize = 0;
61 | 
62 |         // Maximum heap size during the application lifetime - for statistic purposes
63 |         uint32_t m_MaxSize     = 0;
64 |         uint32_t m_CurrentSize = 0;
65 |     };
66 | }
67 | 


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/DescriptorHeapAllocMngr.h:
--------------------------------------------------------------------------------
 1 | // ref
 2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/
 3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/include/DescriptorHeap.hpp
 4 | // 3. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/src/DescriptorHeap.cpp
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "IDescriptorAllocator.h"
 9 | 
10 | #include "../VarSizeAllocMngr.h"
11 | 
12 | #include <mutex>
13 | 
14 | namespace Ubpa::UDX12 {
15 |     // The class performs suballocations within one D3D12 descriptor heap.
16 |     // It uses VariableSizeAllocationsManager to manage free space in the heap
17 |     //
18 |     // |  X  X  X  X  O  O  O  X  X  O  O  X  O  O  O  O  |  D3D12 descriptor heap
19 |     //
20 |     //  X - used descriptor
21 |     //  O - available descriptor
22 |     //
23 |     class DescriptorHeapAllocMngr {
24 |     public:
25 |         // Creates a new D3D12 descriptor heap
26 |         DescriptorHeapAllocMngr(ID3D12Device*                     pDevice,
27 |                                 IDescriptorAllocator&             ParentAllocator,
28 |                                 size_t                            ThisManagerId,
29 |                                 const D3D12_DESCRIPTOR_HEAP_DESC& HeapDesc);
30 | 
31 |         // Uses subrange of descriptors in the existing D3D12 descriptor heap
32 |         // that starts at offset FirstDescriptor and uses NumDescriptors descriptors
33 |         DescriptorHeapAllocMngr(ID3D12Device*          pDevice,
34 |                                 IDescriptorAllocator&  ParentAllocator,
35 |                                 size_t                 ThisManagerId,
36 |                                 ID3D12DescriptorHeap*  pd3d12DescriptorHeap,
37 |                                 uint32_t               FirstDescriptor,
38 |                                 uint32_t               NumDescriptors);
39 | 
40 |         // = default causes compiler error when instantiating std::vector::emplace_back() in Visual Studio 2015 (Version 14.0.23107.0 D14REL)
41 |         DescriptorHeapAllocMngr(DescriptorHeapAllocMngr&& rhs) noexcept;
42 | 
43 |         // No copies or move-assignments
44 |         DescriptorHeapAllocMngr& operator= (DescriptorHeapAllocMngr&&)      = delete;
45 |         DescriptorHeapAllocMngr            (const DescriptorHeapAllocMngr&) = delete;
46 |         DescriptorHeapAllocMngr& operator= (const DescriptorHeapAllocMngr&) = delete;
47 | 
48 |         ~DescriptorHeapAllocMngr();
49 | 
50 |         // Allocates Count descriptors
51 |         DescriptorHeapAllocation Allocate(uint32_t Count);
52 |         void                     FreeAllocation(DescriptorHeapAllocation&& Allocation);
53 | 
54 |         size_t   GetNumAvailableDescriptors() const noexcept { return m_FreeBlockManager.GetFreeSize(); }
55 | 	    uint32_t GetMaxDescriptors()          const noexcept { return m_NumDescriptorsInAllocation;     }
56 |         size_t   GetMaxAllocatedSize()        const noexcept { return m_MaxAllocatedSize;               }
57 | 
58 |     private:
59 |         IDescriptorAllocator&  m_ParentAllocator;
60 |         ID3D12Device* m_pDevice;
61 | 
62 |         // External ID assigned to this descriptor allocations manager
63 |         size_t m_ThisManagerId{ static_cast<size_t>(-1) };
64 | 
65 |         // Heap description
66 |         const D3D12_DESCRIPTOR_HEAP_DESC m_HeapDesc;
67 | 
68 |         const UINT m_DescriptorSize{ 0 };
69 | 
70 |         // Number of descriptors in the allocation.
71 |         // If this manager was initialized as a subrange in the existing heap,
72 |         // this value may be different from m_HeapDesc.NumDescriptors
73 |         uint32_t m_NumDescriptorsInAllocation{ 0 };
74 | 
75 |         // Allocations manager used to handle descriptor allocations within the heap
76 |         std::mutex                     m_FreeBlockManagerMutex;
77 |         VarSizeAllocMngr               m_FreeBlockManager;
78 | 
79 |         // Strong reference to D3D12 descriptor heap object
80 |         CComPtr<ID3D12DescriptorHeap>  m_pd3d12DescriptorHeap;
81 | 
82 |         // First CPU descriptor handle in the available descriptor range
83 |         D3D12_CPU_DESCRIPTOR_HANDLE    m_FirstCPUHandle{ 0 };
84 | 
85 |         // First GPU descriptor handle in the available descriptor range
86 |         D3D12_GPU_DESCRIPTOR_HANDLE    m_FirstGPUHandle{ 0 };
87 | 
88 |         size_t m_MaxAllocatedSize{ 0 };
89 | 
90 | #ifndef NDEBUG
91 |         std::atomic_int32_t m_AllocationsCounter = 0;
92 | #endif // !NDEBUG
93 |     };
94 | }
95 | 


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/DescriptorHeapAllocation.h:
--------------------------------------------------------------------------------
 1 | // ref
 2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/
 3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/include/DescriptorHeap.hpp
 4 | // 3. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/src/DescriptorHeap.cpp
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "IDescriptorAllocator.h"
 9 | 
10 | namespace Ubpa::UDX12 {
11 |     // The class represents descriptor heap allocation (continuous descriptor range in a descriptor heap)
12 |     //
13 |     //                  m_FirstCpuHandle
14 |     //                   |
15 |     //  | ~  ~  ~  ~  ~  X  X  X  X  X  X  X  ~  ~  ~  ~  ~  ~ |  D3D12 Descriptor Heap
16 |     //                   |
17 |     //                  m_FirstGpuHandle
18 |     //
19 |     class DescriptorHeapAllocation {
20 |     public:
21 |         // Creates null allocation
22 |         DescriptorHeapAllocation() noexcept;
23 | 
24 |         // Initializes non-null allocation
25 |         DescriptorHeapAllocation(
26 |             IDescriptorAllocator*       pAllocator,
27 |             ID3D12DescriptorHeap*       pHeap,
28 |             D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle,
29 |             D3D12_GPU_DESCRIPTOR_HANDLE GpuHandle,
30 |             uint32_t                    NHandles,
31 |             uint16_t                    AllocationManagerId
32 |         ) noexcept;
33 | 
34 |         // Move constructor (copy is not allowed)
35 |         DescriptorHeapAllocation(DescriptorHeapAllocation&& Allocation) noexcept;
36 | 
37 |         // Destructor automatically releases this allocation through the allocator
38 |         ~DescriptorHeapAllocation();
39 | 
40 |         // Move assignment (assignment is not allowed)
41 |         DescriptorHeapAllocation& operator=(DescriptorHeapAllocation&& Allocation) noexcept;
42 | 
43 |         void Reset() noexcept;
44 | 
45 |         DescriptorHeapAllocation(const DescriptorHeapAllocation&) = delete;
46 |         DescriptorHeapAllocation& operator=(const DescriptorHeapAllocation&) = delete;
47 | 
48 |         // Returns CPU descriptor handle at the specified offset
49 |         D3D12_CPU_DESCRIPTOR_HANDLE GetCpuHandle(uint32_t Offset = 0) const noexcept {
50 |             assert(Offset >= 0 && Offset < m_NumHandles);
51 |             return { m_FirstCpuHandle.ptr + m_DescriptorSize * Offset };
52 |         }
53 | 
54 |         // Returns GPU descriptor handle at the specified offset
55 |         D3D12_GPU_DESCRIPTOR_HANDLE GetGpuHandle(uint32_t Offset = 0) const noexcept {
56 |             assert(Offset >= 0 && Offset < m_NumHandles);
57 |             return { m_FirstGpuHandle.ptr + m_DescriptorSize * Offset };
58 |         }
59 | 
60 |         // Returns pointer to D3D12 descriptor heap that contains this allocation
61 |         ID3D12DescriptorHeap* GetDescriptorHeap() const noexcept { return m_pDescriptorHeap; }
62 | 
63 |         uint32_t GetNumHandles()          const noexcept { return m_NumHandles; }
64 |         bool     IsNull()                 const noexcept { return m_FirstCpuHandle.ptr == 0; }
65 |         bool     IsShaderVisible()        const noexcept { return m_FirstGpuHandle.ptr != 0; }
66 |         uint16_t GetAllocationManagerId() const noexcept { return m_AllocationManagerId; }
67 |         uint16_t GetDescriptorSize()      const noexcept { return m_DescriptorSize; }
68 | 
69 |     private:
70 |         // First CPU descriptor handle in this allocation
71 |         D3D12_CPU_DESCRIPTOR_HANDLE m_FirstCpuHandle{ 0 };
72 | 
73 |         // First GPU descriptor handle in this allocation
74 |         D3D12_GPU_DESCRIPTOR_HANDLE m_FirstGpuHandle{ 0 };
75 | 
76 |         // Pointer to the descriptor heap allocator that created this allocation
77 |         IDescriptorAllocator* m_pAllocator{ nullptr };
78 | 
79 |         // Pointer to the D3D12 descriptor heap that contains descriptors in this allocation
80 |         ID3D12DescriptorHeap* m_pDescriptorHeap{ nullptr };
81 | 
82 |         // Number of descriptors in the allocation
83 |         uint32_t m_NumHandles{ 0 };
84 | 
85 |         // Allocation manager ID. One allocator may support several
86 |         // allocation managers. This field is required to identify
87 |         // the manager within the allocator that was used to create
88 |         // this allocation
89 |         uint16_t m_AllocationManagerId{ static_cast<uint16_t>(-1) };
90 | 
91 |         // Descriptor size
92 |         uint16_t m_DescriptorSize{ 0 };
93 |     };
94 | }
95 | 


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/DescriptorHeapWrapper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../Util.h"
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 |     // ref: https://docs.microsoft.com/en-us/windows/win32/direct3d12/creating-descriptor-heaps
 7 |     class DescriptorHeapWrapper : Util::ComPtrHolder<ID3D12DescriptorHeap> {
 8 |     public:
 9 |         DescriptorHeapWrapper() { memset(this, 0, sizeof(DescriptorHeapWrapper)); }
10 | 
11 |         HRESULT Create(
12 |             ID3D12Device* pDevice,
13 |             const D3D12_DESCRIPTOR_HEAP_DESC* desc);
14 | 
15 |         HRESULT Create(
16 |             ID3D12Device* pDevice,
17 |             D3D12_DESCRIPTOR_HEAP_TYPE Type,
18 |             UINT NumDescriptors,
19 |             bool bShaderVisible = false);
20 | 
21 |         void Clear() {
22 |             raw.Reset();
23 |             memset(this, 0, sizeof(DescriptorHeapWrapper));
24 |         }
25 | 
26 |         UINT Size() const noexcept {
27 |             if (IsNull())
28 |                 return 0;
29 | 
30 |             return Desc.NumDescriptors;
31 |         }
32 | 
33 |         bool Empty() const noexcept { return Size() == 0; }
34 | 
35 |         operator ID3D12DescriptorHeap* () const noexcept { return raw.Get(); }
36 | 
37 |         D3D12_CPU_DESCRIPTOR_HANDLE hCPU(UINT index) const noexcept
38 |         { return { hCPUHeapStart.ptr + index * HandleIncrementSize }; }
39 | 
40 |         D3D12_GPU_DESCRIPTOR_HANDLE hGPU(UINT index) const noexcept {
41 |             assert(Desc.Flags & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE);
42 |             return { hGPUHeapStart.ptr + index * HandleIncrementSize };
43 |         }
44 | 
45 |     private:
46 |         D3D12_DESCRIPTOR_HEAP_DESC Desc;
47 |         D3D12_CPU_DESCRIPTOR_HANDLE hCPUHeapStart;
48 |         D3D12_GPU_DESCRIPTOR_HANDLE hGPUHeapStart;
49 |         UINT HandleIncrementSize;
50 |     };
51 | }
52 | 


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/DynamicSuballocMngr.h:
--------------------------------------------------------------------------------
 1 | // ref
 2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/
 3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/include/DescriptorHeap.hpp
 4 | // 3. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/src/DescriptorHeap.cpp
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "IDescriptorAllocator.h"
 9 | #include "GPUDescriptorHeap.h"
10 | 
11 | namespace Ubpa::UDX12 {
12 |     // The class facilitates allocation of dynamic descriptor handles. It requests a chunk of heap
13 |     // from the master GPU descriptor heap and then performs linear suballocation within the chunk
14 |     // At the end of the frame all allocations are disposed.
15 | 
16 |     //     static and mutable handles     ||                 dynamic space
17 |     //                                    ||    chunk 0                 chunk 2
18 |     //  |                                 ||  | X X X O |             | O O O O |           || GPU Descriptor Heap
19 |     //                                        |                       |
20 |     //                                        m_Suballocations[0]     m_Suballocations[1]
21 |     //
22 | 	class DynamicSuballocMngr final : public IDescriptorAllocator {
23 |     public:
24 |         DynamicSuballocMngr(
25 |             GPUDescriptorHeap* ParentGPUHeap,
26 |             uint32_t           DynamicChunkSize,
27 |             std::string        ManagerName) noexcept;
28 | 
29 |         DynamicSuballocMngr            (const DynamicSuballocMngr&) = delete;
30 |         DynamicSuballocMngr            (DynamicSuballocMngr&&)      = delete;
31 |         DynamicSuballocMngr& operator= (const DynamicSuballocMngr&) = delete;
32 |         DynamicSuballocMngr& operator= (DynamicSuballocMngr&&)      = delete;
33 | 
34 |         ~DynamicSuballocMngr();
35 | 
36 |         virtual DescriptorHeapAllocation Allocate(uint32_t count) override final;
37 |         virtual void                     Free(DescriptorHeapAllocation&& allocation) noexcept override final {
38 |             // Do nothing. Dynamic allocations are not disposed individually, but as whole chunks
39 |             // at the end of the frame by ReleaseAllocations()
40 |             allocation.Reset();
41 |         }
42 | 
43 |         void ReleaseAllocations();
44 | 
45 |         virtual uint32_t GetDescriptorSize() const noexcept override final { return m_ParentGPUHeap->GetDescriptorSize(); }
46 | 
47 |         size_t GetSuballocationCount() const noexcept { return m_Suballocations.size(); }
48 | 
49 |     private:
50 |         // Parent GPU descriptor heap that is used to allocate chunks
51 |         GPUDescriptorHeap* m_ParentGPUHeap;
52 |         std::string        m_ManagerName;
53 | 
54 |         // List of chunks allocated from the master GPU descriptor heap. All chunks are disposed at the end
55 |         // of the frame
56 |         std::vector<DescriptorHeapAllocation> m_Suballocations;
57 | 
58 |         uint32_t m_CurrentSuballocationOffset = 0;
59 |         uint32_t m_DynamicChunkSize           = 0;
60 | 
61 |         uint32_t m_CurrDescriptorCount         = 0;
62 |         uint32_t m_PeakDescriptorCount         = 0;
63 |         uint32_t m_CurrSuballocationsTotalSize = 0;
64 |         uint32_t m_PeakSuballocationsTotalSize = 0;
65 |     };
66 | }


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/GPUDescriptorHeap.h:
--------------------------------------------------------------------------------
 1 | // ref
 2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/
 3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/include/DescriptorHeap.hpp
 4 | // 3. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/src/DescriptorHeap.cpp
 5 | 
 6 | #pragma once
 7 | 
 8 | #include "IDescriptorAllocator.h"
 9 | #include "DescriptorHeapAllocation.h"
10 | #include "DescriptorHeapAllocMngr.h"
11 | 
12 | namespace Ubpa::UDX12 {
13 | 	// GPU descriptor heap provides storage for shader-visible descriptors
14 |     // The heap contains single D3D12 descriptor heap that is split into two parts.
15 |     // The first part stores static and mutable resource descriptor handles.
16 |     // The second part is intended to provide temporary storage for dynamic resources.
17 |     // Space for dynamic resources is allocated in chunks, and then descriptors are suballocated within every
18 |     // chunk. DynamicSuballocMngr facilitates this process.
19 |     //
20 |     //
21 |     //     static and mutable handles      ||                 dynamic space
22 |     //                                     ||    chunk 0     chunk 1     chunk 2     unused
23 |     //  | X O O X X O X O O O O X X X X O  ||  | X X X O | | X X O O | | O O O O |  O O O O  ||
24 |     //                                               |         |
25 |     //                                     suballocation       suballocation
26 |     //                                    within chunk 0       within chunk 1
27 |     //
28 |     // Render device contains two GPUDescriptorHeap instances (CBV_SRV_UAV and SAMPLER). The heaps
29 |     // are used to allocate GPU-visible descriptors for shader resource binding objects. The heaps
30 |     // are also used by the command contexts (through DynamicSuballocMngr to allocated dynamic descriptors)
31 |     //
32 |     //  _______________________________________________________________________________________________________________________________
33 |     // | Render Device                                                                                                                 |
34 |     // |                                                                                                                               |
35 |     // | m_CPUDescriptorHeaps[CBV_SRV_UAV] |  X  X  X  X  X  X  X  X  |, |  X  X  X  X  X  X  X  X  |, |  X  O  O  X  O  O  O  O  |    |
36 |     // | m_CPUDescriptorHeaps[SAMPLER]     |  X  X  X  X  O  O  O  X  |, |  X  O  O  X  O  O  O  O  |                                  |
37 |     // | m_CPUDescriptorHeaps[RTV]         |  X  X  X  O  O  O  O  O  |, |  O  O  O  O  O  O  O  O  |                                  |
38 |     // | m_CPUDescriptorHeaps[DSV]         |  X  X  X  O  X  O  X  O  |                                                                |
39 |     // |                                                                               ctx1        ctx2                                |
40 |     // | m_GPUDescriptorHeaps[CBV_SRV_UAV]  | X O O X X O X O O O O X X X X O  ||  | X X X O | | X X O O | | O O O O |  O O O O  ||    |
41 |     // | m_GPUDescriptorHeaps[SAMPLER]      | X X O O X O X X X O O X O O O O  ||  | X X O O | | X O O O | | O O O O |  O O O O  ||    |
42 |     // |                                                                                                                               |
43 |     // |_______________________________________________________________________________________________________________________________|
44 |     //
45 |     //  ________________________________________________               ________________________________________________
46 |     // |Device Context 1                                |             |Device Context 2                                |
47 |     // |                                                |             |                                                |
48 |     // | m_DynamicGPUDescriptorAllocator[CBV_SRV_UAV]   |             | m_DynamicGPUDescriptorAllocator[CBV_SRV_UAV]   |
49 |     // | m_DynamicGPUDescriptorAllocator[SAMPLER]       |             | m_DynamicGPUDescriptorAllocator[SAMPLER]       |
50 |     // |________________________________________________|             |________________________________________________|
51 |     //
52 |     class GPUDescriptorHeap final : public IDescriptorAllocator {
53 |     public:
54 |         GPUDescriptorHeap(ID3D12Device*               pDevice,
55 |                           uint32_t                    NumDescriptorsInHeap,
56 |                           uint32_t                    NumDynamicDescriptors,
57 |                           D3D12_DESCRIPTOR_HEAP_TYPE  Type,
58 |                           D3D12_DESCRIPTOR_HEAP_FLAGS Flags);
59 | 
60 |         GPUDescriptorHeap            (const GPUDescriptorHeap&) = delete;
61 |         GPUDescriptorHeap            (GPUDescriptorHeap&&)      = delete;
62 |         GPUDescriptorHeap& operator= (const GPUDescriptorHeap&) = delete;
63 |         GPUDescriptorHeap& operator= (GPUDescriptorHeap&&)      = delete;
64 | 
65 |         virtual DescriptorHeapAllocation Allocate(uint32_t count) override final
66 |         { return m_HeapAllocationManager.Allocate(count); }
67 | 
68 |         DescriptorHeapAllocation AllocateDynamic(uint32_t count)
69 |         { return m_DynamicAllocationsManager.Allocate(count); }
70 | 
71 |         virtual void     Free(DescriptorHeapAllocation&&) override final;
72 |         virtual uint32_t GetDescriptorSize() const override final { return m_DescriptorSize; }
73 | 
74 |         const D3D12_DESCRIPTOR_HEAP_DESC& GetHeapDesc() const noexcept { return m_HeapDesc; }
75 |         uint32_t                          GetMaxStaticDescriptors() const noexcept { return m_HeapAllocationManager.GetMaxDescriptors(); }
76 |         uint32_t                          GetMaxDynamicDescriptors() const noexcept { return m_DynamicAllocationsManager.GetMaxDescriptors(); }
77 |         ID3D12DescriptorHeap*             GetDescriptorHeap() const noexcept { return m_pd3d12DescriptorHeap.p; }
78 | 
79 |     protected:
80 |         ID3D12Device* m_Device;
81 | 
82 |         const D3D12_DESCRIPTOR_HEAP_DESC m_HeapDesc;
83 |         CComPtr<ID3D12DescriptorHeap>    m_pd3d12DescriptorHeap;
84 | 
85 |         const UINT m_DescriptorSize;
86 | 
87 |         static constexpr size_t StaticHeapAllocatonManagerID  = 0;
88 |         static constexpr size_t DynamicHeapAllocatonManagerID = 1;
89 | 
90 |         // Allocation manager for static/mutable part
91 |         DescriptorHeapAllocMngr m_HeapAllocationManager;
92 | 
93 |         // Allocation manager for dynamic part
94 |         DescriptorHeapAllocMngr m_DynamicAllocationsManager;
95 |     };
96 | }


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeap/IDescriptorAllocator.h:
--------------------------------------------------------------------------------
 1 | // ref
 2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/
 3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/master/Graphics/GraphicsEngineD3D12/include/DescriptorHeap.hpp
 4 | 
 5 | #pragma once
 6 | 
 7 | #include "../Util.h"
 8 | 
 9 | namespace Ubpa::UDX12 {
10 |     class DescriptorHeapAllocation;
11 |     class DescriptorHeapAllocMngr;
12 |     class RenderpDevice;
13 | 
14 |     class IDescriptorAllocator {
15 |     public:
16 |         // Allocate Count descriptors
17 |         virtual DescriptorHeapAllocation Allocate(uint32_t Count) = 0;
18 |         virtual void Free(DescriptorHeapAllocation&& Allocation) = 0;
19 |         virtual uint32_t GetDescriptorSize() const = 0;
20 |     };
21 | }
22 | 


--------------------------------------------------------------------------------
/include/UDX12/DescriptorHeapMngr.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "DescriptorHeap/CPUDescriptorHeap.h"
 4 | #include "DescriptorHeap/DescriptorHeapAllocation.h"
 5 | #include "DescriptorHeap/DescriptorHeapAllocMngr.h"
 6 | #include "DescriptorHeap/DynamicSuballocMngr.h"
 7 | #include "DescriptorHeap/GPUDescriptorHeap.h"
 8 | #include "DescriptorHeap/IDescriptorAllocator.h"
 9 | 
10 | namespace Ubpa::UDX12 {
11 | 	class DescriptorHeapMngr {
12 | 	public:
13 | 		static DescriptorHeapMngr& Instance() noexcept {
14 | 			static DescriptorHeapMngr instance;
15 | 			return instance;
16 | 		}
17 | 
18 | 		void Init(
19 | 			ID3D12Device* device,
20 | 			uint32_t numCpuCSU,
21 | 			uint32_t numCpuRTV,
22 | 			uint32_t numCpuDSV,
23 | 			uint32_t numGpuCSU_static,
24 | 			uint32_t numGpuCSU_dynamic
25 | 		);
26 | 
27 | 		CPUDescriptorHeap* GetCSUCpuDH() const noexcept { assert(isInit); return CSU_CpuDH; }
28 | 		CPUDescriptorHeap* GetRTVCpuDH() const noexcept { assert(isInit); return RTV_CpuDH; }
29 | 		CPUDescriptorHeap* GetDSVCpuDH() const noexcept { assert(isInit); return DSV_CpuDH; }
30 | 		GPUDescriptorHeap* GetCSUGpuDH() const noexcept { assert(isInit); return CSU_GpuDH; }
31 | 
32 | 		void Clear();
33 | 
34 | 	private:
35 | 		DescriptorHeapMngr() = default;
36 | 		~DescriptorHeapMngr();
37 | 
38 | 		bool isInit{ false };
39 | 		CPUDescriptorHeap* CSU_CpuDH{ nullptr };
40 | 		CPUDescriptorHeap* RTV_CpuDH{ nullptr };
41 | 		CPUDescriptorHeap* DSV_CpuDH{ nullptr };
42 | 		GPUDescriptorHeap* CSU_GpuDH{ nullptr };
43 | 	};
44 | }
45 | 


--------------------------------------------------------------------------------
/include/UDX12/Device.h:
--------------------------------------------------------------------------------
 1 | #pragma once 
 2 | 
 3 | #include "Util.h"
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 |     // raw : Microsoft::WRL::ComPtr<ID3D12Device>
 7 |     // .   : simple API
 8 |     // ->  : raw API
 9 | 	struct Device : Util::ComPtrHolder<ID3D12Device> {
10 | 		using Util::ComPtrHolder<ID3D12Device>::ComPtrHolder;
11 | 
12 |         void CreateCommittedResource(
13 |             D3D12_HEAP_TYPE heap_type,
14 |             SIZE_T size,
15 |             ID3D12Resource** resources);
16 | 
17 |         void CreateDescriptorHeap(UINT size, D3D12_DESCRIPTOR_HEAP_TYPE type,
18 |             ID3D12DescriptorHeap** pHeap);
19 | 
20 |         ComPtr<ID3D12RootSignature> CreateRootSignature(const D3D12_ROOT_SIGNATURE_DESC& desc);
21 |     };
22 | }
23 | 


--------------------------------------------------------------------------------
/include/UDX12/FrameGraph/Executor.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Rsrc.h"
 4 | 
 5 | #include <UFG/Compiler.hpp>
 6 | #include <UThreadPool/UThreadPool.hpp>
 7 | 
 8 | #include <functional>
 9 | 
10 | namespace Ubpa::UDX12::FG {
11 | 	class RsrcMngr;
12 | 
13 | 	class Executor {
14 | 	public:
15 | 		using PassFunction = unique_function<void(ID3D12GraphicsCommandList*, const PassRsrcs&) const>;
16 | 
17 | 		Executor(ID3D12Device* device, size_t num_threads = std::thread::hardware_concurrency());
18 | 
19 | 		Executor& RegisterPassFunc(size_t passNodeIdx, PassFunction func);
20 | 
21 | 		Executor& RegisterCopyPassFunc(size_t passNodeIdx,
22 | 			std::span<const size_t> srcRsrcNodeIndices,
23 | 			std::span<const size_t> dstRsrcNodeIndices);
24 | 
25 | 		Executor& RegisterCopyPassFunc(const UFG::FrameGraph& fg, size_t passNodeIdx);
26 | 
27 | 		void NewFrame();
28 | 
29 | 		void Execute(
30 | 			ID3D12CommandQueue* cmdQueue,
31 | 			const UFG::Compiler::Result& crst,
32 | 			RsrcMngr& rsrcMngr
33 | 		);
34 | 
35 | 	private:
36 | 		ThreadPool threadpool;
37 | 		ID3D12Device* device;
38 | 		std::unordered_map<size_t, PassFunction> passFuncs;
39 | 		std::vector<ComPtr<ID3D12CommandAllocator>> free_allocators;
40 | 		std::vector<ComPtr<ID3D12CommandAllocator>> used_allocators;
41 | 	};
42 | }
43 | 


--------------------------------------------------------------------------------
/include/UDX12/FrameGraph/FrameGraph.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | #include "Executor.h"
4 | #include "Rsrc.h"
5 | #include "RsrcMngr.h"
6 | 


--------------------------------------------------------------------------------
/include/UDX12/FrameGraph/RsrcMngr.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "Rsrc.h"
  4 | 
  5 | #include "../GCmdList.h"
  6 | #include "../Device.h"
  7 | #include "../DescriptorHeapMngr.h"
  8 | 
  9 | #include <unordered_set>
 10 | 
 11 | namespace Ubpa::UFG {
 12 | 	class FrameGraph;
 13 | }
 14 | 
 15 | namespace Ubpa::UDX12::FG {
 16 | 	// manage per pass resources
 17 | 	// CBV, SRV, UAV, RTV, DSV
 18 | 	class RsrcMngr {
 19 | 	public:
 20 | 		RsrcMngr(ID3D12Device* device);
 21 | 		~RsrcMngr();
 22 | 
 23 | 		// clear resources
 24 | 		// you can call it when resize window
 25 | 		void Clear();
 26 | 
 27 | 		// clear per frame datas
 28 | 		// call it per frame before registerations
 29 | 		void NewFrame();
 30 | 
 31 | 		// descriptor heap reserve
 32 | 		// call by Ubpa::UDX12::FG::Executor
 33 | 		void DHReserve();
 34 | 
 35 | 		// allocate handles in descriptor heap for each resource nodes
 36 | 		// call by Ubpa::UDX12::FG::Executor
 37 | 		void AllocateHandle();
 38 | 
 39 | 		// import, create or reuse buffer for the resource node
 40 | 		// call by Ubpa::UDX12::FG::Executor
 41 | 		void Construct(size_t rsrcNodeIdx);
 42 | 
 43 | 		// recycle the buffer of the resource node
 44 | 		// call by Ubpa::UDX12::FG::Executor
 45 | 		void DestructCPU(size_t rsrcNodeIdx);
 46 | 		void DestructGPU(ID3D12GraphicsCommandList*, size_t rsrcNodeIdx);
 47 | 
 48 | 		// move the resource view of the source resource node to the destination resource node
 49 | 		// call by Ubpa::UDX12::FG::Executor
 50 | 		void Move(size_t dstRsrcNodeIdx, size_t srcRsrcNodeIdx);
 51 | 
 52 | 		// - get the resource map (resource node index -> impl resource) of the pass node
 53 | 		// - we will
 54 | 		//   1. change buffer state
 55 | 		//   2. init handle
 56 | 		// - call by Ubpa::UDX12::FG::Executor
 57 | 		PassRsrcs RequestPassRsrcs(ID3D12GraphicsCommandList*, size_t passNodeIdx);
 58 | 
 59 | 		// mark the resource node as imported
 60 | 		RsrcMngr& RegisterImportedRsrc(size_t rsrcNodeIdx, SRsrcView view) {
 61 | 			importeds[rsrcNodeIdx] = view;
 62 | 			return *this;
 63 | 		}
 64 | 
 65 | 		// mark the resource node as temporal
 66 | 		RsrcMngr& RegisterTemporalRsrc(size_t rsrcNodeIdx, D3D12_RESOURCE_DESC type);
 67 | 		RsrcMngr& RegisterTemporalRsrcAutoClear(size_t rsrcNodeIdx, D3D12_RESOURCE_DESC type);
 68 | 		RsrcMngr& RegisterTemporalRsrc(size_t rsrcNodeIdx, D3D12_RESOURCE_DESC type, D3D12_CLEAR_VALUE clearvalue);
 69 | 		RsrcMngr& RegisterTemporalRsrcReusable(size_t rsrcNodeIdx, bool reusable);
 70 | 		RsrcMngr& RegisterTemporalRsrcConstructState(size_t rsrcNodeIdx, D3D12_RESOURCE_STATES state);
 71 | 
 72 | 		// provide details for the resource node of the pass node
 73 | 		RsrcMngr& RegisterPassRsrcState(size_t passNodeIdx, size_t rsrcNodeIdx, RsrcState state);
 74 | 		// a resource can have several descriptions
 75 | 		RsrcMngr& RegisterPassRsrcImplDesc(size_t passNodeIdx, size_t rsrcNodeIdx, RsrcImplDesc desc);
 76 | 		// a helper function to simplify register pass resource's state and impl description
 77 | 		RsrcMngr& RegisterPassRsrc(size_t passNodeIdx, size_t rsrcNodeIdx, RsrcState state, RsrcImplDesc desc);
 78 | 
 79 | 		// provide external handles for the resource node
 80 | 		RsrcMngr& RegisterRsrcHandle(
 81 | 			size_t rsrcNodeIdx,
 82 | 			RsrcImplDesc desc,
 83 | 			D3D12_CPU_DESCRIPTOR_HANDLE cpuHandle,
 84 | 			D3D12_GPU_DESCRIPTOR_HANDLE gpuHandle = { 0 },
 85 | 			bool inited = true
 86 | 		);
 87 | 
 88 | 		// only support CBV, SRV, UAV
 89 | 		RsrcMngr& RegisterRsrcTable(const std::string& ID, const std::vector<std::tuple<size_t, RsrcImplDesc>>& rsrcNodeIndices);
 90 | 
 91 | 		RsrcMngr& RegisterCopyPassRsrcState(size_t passNodeIdx, size_t srcRsrcNodeIdx, size_t dstRsrcNodeIdx);
 92 | 
 93 | 		RsrcMngr& RegisterCopyPassRsrcState(size_t passNodeIdx,
 94 | 			std::span<const size_t> srcRsrcNodeIndices,
 95 | 			std::span<const size_t> dstRsrcNodeIndices);
 96 | 
 97 | 		RsrcMngr& RegisterCopyPassRsrcState(const UFG::FrameGraph& fg, size_t passNodeIdx);
 98 | 
 99 | 		DXGI_FORMAT GetResourceFormat(size_t rsrcNodeIdx) const;
100 | 
101 | 		// you should
102 | 		// 1. use RegisterImportedRsrc or RegisterTemporalRsrc to mark each resource nodes
103 | 		// 2. use RegisterPassRsrcs to mark each resource nodes for every passes
104 | 		// if you do it correct, then return true, else return false
105 | 		// TODO : move
106 | 		bool CheckComplete(const UFG::FrameGraph& fg);
107 | 
108 | 	private:
109 | 		bool IsImported(size_t rsrcNodeIdx) const noexcept {
110 | 			return importeds.find(rsrcNodeIdx) != importeds.end();
111 | 		}
112 | 
113 | 		// CSU : CBV, CSU, UAV
114 | 
115 | 		void CSUDHReserve(UINT num);
116 | 		void DsvDHReserve(UINT num);
117 | 		void RtvDHReserve(UINT num);
118 | 
119 | 		struct RsrcType {
120 | 			D3D12_RESOURCE_DESC desc;
121 | 			bool containClearvalue;
122 | 			D3D12_CLEAR_VALUE clearvalue;
123 | 			bool operator==(const RsrcType& rhs) const noexcept {
124 | 				return desc == rhs.desc && containClearvalue == rhs.containClearvalue
125 | 					&& (containClearvalue?clearvalue == rhs.clearvalue:true);
126 | 			}
127 | 		};
128 | 		struct RsrcTypeHasher {
129 | 			bool operator()(const RsrcType& rsrctype) const noexcept {
130 | 				return Ubpa::UDX12::FG::detail::hash_of(rsrctype);
131 | 			}
132 | 		};
133 | 
134 | 		ID3D12Device* device;
135 | 
136 | 		// type -> vector<view>
137 | 		std::unordered_map<Rsrc*, RsrcPtr> rsrcKeeper;
138 | 		std::unordered_map<RsrcType, std::vector<SRsrcView>, RsrcTypeHasher> pool;
139 | 		std::vector<std::pair<RsrcType, SRsrcView>> unreusableRsrcs;
140 | 		std::unordered_set<Rsrc*> usedRsrcs;
141 | 
142 | 		// rsrcNodeIdx -> view
143 | 		std::unordered_map<size_t, SRsrcView> importeds;
144 | 
145 | 		// rsrcNodeIdx -> type
146 | 		std::unordered_map<size_t, RsrcType> temporals;
147 | 		std::unordered_map<size_t, bool> temporalReusable;
148 | 		std::unordered_map<size_t, D3D12_RESOURCE_STATES> temporalConstructStates;
149 | 
150 | 		// passNodeIdx -> resource (state + descs) map
151 | 		std::unordered_map<size_t, std::unordered_map<size_t, std::tuple<RsrcState, std::vector<RsrcImplDesc>>>> passNodeIdx2rsrcMap;
152 | 
153 | 		// rsrcNodeIdx -> view
154 | 		std::unordered_map<size_t, SRsrcView> actives;
155 | 
156 | 		// rsrcNodeIdx -> typeinfo
157 | 		std::unordered_map<size_t, RsrcDescInfo> typeinfoMap;
158 | 		
159 | 		UDX12::DynamicSuballocMngr* csuDynamicDH{ nullptr };
160 | 
161 | 		UDX12::DescriptorHeapAllocation csuDH;
162 | 		std::vector<UINT> csuDHfree;
163 | 		std::unordered_set<UINT> csuDHused;
164 | 
165 | 		UDX12::DescriptorHeapAllocation rtvDH;
166 | 		std::vector<UINT> rtvDHfree;
167 | 		std::unordered_set<UINT> rtvDHused;
168 | 
169 | 		UDX12::DescriptorHeapAllocation dsvDH;
170 | 		std::vector<UINT> dsvDHfree;
171 | 		std::unordered_set<UINT> dsvDHused;
172 | 	};
173 | }
174 | 


--------------------------------------------------------------------------------
/include/UDX12/FrameResource.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Util.h"
 4 | #include <functional>
 5 | #include <map>
 6 | #include <unordered_map>
 7 | #include <any>
 8 | 
 9 | namespace Ubpa::UDX12 {
10 | 	// frame resource mngr
11 | 	class FrameResource {
12 | 	public:
13 | 		FrameResource(UINT64 cpuFence, ID3D12Fence* gpuFence) : cpuFence{ cpuFence }, gpuFence{ gpuFence } {}
14 | 
15 | 		bool HaveResource(std::string_view name) const { return resourceMap.find(name) != resourceMap.end(); }
16 | 
17 | 		template<typename T>
18 | 		FrameResource& RegisterResource(std::string name, T&& resource);
19 | 
20 | 		FrameResource& UnregisterResource(std::string_view name);
21 | 		FrameResource& DelayUnregisterResource(std::string name);
22 | 		template<typename Func>
23 | 		FrameResource& DelayUpdateResource(std::string name, Func&& updator);
24 | 
25 | 		template<typename T>
26 | 		T& GetResource(std::string_view name);
27 | 		template<typename T>
28 | 		const T& GetResource(std::string_view name) const;
29 | 
30 | 	private:
31 | 		friend class FrameResourceMngr;
32 | 
33 | 		// cpu at frame [cpuFence] use the resources
34 | 		// when the frame complete (GPU instructions complete), gpuFence <- cpuFence
35 | 		void Signal(ID3D12CommandQueue* cmdQueue, UINT64 cpuFence);
36 | 
37 | 		// at the cpu frame beginning, you should wait the frame complete
38 | 		// block cpu
39 | 		// run delay updator and unregister
40 | 		void BeginFrame(HANDLE sharedEventHandle);
41 | 
42 | 		ID3D12Fence* gpuFence;
43 | 		UINT64 cpuFence;
44 | 		std::map<std::string, std::any, std::less<>> resourceMap;
45 | 		std::vector<std::string> delayUnregisterResources;
46 | 		std::vector<std::tuple<std::string, std::function<void(std::any&)>>> delayUpdatorMap;
47 | 	};
48 | }
49 | 
50 | #include "details/FrameRsrcMngr.inl"
51 | 


--------------------------------------------------------------------------------
/include/UDX12/FrameResourceMngr.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "FrameResource.h"
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 | 	class FrameResourceMngr {
 7 | 	public:
 8 | 		FrameResourceMngr(size_t numFrame, ID3D12Device*);
 9 | 		~FrameResourceMngr();
10 | 		size_t GetNumFrame() const noexcept { return frameResources.size(); }
11 | 		FrameResource* GetCurrentFrameResource() noexcept;
12 | 		const std::vector<std::unique_ptr<FrameResource>>& GetFrameResources() const noexcept { return frameResources; }
13 | 		size_t GetCurrentCpuFence() const noexcept { return cpuFence; };
14 | 
15 | 		void BeginFrame();
16 | 		void EndFrame(ID3D12CommandQueue*);
17 | 	private:
18 | 		HANDLE eventHandle;
19 | 		std::vector<std::unique_ptr<FrameResource>> frameResources;
20 | 		size_t cpuFence{ 0 };
21 | 		Microsoft::WRL::ComPtr<ID3D12Fence> gpuFence;
22 | 	};
23 | }
24 | 


--------------------------------------------------------------------------------
/include/UDX12/GCmdList.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Util.h"
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 |     // raw : Microsoft::WRL::ComPtr<ID3D12GraphicsCommandList>
 7 |     // .   : simple API
 8 |     // ->  : raw API
 9 | 	struct GCmdList : Util::ComPtrHolder<ID3D12GraphicsCommandList> {
10 | 		using Util::ComPtrHolder<ID3D12GraphicsCommandList>::ComPtrHolder;
11 | 
12 |         void Reset(ID3D12CommandAllocator* pAllocator);
13 | 
14 |         void ResourceBarrierTransition(
15 |             ID3D12Resource* resource,
16 |             D3D12_RESOURCE_STATES from,
17 |             D3D12_RESOURCE_STATES to
18 |         );
19 | 
20 |         // D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER
21 |         template<typename... Heaps,
22 |             typename = std::enable_if_t<
23 |             sizeof...(Heaps) <= static_cast<size_t>(2) &&
24 |             (std::is_same_v<Heaps, ID3D12DescriptorHeap>&&...) >>
25 |         void SetDescriptorHeaps(Heaps*... heaps);
26 | 
27 |         void ClearRenderTargetView(D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, const FLOAT color[4]);
28 |         void ClearDepthStencilView(D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView);
29 | 
30 |         void RSSetViewport(D3D12_VIEWPORT viewport);
31 |         void RSSetScissorRect(D3D12_RECT rect);
32 | 
33 |         // simple version
34 |         // pro: OMSetRenderTargets
35 |         void OMSetRenderTarget(
36 |             D3D12_CPU_DESCRIPTOR_HANDLE rendertarget,
37 |             D3D12_CPU_DESCRIPTOR_HANDLE depthstencil);
38 | 
39 |         // one instance
40 |         void DrawIndexed(
41 |             UINT IndexCount,
42 |             UINT StartIndexLocation,
43 |             INT BaseVertexLocation);
44 |     };
45 | }
46 | 
47 | #include "details/GCmdList.inl"
48 | 


--------------------------------------------------------------------------------
/include/UDX12/MeshGPUBuffer.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "Util.h"
  4 | 
  5 | #include "_deps/DirectXTK12/ResourceUploadBatch.h"
  6 | 
  7 | #include "UploadBuffer.h"
  8 | 
  9 | namespace Ubpa::UDX12 {
 10 | 	// static / dynamic mesh GPU buffer
 11 | 	class MeshGPUBuffer {
 12 | 	public:
 13 | 		// [[ static ]]
 14 | 		// default buffer
 15 | 		// ib_format   : DXGI_FORMAT_R16_UINT / DXGI_FORMAT_R32_UINT
 16 | 		// after state : D3D12_RESOURCE_STATE_GENERIC_READ
 17 | 		// [sync]
 18 | 		// - construct upload, default buffer
 19 | 		// - cpu buffer -> upload buffer
 20 | 		// [async]
 21 | 		// - upload buffer -> default buffer
 22 | 		// - delete upload buffer
 23 | 		MeshGPUBuffer(
 24 | 			ID3D12Device* device, DirectX::ResourceUploadBatch& resourceUpload,
 25 | 			const void* vb_data, UINT vb_count, UINT vb_stride,
 26 | 			const void* ib_data, UINT ib_count, DXGI_FORMAT ib_format
 27 | 		);
 28 | 		
 29 | 		// [[ dynamic ]]
 30 | 		// upload buffer + default buffer
 31 | 		MeshGPUBuffer(
 32 | 			ID3D12Device* device, ID3D12GraphicsCommandList* cmdList,
 33 | 			const void* vb_data, UINT vb_count, UINT vb_stride,
 34 | 			const void* ib_data, UINT ib_count, DXGI_FORMAT ib_format
 35 | 		);
 36 | 
 37 | 		bool IsStatic() const noexcept { return isStatic; }
 38 | 
 39 | 		// view of default buffer
 40 | 		D3D12_VERTEX_BUFFER_VIEW VertexBufferView() const;
 41 | 
 42 | 		// view of default buffer
 43 | 		D3D12_INDEX_BUFFER_VIEW IndexBufferView() const;
 44 | 
 45 | 		// [[ Update Strategy ]]
 46 | 		// 
 47 | 		// # [FOUR] cases to update a [dynamic] mesh
 48 | 		//   1. non-editable + non-dirty : ConvertToStatic
 49 | 		//   2. non-editable +     dirty : Update + ConvertToStatic
 50 | 		//   3.     editable + non-dirty : do nothing
 51 | 		//   4.     editable +     dirty : Update
 52 | 		// 
 53 | 		// # [FOUR] cases to update a [static] mesh
 54 | 		//   1. non-editable + non-dirty : do nothing
 55 | 		//   2. non-editable +     dirty : ConvertToDynamic + Update + ConvertToStatic
 56 | 		//   3.     editable + non-dirty : ConvertToDynamic
 57 | 		//   4.     editable +     dirty : ConvertToDynamic + Update
 58 | 
 59 | 		// update dynamic mesh data
 60 | 		// [sync]
 61 | 		// - (maybe) construct resized upload buffer
 62 | 		// - (maybe) construct resized default buffer
 63 | 		// - cpu buffer -> upload buffer
 64 | 		// [async]
 65 | 		// - upload buffer -> default buffer
 66 | 		void Update(
 67 | 			ID3D12Device* device, ID3D12GraphicsCommandList* cmdList,
 68 | 			const void* vb_data, UINT vb_count, UINT vb_stride,
 69 | 			const void* ib_data, UINT ib_count, DXGI_FORMAT ib_format
 70 | 		);
 71 | 
 72 | 		// set static, delete upload buffer
 73 | 		// [async]
 74 | 		// - delete upload buffer
 75 | 		void ConvertToStatic(ResourceDeleteBatch& deleteBatch);
 76 | 
 77 | 		// convert static to dynamic
 78 | 		// [sync]
 79 | 		// - construct upload buffer
 80 | 		void ConvertToDynamic(ID3D12Device* device);
 81 | 
 82 | 		// delete all buffers
 83 | 		// [async]
 84 | 		// - delete vertexUploadBuffer, indexUploadBuffer, staticVertexBuffer, staticIndexBuffer
 85 | 		void Delete(ResourceDeleteBatch& deleteBatch);
 86 | 
 87 | 		ComPtr<ID3D12Resource> GetVertexBufferResource() const { return staticVertexBuffer; }
 88 | 		ComPtr<ID3D12Resource> GetIndexBufferResource() const { return staticIndexBuffer; }
 89 | 
 90 | 	private:
 91 | 		bool isStatic;
 92 | 
 93 | 		ComPtr<ID3D12Resource> staticVertexBuffer;
 94 | 		ComPtr<ID3D12Resource> staticIndexBuffer;
 95 | 
 96 | 		std::unique_ptr<DynamicUploadBuffer> vertexUploadBuffer;
 97 | 		std::unique_ptr<DynamicUploadBuffer> indexUploadBuffer;
 98 | 
 99 | 		UINT vertexByteStride; // per vertex data size in bytes
100 | 		UINT vertexBufferByteSize; // vertex buffer total size in bytes
101 | 
102 | 		DXGI_FORMAT indexFormat; // DXGI_FORMAT_R16_UINT / DXGI_FORMAT_R32_UINT
103 | 		UINT indexBufferByteSize; // index buffer total size in bytes
104 | 	};
105 | }
106 | 


--------------------------------------------------------------------------------
/include/UDX12/ResourceDeleteBatch.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Util.h"
 4 | 
 5 | #include <UFunction.hpp>
 6 | 
 7 | namespace Ubpa::UDX12 {
 8 | 	class ResourceDeleteBatch {
 9 | 	public:
10 | 		ResourceDeleteBatch() = default;
11 | 		ResourceDeleteBatch(const ResourceDeleteBatch&) = delete;
12 | 		ResourceDeleteBatch(ResourceDeleteBatch&&) noexcept = default;
13 | 		ResourceDeleteBatch& operator=(const ResourceDeleteBatch&) = delete;
14 | 		ResourceDeleteBatch& operator=(ResourceDeleteBatch&&) noexcept = default;
15 | 		~ResourceDeleteBatch();
16 | 		void Add(Microsoft::WRL::ComPtr<ID3D12Resource> resource);
17 | 		void AddCallback(unique_function<void()> callback);
18 | 		void Release();
19 | 	private:
20 | 		std::vector<Microsoft::WRL::ComPtr<ID3D12Resource>> resources;
21 | 		std::vector<unique_function<void()>> callbacks;
22 | 	};
23 | }
24 | 


--------------------------------------------------------------------------------
/include/UDX12/UDX12.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "_deps/DirectXTK12/DirectXTK12.h"
 4 | #include "_deps/d3dx12.h"
 5 | 
 6 | #include "FrameGraph/FrameGraph.h"
 7 | 
 8 | #include "Blob.h"
 9 | #include "CmdQueue.h"
10 | #include "D3DInclude.h"
11 | #include "Desc.h"
12 | #include "DescriptorHeapMngr.h"
13 | #include "Device.h"
14 | #include "FrameResource.h"
15 | #include "FrameResourceMngr.h"
16 | #include "GCmdList.h"
17 | #include "MeshGPUBuffer.h"
18 | #include "ResourceDeleteBatch.h"
19 | #include "UploadBuffer.h"
20 | #include "Util.h"
21 | 


--------------------------------------------------------------------------------
/include/UDX12/UploadBuffer.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "Util.h"
  4 | 
  5 | #include "ResourceDeleteBatch.h"
  6 | #include "_deps/DirectXTK12/ResourceUploadBatch.h"
  7 | 
  8 | #include <memory>
  9 | 
 10 | namespace Ubpa::UDX12 {
 11 | 	// resource in upload heap
 12 | 	// upload heap : cpu and gpu shared memory
 13 | 	// sync : run in cpu timeline
 14 | 	// async : record in command list, run in gpu timeline
 15 | 	class UploadBuffer {
 16 | 	public:
 17 | 		// create default buffer
 18 | 		// [sync]
 19 | 		// - construct
 20 | 		UploadBuffer(ID3D12Device* device, UINT64 size, D3D12_RESOURCE_FLAGS flag = D3D12_RESOURCE_FLAG_NONE);
 21 | 		~UploadBuffer();
 22 | 
 23 | 		ID3D12Resource* GetResource() const noexcept { return resource.Get(); }
 24 | 		UINT64 Size() const noexcept { return size; }
 25 | 		void* GetMappedData() const noexcept { return mappedData; }
 26 | 		bool Valid() const noexcept { return resource.Get() != nullptr; }
 27 | 
 28 | 		// copy cpu buffer to upload buffer
 29 | 		// [sync]
 30 | 		// - cpu buffer -> upload buffer
 31 | 		void Set(UINT64 offset, const void* data, UINT64 size);
 32 | 		template<typename T>
 33 | 		void Set(UINT64 offset, const T* data) { Set(offset, data, sizeof(T)); }
 34 | 
 35 | 		// create default buffer resource
 36 | 		// [sync]
 37 | 		// - construct default buffer
 38 | 		// [async]
 39 | 		// - upload buffer -> default buffer
 40 | 		void CopyConstruct(
 41 | 			size_t dstOffset, size_t srcOffset, size_t numBytes,
 42 | 			ID3D12Device* device,
 43 | 			ID3D12GraphicsCommandList* cmdList,
 44 | 			D3D12_RESOURCE_STATES afterState,
 45 | 			ID3D12Resource** pBuffer, // out com ptr
 46 | 			D3D12_RESOURCE_FLAGS resFlags = D3D12_RESOURCE_FLAG_NONE
 47 | 		);
 48 | 
 49 | 		// copy upload buffer to dst
 50 | 		// [async]
 51 | 		// - upload buffer -> dst
 52 | 		void CopyAssign(
 53 | 			size_t dstOffset, size_t srcOffset, size_t numBytes,
 54 | 			ID3D12GraphicsCommandList* cmdList,
 55 | 			ID3D12Resource* dst,
 56 | 			D3D12_RESOURCE_STATES state = D3D12_RESOURCE_STATE_GENERIC_READ
 57 | 		);
 58 | 
 59 | 		// move resource to deleteBatch
 60 | 		void Delete(ResourceDeleteBatch& deleteBatch);
 61 | 	private:
 62 | 		ComPtr<ID3D12Resource> resource;
 63 | 		void* mappedData;
 64 | 		UINT64 size;
 65 | 	};
 66 | 
 67 | 	class DynamicUploadBuffer {
 68 | 	public:
 69 | 		DynamicUploadBuffer(ID3D12Device* device, UINT64 size, D3D12_RESOURCE_FLAGS flag = D3D12_RESOURCE_FLAG_NONE);
 70 | 
 71 | 		ID3D12Resource* GetResource() const noexcept;
 72 | 		UINT64 Size() const noexcept;
 73 | 		bool Valid() const noexcept { return (bool)buffer; }
 74 | 		void* GetMappedData() const noexcept;
 75 | 
 76 | 		// retain original data when resizing
 77 | 		// [sync]
 78 | 		// - (maybe) construct resized upload buffer
 79 | 		// - (maybe) orignal upload buffer -> new upload buffer
 80 | 		void Reserve(size_t size);
 81 | 
 82 | 		// not retain original data when resizing
 83 | 		// [sync]
 84 | 		// - (maybe) construct resized upload buffer
 85 | 		void FastReserve(size_t size);
 86 | 
 87 | 		void Resize(size_t size);
 88 | 
 89 | 		// copy cpu buffer to upload buffer
 90 | 		// [sync]
 91 | 		// - cpu buffer -> upload buffer
 92 | 		void Set(UINT64 offset, const void* data, UINT64 size);
 93 | 		template<typename T>
 94 | 		void Set(UINT64 offset, const T* data) { Set(offset, data, sizeof(T)); }
 95 | 
 96 | 		// same with UploadBuffer::CopyConstruct
 97 | 		void CopyConstruct(
 98 | 			size_t dstOffset, size_t srcOffset, size_t numBytes,
 99 | 			ID3D12Device* device,
100 | 			ID3D12GraphicsCommandList* cmdList,
101 | 			D3D12_RESOURCE_STATES afterState,
102 | 			ID3D12Resource** pBuffer, // out com ptr
103 | 			D3D12_RESOURCE_FLAGS resFlags = D3D12_RESOURCE_FLAG_NONE
104 | 		);
105 | 
106 | 		// same with UploadBuffer::CopyAssign
107 | 		void CopyAssign(
108 | 			size_t dstOffset, size_t srcOffset, size_t numBytes,
109 | 			ID3D12GraphicsCommandList* cmdList,
110 | 			ID3D12Resource* dst,
111 | 			D3D12_RESOURCE_STATES state = D3D12_RESOURCE_STATE_GENERIC_READ
112 | 		);
113 | 
114 | 		// move resource to deleteBatch
115 | 		void Delete(ResourceDeleteBatch& deleteBatch);
116 | 	private:
117 | 		ID3D12Device* device;
118 | 		D3D12_RESOURCE_FLAGS flag;
119 | 
120 | 		std::unique_ptr<UploadBuffer> buffer;
121 | 	};
122 | 
123 | 	class DynamicUploadVector {
124 | 	public:
125 | 		DynamicUploadVector(ID3D12Device* device, D3D12_RESOURCE_FLAGS flag = D3D12_RESOURCE_FLAG_NONE)
126 | 			: buffer(device, 0, flag), size{ 0 } {}
127 | 
128 | 		void* Data() noexcept { return buffer.GetMappedData(); }
129 | 		const void* Data() const noexcept { return buffer.GetMappedData(); }
130 | 		UINT64 Capacity() const noexcept { return buffer.Size(); }
131 | 		bool Empty() const noexcept { return size == 0; }
132 | 		UINT64 Size() const noexcept { return size; }
133 | 
134 | 		// offset + data_size < Size()
135 | 		void Set(size_t offset, const void* data, UINT64 data_size) {
136 | 			assert(offset + data_size < Size());
137 | 			buffer.Set(offset, data, data_size);
138 | 		}
139 | 
140 | 		void Pushback(const void* data, UINT64 data_size) {
141 | 			if (size + data_size < Capacity())
142 | 				Reserve(2 * (size + data_size));
143 | 			buffer.Set(size, data, data_size);
144 | 			size += data_size;
145 | 		}
146 | 
147 | 		void Reserve(UINT64 capacity) { buffer.Reserve(capacity); }
148 | 		void FastReserve(UINT64 capacity) { buffer.FastReserve(capacity); }
149 | 
150 | 		void Popback(UINT64 data_size) { assert(size > data_size); size -= data_size; }
151 | 
152 | 		void Clear() noexcept { size = 0; }
153 | 
154 | 		void Resize(UINT64 s) {
155 | 			if (s > Capacity())
156 | 				buffer.Resize(s);
157 | 			size = s;
158 | 		}
159 | 
160 | 		ID3D12Resource* GetResource() const noexcept { return buffer.GetResource(); }
161 | 	private:
162 | 		DynamicUploadBuffer buffer;
163 | 		UINT64 size;
164 | 	};
165 | 
166 | 	// a wrappper of the upload buffer to treat the buffer as an fix-size array
167 | 	template<typename T>
168 | 	class ArrayUploadBuffer : public UploadBuffer {
169 | 	public:
170 | 		ArrayUploadBuffer(ID3D12Device* device, UINT64 numElement, bool isConstantBuffer,
171 | 			D3D12_RESOURCE_FLAGS flag = D3D12_RESOURCE_FLAG_NONE);
172 | 
173 | 		void Set(UINT64 index, const T* data, UINT64 numElement);
174 | 		void Set(UINT64 index, const T& element);
175 | 		bool IsConstantBuffer() const noexcept { return isConstantBuffer; }
176 | 		UINT64 NumElement() const noexcept { return numElement; }
177 | 	private:
178 | 		static constexpr UINT ElementSize(bool isConstantBuffer);
179 | 		UINT64 numElement;
180 | 		bool isConstantBuffer;
181 | 	};
182 | 
183 | 	template<typename T>
184 | 	class VectorUploadBuffer : public DynamicUploadBuffer {
185 | 	public:
186 | 		VectorUploadBuffer(ID3D12Device* device, bool isConstantBuffer, D3D12_RESOURCE_FLAGS flag = D3D12_RESOURCE_FLAG_NONE);
187 | 		bool IsConstantBuffer() const noexcept { return isConstantBuffer; }
188 | 
189 | 		void* Data() noexcept { return DynamicUploadBuffer::GetMappedData(); }
190 | 		const void* Data() const noexcept { return DynamicUploadBuffer::GetMappedData(); }
191 | 
192 | 		T& At(size_t idx);
193 | 		const T& At(size_t idx) const;
194 | 
195 | 		T& operator[](size_t idx) noexcept;
196 | 		const T& operator[](size_t idx) const noexcept;
197 | 
198 | 		bool Empty() const noexcept { return size == 0; }
199 | 		size_t Size() const noexcept { return size; }
200 | 
201 | 		void Reserve(size_t n) { DynamicUploadBuffer::Reserve(n * ElementSize<T>(isConstantBuffer)); }
202 | 		size_t Capacity() const noexcept { DynamicUploadBuffer::Size() / ElementSize<T>(isConstantBuffer); }
203 | 		
204 | 		void Clear() noexcept { size = 0; }
205 | 		
206 | 		void Pushback(const T& ele);
207 | 		void Popback() noexcept { assert(size > 0); --size; }
208 | 
209 | 		D3D12_GPU_VIRTUAL_ADDRESS GpuAdressAt(size_t idx) const;
210 | 		
211 | 	private:
212 | 		static constexpr UINT ElementSize(bool isConstantBuffer);
213 | 		bool isConstantBuffer;
214 | 		size_t size;
215 | 	};
216 | }
217 | 
218 | #include "details/UploadBuffer.inl"
219 | 


--------------------------------------------------------------------------------
/include/UDX12/Util.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "_deps/d3dx12.h"
  4 | #include "_deps/DirectXTK12/ResourceUploadBatch.h"
  5 | #include "dxcapi.h"
  6 | 
  7 | #include <d3dcompiler.h>
  8 | #include <wrl.h>
  9 | #include <atlcomcli.h>
 10 | 
 11 | #include <string>
 12 | 
 13 | #include <cassert>
 14 | 
 15 | #ifndef ThrowIfFailed
 16 | #define ThrowIfFailed(x)                                                          \
 17 | {                                                                                 \
 18 |     HRESULT hr__ = (x);                                                           \
 19 |     if(FAILED(hr__)) {                                                            \
 20 |          std::wstring wfn = Ubpa::UDX12::Util::AnsiToWString(__FILE__);           \
 21 |          throw Ubpa::UDX12::Util::Exception(hr__, L#x, std::move(wfn), __LINE__); \
 22 |     }                                                                             \
 23 | }
 24 | #endif // !ThrowIfFailed
 25 | 
 26 | namespace Ubpa::UDX12 {
 27 |     using Microsoft::WRL::ComPtr;
 28 |     using ATL::CComPtr;
 29 |     class D3DInclude;
 30 | }
 31 | 
 32 | namespace Ubpa::UDX12::Util {
 33 |     template<typename T>
 34 |     void ReleaseCom(T* & p) {
 35 |         if (p) {
 36 |             p->Release();
 37 |             p = nullptr;
 38 |         }
 39 |     }
 40 | 
 41 |     std::wstring AnsiToWString(const std::string& str);
 42 | 
 43 |     template<typename T>
 44 |     struct ComPtrHolder {
 45 |         ComPtrHolder(ComPtr<T> ptr = {}) : raw{ ptr } {}
 46 |         ComPtr<T> raw;
 47 |         T* operator->() noexcept { return raw.Get(); }
 48 |         const T* operator->() const noexcept { return raw.Get(); }
 49 |         bool IsNull() const noexcept { return raw.Get() == nullptr; }
 50 |         T* Get() const noexcept { return raw.Get(); }
 51 |     };
 52 | 
 53 |     class Exception {
 54 |     public:
 55 |         Exception() = default;
 56 |         Exception(HRESULT hr, const std::wstring& functionName, const std::wstring& filename, int lineNumber);
 57 | 
 58 |         std::wstring ToString() const;
 59 | 
 60 |         HRESULT ErrorCode = S_OK;
 61 |         std::wstring FunctionName;
 62 |         std::wstring Filename;
 63 |         int LineNumber = -1;
 64 |     };
 65 | 
 66 |     // vkeyCode : virtual key code
 67 |     // ref: https://docs.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes 
 68 |     bool IsKeyDown(int vkeyCode);
 69 | 
 70 |     // 32bit in hex, start with '0x'
 71 |     // e.g. 0x88888888
 72 |     std::string HRstToString(HRESULT hr);
 73 | 
 74 |     constexpr UINT CalcConstantBufferByteSize(UINT byteSize)
 75 |     {
 76 |         // Constant buffers must be a multiple of the minimum hardware
 77 |         // allocation size (usually 256 bytes).  So round up to nearest
 78 |         // multiple of 256.  We do this by adding 255 and then masking off
 79 |         // the lower 2 bytes which store all bits < 256.
 80 |         // Example: Suppose byteSize = 300.
 81 |         // (300 + 255) & ~255
 82 |         // 555 & ~255
 83 |         // 0x022B & ~0x00ff
 84 |         // 0x022B & 0xff00
 85 |         // 0x0200
 86 |         // 512
 87 |         return (byteSize + 255) & ~255;
 88 |     }
 89 | 
 90 |     ComPtr<ID3DBlob> LoadBinary(const std::wstring& filename);
 91 | 
 92 |     // release uploadBuffer after coping
 93 |     ComPtr<ID3D12Resource> CreateDefaultBuffer(
 94 |         ID3D12Device* device,
 95 |         ID3D12GraphicsCommandList* cmdList,
 96 |         const void* initData,
 97 |         UINT64 byteSize,
 98 |         ComPtr<ID3D12Resource>& uploadBuffer);
 99 | 
100 |     // [summary]
101 |     // compile shader file to bytecode
102 |     // [arguments]
103 |     // - defines: marco array, end with {NULL, NULL}
104 |     // - - e.g. #define zero 0 <-> D3D_SHADER_MACRO Shader_Macros[] = { "zero", "0", NULL, NULL };
105 |     // - entrypoint: begin function name, like 'main'
106 |     // - target: e.g. cs/ds/gs/hs/ps/vs + _5_ + 0/1
107 |     // [ref] https://docs.microsoft.com/en-us/windows/win32/api/d3dcompiler/nf-d3dcompiler-d3dcompilefromfile
108 |     ComPtr<ID3DBlob> CompileShaderFromFile(
109 |         const std::wstring& filename,
110 |         const D3D_SHADER_MACRO* defines,
111 |         const std::string& entrypoint,
112 |         const std::string& target
113 |     );
114 | 
115 | 	ComPtr<ID3DBlob> CompileShader(
116 | 		std::string_view source,
117 | 		const D3D_SHADER_MACRO* defines,
118 | 		const std::string& entrypoint,
119 | 		const std::string& target,
120 |         D3DInclude* pInclude,
121 |         LPCSTR pSourceName = nullptr,
122 |         UINT compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION
123 | 	);
124 | 
125 | 	HRESULT __cdecl CreateTexture2DArrayFromMemory(_In_ ID3D12Device* device,
126 | 		DirectX::ResourceUploadBatch& resourceUpload,
127 | 		size_t width, size_t height, size_t arraySize,
128 | 		DXGI_FORMAT format,
129 | 		const D3D12_SUBRESOURCE_DATA* subResources,
130 | 		_COM_Outptr_ ID3D12Resource** texture,
131 | 		bool generateMips = false,
132 | 		D3D12_RESOURCE_STATES afterState = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
133 | 		D3D12_RESOURCE_FLAGS resFlags = D3D12_RESOURCE_FLAG_NONE) noexcept;
134 | 
135 |     ComPtr<ID3DBlob> CompileLibrary(
136 |         LPCVOID pText,
137 |         UINT32 size,
138 |         LPCWSTR dir = nullptr,
139 |         LPCWSTR pSourceName = nullptr);
140 | }
141 | 


--------------------------------------------------------------------------------
/include/UDX12/VarSizeAllocMngr.h:
--------------------------------------------------------------------------------
  1 | // ref
  2 | // 1. http://diligentgraphics.com/diligent-engine/architecture/d3d12/variable-size-memory-allocations-manager/
  3 | // 2. https://github.com/DiligentGraphics/DiligentCore/blob/09b9f1dc1ec69683c3143f309e6e8a0141361624/Graphics/GraphicsAccessories/interface/VarSizeAllocMngr.hpp
  4 | // 3. https://github.com/DiligentGraphics/DiligentCore/blob/09b9f1dc1ec69683c3143f309e6e8a0141361624/Graphics/GraphicsEngineD3D12/src/DescriptorHeap.cpp
  5 | 
  6 | #pragma once
  7 | 
  8 | #include <map>
  9 | 
 10 | namespace Ubpa::UDX12 {
 11 |     // The class handles free memory block management to accommodate variable-size allocation requests.
 12 |     // It keeps track of free blocks only and does not record allocation sizes. The class uses two ordered maps
 13 |     // to facilitate operations. The first map keeps blocks sorted by their offsets. The second multimap keeps blocks
 14 |     // sorted by their sizes. The elements of the two maps reference each other, which enables efficient block
 15 |     // insertion, removal and merging.
 16 |     //
 17 |     //   8                 32                       64                           104
 18 |     //   |<---16--->|       |<-----24------>|        |<---16--->|                 |<-----32----->|
 19 |     //
 20 |     //
 21 |     //          size2freeblock         offset2freeblock
 22 |     //           size->offset            offset->size
 23 |     //
 24 |     //                16 ------------------>   8 ---------->  {size = 16, &size2freeblock[0]}
 25 |     //
 26 |     //                16 ------.   .------->  32 ---------->  {size = 24, &size2freeblock[2]}
 27 |     //                          '.'
 28 |     //                24 -------' '-------->  64 ---------->  {size = 16, &size2freeblock[1]}
 29 |     //
 30 |     //                32 ------------------> 104 ---------->  {size = 32, &size2freeblock[3]}
 31 |     //
 32 |     class VarSizeAllocMngr {
 33 |     public:
 34 |         VarSizeAllocMngr(size_t capacity);
 35 |         VarSizeAllocMngr(VarSizeAllocMngr&&) noexcept;
 36 | 
 37 |         VarSizeAllocMngr& operator=(VarSizeAllocMngr&&) noexcept;
 38 | 
 39 |         VarSizeAllocMngr(const VarSizeAllocMngr&) = delete;
 40 |         VarSizeAllocMngr& operator=(const VarSizeAllocMngr&) = delete;
 41 | 
 42 |         // Offset returned by Allocate() may not be aligned, but the size of the allocation
 43 |         // is sufficient to properly align it
 44 |         struct Allocation {
 45 |             static constexpr size_t InvalidOffset = static_cast<size_t>(-1);
 46 | 
 47 |             static constexpr Allocation Invalid() noexcept { return {}; }
 48 | 
 49 |             constexpr bool IsValid() const noexcept { return unalignedOffset != Invalid().unalignedOffset; }
 50 |             constexpr void Reset() noexcept { *this = Invalid(); }
 51 | 
 52 |             size_t unalignedOffset{ InvalidOffset };
 53 |             size_t size{ 0 };
 54 |         };
 55 | 
 56 |         Allocation Allocate(size_t size, size_t alignment);
 57 | 
 58 |         void Free(Allocation&& allocation) {
 59 |             Free(allocation.unalignedOffset, allocation.size);
 60 |             allocation.Reset();
 61 |         }
 62 |         void Free(size_t offset, size_t size);
 63 | 
 64 |         bool IsFull() const noexcept { return freeSize == 0; };
 65 |         bool IsEmpty() const noexcept { return freeSize == capacity; };
 66 |         size_t GetCapacity() const noexcept { return capacity; }
 67 |         size_t GetFreeSize() const noexcept { return freeSize; }
 68 |         size_t GetUsedSize() const noexcept { return capacity - freeSize; }
 69 | 
 70 |     private:
 71 |         void AddNewBlock(size_t Offset, size_t Size);
 72 | 
 73 |         void ResetCurrAlignment() noexcept;
 74 | 
 75 |         struct FreeBlockInfo;
 76 | 
 77 |         // Type of the map that keeps memory blocks sorted by their offsets
 78 |         using TFreeBlocksByOffsetMap = std::map<size_t, FreeBlockInfo>;
 79 | 
 80 |         // Type of the map that keeps memory blocks sorted by their sizes
 81 |         using TFreeBlocksBySizeMap = std::multimap<size_t, TFreeBlocksByOffsetMap::iterator>;
 82 | 
 83 |         struct FreeBlockInfo {
 84 |             // Block size (no reserved space for the size of the allocation)
 85 |             size_t size;
 86 | 
 87 |             // Iterator referencing this block in the multimap sorted by the block size
 88 |             TFreeBlocksBySizeMap::iterator OrderBySizeIt;
 89 | 
 90 |             FreeBlockInfo(size_t size) : size(size) {}
 91 |         };
 92 | 
 93 |         TFreeBlocksByOffsetMap offset2freeblock;
 94 |         TFreeBlocksBySizeMap   size2freeblock;
 95 | 
 96 |         size_t capacity = 0;
 97 |         size_t freeSize = 0;
 98 |         size_t curMinAlignment = 0; // min alignment of all free blocks
 99 |     };
100 | }
101 | 


--------------------------------------------------------------------------------
/include/UDX12/_deps/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | Ubpa_DownloadZip(
2 |   https://udata-1308066321.cos.ap-guangzhou.myqcloud.com/d3dx12_20200602.zip
3 |   d3dx12.zip
4 |   SHA256 8ADAFBA084B8F2FB5272A81E2B8D8248E14FF5B87531616D6FE55DE4A091B327
5 | )
6 | 


--------------------------------------------------------------------------------
/include/UDX12/_deps/DirectXTK12/DirectXTK12.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "Audio.h"
 4 | #include "BufferHelpers.h"
 5 | #include "CommonStates.h"
 6 | #include "DDSTextureLoader.h"
 7 | #include "DescriptorHeap.h"
 8 | #include "DirectXHelpers.h"
 9 | #include "EffectPipelineStateDescription.h"
10 | #include "Effects.h"
11 | #include "GamePad.h"
12 | #include "GeometricPrimitive.h"
13 | #include "GraphicsMemory.h"
14 | #include "Keyboard.h"
15 | #include "Model.h"
16 | #include "Mouse.h"
17 | #include "PostProcess.h"
18 | #include "PrimitiveBatch.h"
19 | #include "RenderTargetState.h"
20 | #include "ResourceUploadBatch.h"
21 | #include "ScreenGrab.h"
22 | #include "SimpleMath.h"
23 | #include "SimpleMath.inl"
24 | #include "SpriteBatch.h"
25 | #include "SpriteFont.h"
26 | #include "VertexTypes.h"
27 | #include "WICTextureLoader.h"
28 | #include "XboxDDSTextureLoader.h"
29 | 


--------------------------------------------------------------------------------
/include/UDX12/details/FrameRsrcMngr.inl:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <UTemplate/Func.hpp>
 4 | 
 5 | namespace Ubpa::UDX12 {
 6 | 	template<typename T>
 7 | 	T& FrameResource::GetResource(std::string_view name) {
 8 | 		static_assert(!std::is_reference_v<T>);
 9 | 		assert(HaveResource(name));
10 | 		return std::any_cast<T&>(resourceMap.find(name)->second);
11 | 	}
12 | 
13 | 	template<typename T>
14 | 	const T& FrameResource::GetResource(std::string_view name) const {
15 | 		return const_cast<FrameResource*>(this)->GetResource<T>();
16 | 	}
17 | 
18 | 	template<typename T>
19 | 	FrameResource& FrameResource::RegisterResource(std::string name, T&& resource) {
20 | 		assert(!HaveResource(name));
21 | 		resourceMap.emplace(std::move(name), std::any{ std::forward<T>(resource) });
22 | 		return *this;
23 | 	}
24 | 
25 | 	template<typename Func>
26 | 	FrameResource& FrameResource::DelayUpdateResource(std::string name, Func&& updator) {
27 | 		using ArgList = FuncTraits_ArgList<std::decay_t<Func>>;
28 | 		static_assert(Length_v<ArgList> == 1);
29 | 		using Arg = Front_t<ArgList>;
30 | 		delayUpdatorMap.emplace_back(std::tuple{ std::move(name), std::function{
31 | 			[updator = std::forward<Func>(updator)] (std::any& resource) mutable {
32 | 				updator(std::any_cast<Arg>(resource));
33 | 			}
34 | 		}});
35 | 		return *this;
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/include/UDX12/details/GCmdList.inl:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace Ubpa::UDX12 {
 4 |     template<typename... Heaps, typename>
 5 |     void GCmdList::SetDescriptorHeaps(Heaps*... heaps){
 6 |         constexpr size_t N = sizeof...(Heaps);
 7 |         ID3D12DescriptorHeap* arr[N] = { heaps... };
 8 | 
 9 | #ifndef NDEBUG
10 |         for (SIZE_T i = 0; i < N; i++) {
11 |             ID3D12DescriptorHeap* heapi = arr[i];
12 |             auto typei = heapi->GetDesc().Type;
13 |             assert(typei == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV || typei == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
14 |             for (SIZE_T j = 1; j < N; j++) {
15 |                 ID3D12DescriptorHeap* heapj = arr[j];
16 |                 auto typej = heapj->GetDesc().Type;
17 |                 assert(typei != typej);
18 |             }
19 |         }
20 | #endif // !NDEBUG
21 | 
22 |         raw->SetDescriptorHeaps(N, arr);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/include/UDX12/details/UploadBuffer.inl:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace Ubpa::UDX12 {
 4 | 	template<typename T>
 5 | 	constexpr UINT ArrayUploadBuffer<T>::ElementSize(bool isConstantBuffer) {
 6 | 		return isConstantBuffer ? Util::CalcConstantBufferByteSize(sizeof(T)) : sizeof(T);
 7 | 	}
 8 | 
 9 | 	template<typename T>
10 | 	ArrayUploadBuffer<T>::ArrayUploadBuffer(ID3D12Device* device, UINT64 numElement, bool isConstantBuffer,
11 | 		D3D12_RESOURCE_FLAGS flag)
12 | 		: UploadBuffer{device, numElement * ElementSize(isConstantBuffer), flag },
13 | 		isConstantBuffer{ isConstantBuffer },
14 | 		numElement{ numElement }
15 | 	{
16 | 	}
17 | 
18 | 	template<typename T>
19 | 	void ArrayUploadBuffer<T>::Set(UINT64 index, const T* data, UINT64 numElement) {
20 | 		assert(index < this->numElement);
21 | 		auto elementSize = ElementSize(isConstantBuffer);
22 | 		UploadBuffer::Set(index * elementSize, data, numElement * elementSize);
23 | 	}
24 | 
25 | 	template<typename T>
26 | 	void ArrayUploadBuffer<T>::Set(UINT64 index, const T& element) {
27 | 		assert(index < numElement);
28 | 		auto elementSize = ElementSize(isConstantBuffer);
29 | 		UploadBuffer::Set(index * elementSize, &element, elementSize);
30 | 	}
31 | 
32 | 	// ===
33 | 
34 | 	template<typename T>
35 | 	constexpr UINT VectorUploadBuffer<T>::ElementSize(bool isConstantBuffer) {
36 | 		return isConstantBuffer ? Util::CalcConstantBufferByteSize(sizeof(T)) : sizeof(T);
37 | 	}
38 | 
39 | 	template<typename T>
40 | 	VectorUploadBuffer<T>::VectorUploadBuffer(ID3D12Device* device, bool isConstantBuffer,
41 | 		D3D12_RESOURCE_FLAGS flag)
42 | 		: DynamicUploadBuffer{ device, 0, flag },
43 | 		isConstantBuffer{ isConstantBuffer },
44 | 		size{ 0 }
45 | 	{
46 | 	}
47 | 
48 | 	template<typename T>
49 | 	void VectorUploadBuffer<T>::Pushback(const T& ele) {
50 | 		if (size == Capacity())
51 | 			Reserve(size == 0 ? 1 : 2 * size);
52 | 		Set<T>(size * ElementSize<T>(isConstantBuffer), &ele);
53 | 	}
54 | 
55 | 	template<typename T>
56 | 	T& VectorUploadBuffer<T>::At(size_t idx) {
57 | 		if (idx >= size)
58 | 			throw std::out_of_range{ "VectorUploadBuffer::At out of range" };
59 | 		return *(Data() + idx);
60 | 	}
61 | 
62 | 	template<typename T>
63 | 	const T& VectorUploadBuffer<T>::At(size_t idx) const {
64 | 		return const_cast<VectorUploadBuffer*>(this)->At(idx);
65 | 	}
66 | 
67 | 	template<typename T>
68 | 	T& VectorUploadBuffer<T>::operator[](size_t idx) noexcept {
69 | 		assert(idx < size);
70 | 		return *(Data() + idx);
71 | 	}
72 | 
73 | 	template<typename T>
74 | 	const T& VectorUploadBuffer<T>::operator[](size_t idx) const noexcept {
75 | 		return const_cast<VectorUploadBuffer*>(this)->operator[](idx);
76 | 	}
77 | 
78 | 	template<typename T>
79 | 	D3D12_GPU_VIRTUAL_ADDRESS VectorUploadBuffer<T>::GpuAdressAt(size_t idx) const {
80 | 		if (idx >= size)
81 | 			throw std::out_of_range{ "VectorUploadBuffer::GpuAdressAt out of range" };
82 | 
83 | 		return DynamicUploadBuffer::GetResource()->GetGPUVirtualAddress() + idx * ElementSize<T>(isConstantBuffer);
84 | 	}
85 | }
86 | 


--------------------------------------------------------------------------------
/src/core/Blob.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/Blob.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | void UDX12::Blob::Create(SIZE_T size) {
 6 |     ThrowIfFailed(D3DCreateBlob(size, &raw));
 7 | }
 8 | 
 9 | void UDX12::Blob::Copy(const void* data, SIZE_T size) {
10 |     CopyMemory(raw->GetBufferPointer(), data, size);
11 | }
12 | 
13 | void UDX12::Blob::Create(const void* data, SIZE_T size) {
14 |     Create(size);
15 |     Copy(data, size);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/core/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(c_options_private "")
 2 | if(MSVC)
 3 |   list(APPEND c_options_private "/wd4996;/MP")
 4 | elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 5 |   #
 6 | elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 7 |   #
 8 | endif()
 9 | 
10 | Ubpa_AddTarget(
11 |   MODE STATIC
12 |   RET_TARGET_NAME core
13 |   SOURCE
14 |     "${PROJECT_SOURCE_DIR}/include/UDX12"
15 |     "_deps/DirectXTK12/Shaders/Compiled/SpriteEffect_SpriteVertexShader.inc"
16 |   INC
17 |     "${PROJECT_SOURCE_DIR}/include"
18 |   INC_PRIVATE
19 |     "${PROJECT_SOURCE_DIR}/include/UDX12/_deps/DirectXTK12"
20 |   LIB
21 |     Ubpa::UTemplate_core
22 |     Ubpa::UFG_core
23 |     Ubpa::UThreadPool_core
24 |   LIB_INTERFACE
25 |     d3dcompiler.lib
26 |     D3D12.lib
27 |     dxgi.lib
28 |     dxguid.lib
29 |   C_OPTION_PRIVATE
30 |     ${c_options_private}
31 |   DEFINE
32 |     UNICODE
33 | 	_UNICODE
34 |     NOMINMAX
35 | )
36 | 
37 | if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.16")
38 |   target_precompile_headers(${core} PRIVATE _deps/DirectXTK12/pch.h)
39 | endif()
40 | 
41 | set(SHADER_SOURCES
42 |   _deps/DirectXTK12/Shaders/AlphaTestEffect.fx
43 |   _deps/DirectXTK12/Shaders/BasicEffect.fx
44 |   _deps/DirectXTK12/Shaders/Common.fxh
45 |   _deps/DirectXTK12/Shaders/DebugEffect.fx
46 |   _deps/DirectXTK12/Shaders/DualTextureEffect.fx
47 |   _deps/DirectXTK12/Shaders/EnvironmentMapEffect.fx
48 |   _deps/DirectXTK12/Shaders/GenerateMips.hlsl
49 |   _deps/DirectXTK12/Shaders/Lighting.fxh
50 |   _deps/DirectXTK12/Shaders/NormalMapEffect.fx
51 |   _deps/DirectXTK12/Shaders/PBRCommon.fxh
52 |   _deps/DirectXTK12/Shaders/PBREffect.fx
53 |   _deps/DirectXTK12/Shaders/PixelPacking_Velocity.hlsli
54 |   _deps/DirectXTK12/Shaders/PostProcess.fx
55 |   _deps/DirectXTK12/Shaders/RootSig.fxh
56 |   _deps/DirectXTK12/Shaders/SkinnedEffect.fx
57 |   _deps/DirectXTK12/Shaders/SpriteEffect.fx
58 |   _deps/DirectXTK12/Shaders/Structures.fxh
59 |   _deps/DirectXTK12/Shaders/ToneMap.fx
60 |   _deps/DirectXTK12/Shaders/Utilities.fxh
61 | )
62 | 
63 | add_custom_command(
64 |   OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/_deps/DirectXTK12/Shaders/Compiled/SpriteEffect_SpriteVertexShader.inc"
65 |   MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/_deps/DirectXTK12/Shaders/CompileShaders.cmd"
66 |   DEPENDS ${SHADER_SOURCES}
67 |   COMMENT "Generating HLSL shaders..."
68 |   COMMAND "CompileShaders.cmd"
69 |   WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/_deps/DirectXTK12/Shaders"
70 |   USES_TERMINAL
71 | )
72 | 


--------------------------------------------------------------------------------
/src/core/CmdQueue.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/CmdQueue.h>
 2 | 
 3 | #include <array>
 4 | 
 5 | using namespace Ubpa;
 6 | 
 7 | void UDX12::CmdQueue::Execute(ID3D12GraphicsCommandList* list) {
 8 | 	const std::array<ID3D12CommandList*, 1> listArr = { list };
 9 | 	raw->ExecuteCommandLists(1, listArr.data());
10 | }
11 | 


--------------------------------------------------------------------------------
/src/core/D3DInclude.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/D3DInclude.h>
  2 | 
  3 | #include <fstream>
  4 | #include <filesystem>
  5 | 
  6 | HRESULT __stdcall Ubpa::UDX12::D3DInclude::Open(
  7 | 	D3D_INCLUDE_TYPE IncludeType,
  8 | 	LPCSTR pFileName,
  9 | 	LPCVOID pParentData,
 10 | 	LPCVOID* ppData,
 11 | 	UINT* pBytes
 12 | ) {
 13 | 	try {
 14 | 		std::string finalPath;
 15 | 		switch (IncludeType) {
 16 | 		case D3D_INCLUDE_LOCAL:
 17 | 			finalPath = localDir + "/" + pFileName;
 18 | 				break;
 19 | 		case D3D_INCLUDE_SYSTEM:
 20 | 			finalPath = systemDir + "/" + pFileName;
 21 | 				break;
 22 | 		default:
 23 | 			assert(0);
 24 | 		}
 25 | 
 26 | 		std::ifstream includeFile(finalPath.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
 27 | 
 28 | 		if (includeFile.is_open()) {
 29 | 			auto fileSize = includeFile.tellg();
 30 | 			char* buf = new char[fileSize];
 31 | 			includeFile.seekg(0, std::ios::beg);
 32 | 			includeFile.read(buf, fileSize);
 33 | 			includeFile.close();
 34 | 			*ppData = buf;
 35 | 			*pBytes = static_cast<UINT>(fileSize);
 36 | 		}
 37 | 		else {
 38 | 			return E_FAIL;
 39 | 		}
 40 | 		return S_OK;
 41 | 	}
 42 | 	catch (...) {
 43 | 		return E_FAIL;
 44 | 	}
 45 | }
 46 | 
 47 | HRESULT __stdcall Ubpa::UDX12::D3DInclude::Close(LPCVOID pData) {
 48 | 	char* buf = (char*)pData;
 49 | 	delete[] buf;
 50 | 	return S_OK;
 51 | }
 52 | 
 53 | HRESULT Ubpa::UDX12::DxcInclude::QueryInterface(REFIID riid, LPVOID* ppvObj)
 54 | {
 55 | 	// Always set out parameter to NULL, validating it first.
 56 | 	if (!ppvObj)
 57 | 		return E_INVALIDARG;
 58 | 	*ppvObj = NULL;
 59 | 	if (riid == IID_IUnknown || riid == __uuidof(IDxcIncludeHandler) ||
 60 | 		riid == __uuidof(DxcInclude))
 61 | 	{
 62 | 		// Increment the reference count and return the pointer.
 63 | 		*ppvObj = (LPVOID)this;
 64 | 		AddRef();
 65 | 		return NOERROR;
 66 | 	}
 67 | 	return E_NOINTERFACE;
 68 | }
 69 | 
 70 | ULONG STDMETHODCALLTYPE Ubpa::UDX12::DxcInclude::AddRef(void) {
 71 | 	++m_cRef;
 72 | 	return m_cRef;
 73 | }
 74 | 
 75 | ULONG STDMETHODCALLTYPE Ubpa::UDX12::DxcInclude::Release(void) {
 76 | 	assert(m_cRef > 0);
 77 | 	ULONG n = --m_cRef;
 78 | 	if (0 == n)
 79 | 		delete this;
 80 | 	return n;
 81 | }
 82 | 
 83 | void Ubpa::UDX12::DxcInclude::Clear() {
 84 | 	for (char* buffer : buffers)
 85 | 		delete[] buffer;
 86 | 	buffers.clear();
 87 | }
 88 | 
 89 | HRESULT __stdcall Ubpa::UDX12::DxcInclude::LoadSource(
 90 | 	LPCWSTR pFilename,                                   // Candidate filename.
 91 | 	IDxcBlob** ppIncludeSource  // Resultant source object for included file, nullptr if not found.
 92 | ) {
 93 | 	try {
 94 | 		std::filesystem::path finalPath(dir);
 95 | 		finalPath += LR"(\)";
 96 | 		finalPath += std::filesystem::path(pFilename);
 97 | 
 98 | 		std::ifstream includeFile(finalPath.string().c_str(), std::ios::in | std::ios::binary | std::ios::ate);
 99 | 
100 | 		if (includeFile.is_open()) {
101 | 			auto fileSize = includeFile.tellg();
102 | 			char* buf = new char[fileSize];
103 | 			includeFile.seekg(0, std::ios::beg);
104 | 			includeFile.read(buf, fileSize);
105 | 			includeFile.close();
106 | 
107 | 			IDxcBlobEncoding* blob = nullptr;
108 | 			lib->CreateBlobWithEncodingFromPinned(buf, (UINT32)fileSize, 0, &blob);
109 | 			*ppIncludeSource = blob;
110 | 			buffers.push_back(buf);
111 | 		}
112 | 		else {
113 | 			return E_FAIL;
114 | 		}
115 | 		return S_OK;
116 | 	}
117 | 	catch (...) {
118 | 		return E_FAIL;
119 | 	}
120 | }


--------------------------------------------------------------------------------
/src/core/Desc.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/Desc.h>
  2 | #include <d3d12.h>
  3 | 
  4 | using namespace Ubpa;
  5 | 
  6 | D3D12_SHADER_RESOURCE_VIEW_DESC UDX12::Desc::SRV::Tex2D(DXGI_FORMAT format, UINT MipLevels) {
  7 | 	D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc;
  8 | 	ZeroMemory(&srvDesc, sizeof(D3D12_SHADER_RESOURCE_VIEW_DESC));
  9 |     srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
 10 |     srvDesc.Format = format;
 11 |     srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
 12 |     srvDesc.Texture2D.MostDetailedMip = 0;
 13 | 	srvDesc.Texture2D.PlaneSlice = 0;
 14 |     srvDesc.Texture2D.MipLevels = MipLevels;
 15 |     srvDesc.Texture2D.ResourceMinLODClamp = 0.0f;
 16 |     return srvDesc;
 17 | }
 18 | 
 19 | D3D12_SHADER_RESOURCE_VIEW_DESC UDX12::Desc::SRV::Tex3D(DXGI_FORMAT format, UINT MipLevels) {
 20 | 	D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc;
 21 | 	ZeroMemory(&srvDesc, sizeof(D3D12_SHADER_RESOURCE_VIEW_DESC));
 22 | 	srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
 23 | 	srvDesc.Format = format;
 24 | 	srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
 25 | 	srvDesc.Texture3D.MipLevels = MipLevels;
 26 | 	srvDesc.Texture3D.MostDetailedMip = 0;
 27 | 	srvDesc.Texture3D.ResourceMinLODClamp = 0.f;
 28 | 	return srvDesc;
 29 | }
 30 | 
 31 | D3D12_SHADER_RESOURCE_VIEW_DESC UDX12::Desc::SRV::TexCube(DXGI_FORMAT format, UINT MipLevels) {
 32 | 	D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc;
 33 | 	ZeroMemory(&srvDesc, sizeof(D3D12_SHADER_RESOURCE_VIEW_DESC));
 34 | 	srvDesc.Format = format;
 35 | 	srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
 36 | 	srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
 37 | 	srvDesc.TextureCube.MostDetailedMip = 0;
 38 | 	srvDesc.TextureCube.MipLevels = MipLevels;
 39 | 	srvDesc.TextureCube.ResourceMinLODClamp = 0.0f;
 40 | 	return srvDesc;
 41 | }
 42 | 
 43 | D3D12_DEPTH_STENCIL_VIEW_DESC UDX12::Desc::DSV::Basic(DXGI_FORMAT format) {
 44 | 	D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc;
 45 | 
 46 | 	ZeroMemory(&dsvDesc, sizeof(D3D12_DEPTH_STENCIL_VIEW_DESC));
 47 | 
 48 | 	dsvDesc.Flags = D3D12_DSV_FLAG_NONE;
 49 | 	dsvDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
 50 | 	dsvDesc.Format = format;
 51 | 	dsvDesc.Texture2D.MipSlice = 0;
 52 | 
 53 | 	return dsvDesc;
 54 | }
 55 | 
 56 | D3D12_GRAPHICS_PIPELINE_STATE_DESC UDX12::Desc::PSO::Basic(
 57 |     ID3D12RootSignature* rootSig,
 58 | 	const D3D12_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements,
 59 | 	const ID3DBlob* VS,
 60 | 	const ID3DBlob* PS,
 61 |     DXGI_FORMAT rtvFormat,
 62 |     DXGI_FORMAT dsvFormat)
 63 | {
 64 | 	return MRT(rootSig,
 65 | 		pInputElementDescs, NumElements,
 66 | 		VS, PS,
 67 | 		1,
 68 | 		rtvFormat,
 69 | 		dsvFormat);
 70 | }
 71 | 
 72 | D3D12_RENDER_TARGET_VIEW_DESC UDX12::Desc::RTV::Tex2DofTexCube(
 73 | 	DXGI_FORMAT format,
 74 | 	UINT Index,
 75 | 	UINT MipSlice
 76 | ) {
 77 | 	D3D12_RENDER_TARGET_VIEW_DESC desc;
 78 | 	ZeroMemory(&desc, sizeof(D3D12_RENDER_TARGET_VIEW_DESC));
 79 | 
 80 | 	desc.Format = format;
 81 | 	desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
 82 | 	desc.Texture2DArray.ArraySize = 1;
 83 | 	desc.Texture2DArray.FirstArraySlice = Index;
 84 | 	desc.Texture2DArray.MipSlice = MipSlice;
 85 | 	desc.Texture2DArray.PlaneSlice = 0;
 86 | 
 87 | 	return desc;
 88 | }
 89 | 
 90 | D3D12_GRAPHICS_PIPELINE_STATE_DESC UDX12::Desc::PSO::MRT(
 91 | 	ID3D12RootSignature* rootSig,
 92 | 	const D3D12_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements,
 93 | 	const ID3DBlob* VS,
 94 | 	const ID3DBlob* PS,
 95 | 	UINT rtNum,
 96 | 	DXGI_FORMAT rtvFormat,
 97 | 	DXGI_FORMAT dsvFormat)
 98 | {
 99 | 	D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc;
100 | 
101 | 	ZeroMemory(&psoDesc, sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
102 | 	psoDesc.InputLayout = { pInputElementDescs, NumElements };
103 | 	psoDesc.pRootSignature = rootSig;
104 | 	psoDesc.VS = { const_cast<ID3DBlob*>(VS)->GetBufferPointer(), const_cast<ID3DBlob*>(VS)->GetBufferSize() };
105 | 	psoDesc.PS = { const_cast<ID3DBlob*>(PS)->GetBufferPointer(), const_cast<ID3DBlob*>(PS)->GetBufferSize() };
106 | 	psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
107 | 	psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
108 | 	psoDesc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
109 | 	psoDesc.SampleMask = UINT_MAX;
110 | 	psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
111 | 	psoDesc.NumRenderTargets = rtNum;
112 | 	for (UINT i = 0; i < rtNum; i++)
113 | 		psoDesc.RTVFormats[i] = rtvFormat;
114 | 	psoDesc.SampleDesc.Count = 1;
115 | 	psoDesc.SampleDesc.Quality = 0;
116 | 	psoDesc.DSVFormat = dsvFormat;
117 | 
118 | 	return psoDesc;
119 | }
120 | 
121 | D3D12_RESOURCE_DESC UDX12::Desc::RSRC::Basic(
122 | 	D3D12_RESOURCE_DIMENSION dimension,
123 | 	UINT64 Width,
124 | 	UINT Height,
125 | 	DXGI_FORMAT format,
126 | 	D3D12_RESOURCE_FLAGS flags)
127 | {
128 | 	D3D12_RESOURCE_DESC desc;
129 | 	ZeroMemory(&desc, sizeof(D3D12_RESOURCE_DESC));
130 | 
131 | 	desc.Dimension = dimension;
132 | 	desc.Alignment = 0;
133 | 	desc.Width = Width;
134 | 	desc.Height = Height;
135 | 	desc.DepthOrArraySize = 1;
136 | 	desc.MipLevels = 1;
137 | 	desc.Format = format;
138 | 	desc.SampleDesc.Count = 1;
139 | 	desc.SampleDesc.Quality = 0;
140 | 	desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
141 | 	desc.Flags = flags;
142 | 
143 | 	return desc;
144 | }
145 | 
146 | D3D12_RESOURCE_DESC UDX12::Desc::RSRC::RT2D(
147 | 	UINT64 Width,
148 | 	UINT Height,
149 | 	DXGI_FORMAT format)
150 | {
151 | 	return Basic(D3D12_RESOURCE_DIMENSION_TEXTURE2D, Width, Height, format, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
152 | }
153 | 
154 | D3D12_RESOURCE_DESC UDX12::Desc::RSRC::TextureCube(
155 | 	UINT64 Width,
156 | 	UINT Height,
157 | 	UINT MipLevels,
158 | 	DXGI_FORMAT format,
159 | 	D3D12_RESOURCE_FLAGS flags
160 | ) {
161 | 	D3D12_RESOURCE_DESC desc;
162 | 	ZeroMemory(&desc, sizeof(D3D12_RESOURCE_DESC));
163 | 
164 | 	desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
165 | 	desc.Alignment = 0;
166 | 	desc.Width = Width;
167 | 	desc.Height = Height;
168 | 	desc.DepthOrArraySize = 6;
169 | 	desc.MipLevels = MipLevels;
170 | 	desc.Format = format;
171 | 	desc.SampleDesc.Count = 1;
172 | 	desc.SampleDesc.Quality = 0;
173 | 	desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
174 | 	desc.Flags = flags;
175 | 
176 | 	return desc;
177 | }


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/CPUDescriptorHeap.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/DescriptorHeap/CPUDescriptorHeap.h>
 2 | 
 3 | #include <UDX12/DescriptorHeap/DescriptorHeapAllocation.h>
 4 | 
 5 | using namespace Ubpa;
 6 | 
 7 | UDX12::CPUDescriptorHeap::CPUDescriptorHeap(
 8 |     ID3D12Device*               pDevice,
 9 |     uint32_t                    NumDescriptorsInHeap,
10 |     D3D12_DESCRIPTOR_HEAP_TYPE  Type,
11 |     D3D12_DESCRIPTOR_HEAP_FLAGS Flags)
12 |     :
13 |     m_pDevice{ pDevice },
14 |     m_HeapDesc
15 |     {
16 |         Type,
17 |         NumDescriptorsInHeap,
18 |         Flags,
19 |         1   // NodeMask
20 |     },
21 |     m_DescriptorSize{ pDevice->GetDescriptorHandleIncrementSize(Type) }
22 | {
23 |     // Create one pool
24 |     m_HeapPool.emplace_back(m_pDevice, *this, 0, m_HeapDesc);
25 |     m_AvailableHeaps.insert(0);
26 | }
27 | 
28 | UDX12::CPUDescriptorHeap::~CPUDescriptorHeap() {
29 |     assert(m_CurrentSize == 0 && "Not all allocations released");
30 | 
31 |     assert(m_AvailableHeaps.size() == m_HeapPool.size() && "Not all descriptor heap pools are released");
32 | 
33 | #ifndef NDEBUG
34 |     for (const auto& Heap : m_HeapPool)
35 |         assert(Heap.GetNumAvailableDescriptors() == Heap.GetMaxDescriptors() && "Not all descriptors in the descriptor pool are released");
36 | #endif // !NDEBUG
37 | }
38 | 
39 | UDX12::DescriptorHeapAllocation UDX12::CPUDescriptorHeap::Allocate(uint32_t count) {
40 |     std::lock_guard<std::mutex> lockGuard(m_HeapPoolMutex);
41 |     // Note that every DescriptorHeapAllocationManager object instance is itslef
42 |     // thread-safe. Nested mutexes cannot cause a deadlock
43 | 
44 |     DescriptorHeapAllocation allocation;
45 |     // Go through all descriptor heap managers that have free descriptors
46 |     auto availableHeapIter = m_AvailableHeaps.begin();
47 |     while (availableHeapIter != m_AvailableHeaps.end()) {
48 |         auto nextIter = availableHeapIter;
49 |         ++nextIter;
50 |         // Try to allocate descriptor using the current descriptor heap manager
51 |         allocation = m_HeapPool[*availableHeapIter].Allocate(count);
52 |         // Remove the manager from the pool if it has no more available descriptors
53 |         if (m_HeapPool[*availableHeapIter].GetNumAvailableDescriptors() == 0)
54 |             m_AvailableHeaps.erase(*availableHeapIter);
55 | 
56 |         // Terminate the loop if descriptor was successfully allocated, otherwise
57 |         // go to the next manager
58 |         if (!allocation.IsNull())
59 |             break;
60 |         availableHeapIter = nextIter;
61 |     }
62 | 
63 |     // If there were no available descriptor heap managers or no manager was able
64 |     // to suffice the allocation request, create a new manager
65 |     if (allocation.IsNull()) {
66 |         // Make sure the heap is large enough to accomodate the requested number of descriptors
67 |         m_HeapDesc.NumDescriptors = std::max(m_HeapDesc.NumDescriptors, static_cast<UINT>(count));
68 |         // Create a new descriptor heap manager. Note that this constructor creates a new D3D12 descriptor
69 |         // heap and references the entire heap. Pool index is used as manager ID
70 |         m_HeapPool.emplace_back(m_pDevice, *this, m_HeapPool.size(), m_HeapDesc);
71 |         auto newHeapIter = m_AvailableHeaps.insert(m_HeapPool.size() - 1);
72 |         assert(newHeapIter.second);
73 | 
74 |         // Use the new manager to allocate descriptor handles
75 |         allocation = m_HeapPool[*newHeapIter.first].Allocate(count);
76 |     }
77 | 
78 |     m_CurrentSize += static_cast<uint32_t>(allocation.GetNumHandles());
79 |     m_MaxSize = std::max(m_MaxSize, m_CurrentSize);
80 | 
81 |     return allocation;
82 | }
83 | 
84 | void UDX12::CPUDescriptorHeap::Free(DescriptorHeapAllocation&& allocation) {
85 |     std::lock_guard<std::mutex> lockGuard(m_HeapPoolMutex);
86 |     auto                        managerId = allocation.GetAllocationManagerId();
87 |     m_CurrentSize -= static_cast<uint32_t>(allocation.GetNumHandles());
88 |     m_HeapPool[managerId].FreeAllocation(std::move(allocation));
89 |     // Return the manager to the pool of available managers
90 |     assert(m_HeapPool[managerId].GetNumAvailableDescriptors() > 0);
91 |     m_AvailableHeaps.insert(managerId);
92 | }
93 | 


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/DescriptorHeapAllocMngr.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/DescriptorHeap/DescriptorHeapAllocMngr.h>
  2 | 
  3 | #include <UDX12/DescriptorHeap/DescriptorHeapAllocation.h>
  4 | 
  5 | using namespace Ubpa;
  6 | 
  7 | UDX12::DescriptorHeapAllocMngr::DescriptorHeapAllocMngr(DescriptorHeapAllocMngr&& rhs) noexcept :
  8 |     m_ParentAllocator           { rhs.m_ParentAllocator },
  9 |     m_pDevice                   { rhs.m_pDevice },
 10 |     m_ThisManagerId             { rhs.m_ThisManagerId },
 11 |     m_HeapDesc                  { rhs.m_HeapDesc },
 12 |     m_DescriptorSize            { rhs.m_DescriptorSize },
 13 |     m_NumDescriptorsInAllocation{ rhs.m_NumDescriptorsInAllocation },
 14 |     m_FirstCPUHandle            { rhs.m_FirstCPUHandle },
 15 |     m_FirstGPUHandle            { rhs.m_FirstGPUHandle },
 16 |     m_MaxAllocatedSize          { rhs.m_MaxAllocatedSize },
 17 |     // Mutex is not movable
 18 |     //m_FreeBlockManagerMutex   { std::move(rhs.m_FreeBlockManagerMutex) },
 19 |     m_FreeBlockManager          { std::move(rhs.m_FreeBlockManager) },
 20 |     m_pd3d12DescriptorHeap      { std::move(rhs.m_pd3d12DescriptorHeap) }
 21 | {
 22 |     rhs.m_NumDescriptorsInAllocation = 0; // Must be set to zero so that debug check in dtor passes
 23 |     rhs.m_ThisManagerId = static_cast<size_t>(-1);
 24 |     rhs.m_FirstCPUHandle.ptr = 0;
 25 |     rhs.m_FirstGPUHandle.ptr = 0;
 26 |     rhs.m_MaxAllocatedSize = 0;
 27 | 
 28 | #ifndef NDEBUG
 29 |     m_AllocationsCounter.store(rhs.m_AllocationsCounter.load());
 30 |     rhs.m_AllocationsCounter = 0;
 31 | #endif // !NDEBUG
 32 | }
 33 | 
 34 | // Creates a new descriptor heap and reference the entire heap
 35 | UDX12::DescriptorHeapAllocMngr::DescriptorHeapAllocMngr(
 36 |     ID3D12Device*                     pDevice,
 37 |     IDescriptorAllocator&             ParentAllocator,
 38 |     size_t                            ThisManagerId,
 39 |     const D3D12_DESCRIPTOR_HEAP_DESC& HeapDesc)
 40 |     :
 41 |     m_ParentAllocator            {ParentAllocator},
 42 |     m_pDevice                    {pDevice        },
 43 |     m_ThisManagerId              {ThisManagerId  },
 44 |     m_HeapDesc                   {HeapDesc       },
 45 |     m_DescriptorSize             {pDevice->GetDescriptorHandleIncrementSize(m_HeapDesc.Type)},
 46 |     m_NumDescriptorsInAllocation {HeapDesc.NumDescriptors},
 47 |     m_FreeBlockManager           {HeapDesc.NumDescriptors}
 48 | {
 49 |     m_FirstCPUHandle.ptr = 0;
 50 |     m_FirstGPUHandle.ptr = 0;
 51 |     
 52 |     pDevice->CreateDescriptorHeap(
 53 |         &m_HeapDesc,
 54 |         __uuidof(m_pd3d12DescriptorHeap),
 55 |         reinterpret_cast<void**>(static_cast<ID3D12DescriptorHeap**>(&m_pd3d12DescriptorHeap))
 56 |     );
 57 |     m_FirstCPUHandle = m_pd3d12DescriptorHeap->GetCPUDescriptorHandleForHeapStart();
 58 |     if (m_HeapDesc.Flags & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)
 59 |         m_FirstGPUHandle = m_pd3d12DescriptorHeap->GetGPUDescriptorHandleForHeapStart();
 60 | }
 61 | 
 62 | // Uses subrange of descriptors in the existing D3D12 descriptor heap
 63 | // that starts at offset FirstDescriptor and uses NumDescriptors descriptors
 64 | UDX12::DescriptorHeapAllocMngr::DescriptorHeapAllocMngr(
 65 |     ID3D12Device*         pDevice,
 66 |     IDescriptorAllocator& ParentAllocator,
 67 |     size_t                ThisManagerId,
 68 |     ID3D12DescriptorHeap* pd3d12DescriptorHeap,
 69 |     uint32_t              FirstDescriptor,
 70 |     uint32_t              NumDescriptors)
 71 |     :
 72 |     m_ParentAllocator            {ParentAllocator},
 73 |     m_pDevice                    {pDevice},
 74 |     m_ThisManagerId              {ThisManagerId},
 75 |     m_HeapDesc                   {pd3d12DescriptorHeap->GetDesc()},
 76 |     m_DescriptorSize             {pDevice->GetDescriptorHandleIncrementSize(m_HeapDesc.Type)},
 77 |     m_NumDescriptorsInAllocation {NumDescriptors},
 78 |     m_FreeBlockManager           {NumDescriptors},
 79 |     m_pd3d12DescriptorHeap       {pd3d12DescriptorHeap}
 80 | {
 81 |     m_FirstCPUHandle = pd3d12DescriptorHeap->GetCPUDescriptorHandleForHeapStart();
 82 |     m_FirstCPUHandle.ptr += m_DescriptorSize * FirstDescriptor;
 83 | 
 84 |     if (m_HeapDesc.Flags & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE) {
 85 |         m_FirstGPUHandle = pd3d12DescriptorHeap->GetGPUDescriptorHandleForHeapStart();
 86 |         m_FirstGPUHandle.ptr += m_DescriptorSize * FirstDescriptor;
 87 |     }
 88 | }
 89 | 
 90 | 
 91 | UDX12::DescriptorHeapAllocMngr::~DescriptorHeapAllocMngr()
 92 | {
 93 |     assert(m_AllocationsCounter == 0 && " allocations have not been released. If these allocations are referenced by release queue, the app will crash when DescriptorHeapAllocationManager::FreeAllocation() is called.");
 94 |     assert("Not all descriptors were released" && m_FreeBlockManager.GetFreeSize() == m_NumDescriptorsInAllocation);
 95 | }
 96 | 
 97 | UDX12::DescriptorHeapAllocation UDX12::DescriptorHeapAllocMngr::Allocate(uint32_t Count) {
 98 |     assert(Count > 0);
 99 | 
100 |     std::lock_guard<std::mutex> LockGuard(m_FreeBlockManagerMutex);
101 |     // Methods of VariableSizeAllocationsManager class are not thread safe!
102 | 
103 |     // Use variable-size GPU allocations manager to allocate the requested number of descriptors
104 |     auto Allocation = m_FreeBlockManager.Allocate(Count, 1);
105 |     if (!Allocation.IsValid())
106 |         return {};
107 | 
108 |     assert(Allocation.size == Count);
109 | 
110 |     // Compute the first CPU and GPU descriptor handles in the allocation by
111 |     // offseting the first CPU and GPU descriptor handle in the range
112 |     auto CPUHandle = m_FirstCPUHandle;
113 |     CPUHandle.ptr += Allocation.unalignedOffset * m_DescriptorSize;
114 | 
115 |     auto GPUHandle = m_FirstGPUHandle; // Will be null if the heap is not GPU-visible
116 |     if (m_HeapDesc.Flags & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)
117 |         GPUHandle.ptr += Allocation.unalignedOffset * m_DescriptorSize;
118 | 
119 |     m_MaxAllocatedSize = std::max(m_MaxAllocatedSize, m_FreeBlockManager.GetUsedSize());
120 | 
121 | #ifndef NDEBUG
122 |     ++m_AllocationsCounter;
123 | #endif // !NDEBUG
124 | 
125 |     assert(m_ThisManagerId < std::numeric_limits<uint16_t>::max() && "ManagerID exceeds 16-bit range");
126 |     return {
127 |         &m_ParentAllocator, m_pd3d12DescriptorHeap,
128 |         CPUHandle, GPUHandle, Count,
129 |         static_cast<uint16_t>(m_ThisManagerId)
130 |     };
131 | }
132 | 
133 | void UDX12::DescriptorHeapAllocMngr::FreeAllocation(DescriptorHeapAllocation&& allocation)
134 | {
135 |     assert(allocation.GetAllocationManagerId() == m_ThisManagerId && "Invalid descriptor heap manager Id");
136 | 
137 |     if (allocation.IsNull())
138 |         return;
139 | 
140 |     std::lock_guard<std::mutex> LockGuard(m_FreeBlockManagerMutex);
141 |     auto DescriptorOffset = (allocation.GetCpuHandle().ptr - m_FirstCPUHandle.ptr) / m_DescriptorSize;
142 |     // Methods of VariableSizeAllocationsManager class are not thread safe!
143 |     m_FreeBlockManager.Free(DescriptorOffset, allocation.GetNumHandles());
144 | 
145 |     // Clear the allocation
146 |     allocation.Reset();
147 | 
148 | #ifndef NDEBUG
149 |     --m_AllocationsCounter;
150 | #endif // !NDEBUG
151 | }
152 | 


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/DescriptorHeapAllocation.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/DescriptorHeap/DescriptorHeapAllocation.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | UDX12::DescriptorHeapAllocation::DescriptorHeapAllocation() noexcept :
 6 |     m_NumHandles{ 0 }, // One null descriptor handle
 7 |     m_pDescriptorHeap{ nullptr },
 8 |     m_DescriptorSize{ 0 }
 9 | {
10 |     m_FirstCpuHandle.ptr = 0;
11 |     m_FirstGpuHandle.ptr = 0;
12 | }
13 | 
14 | UDX12::DescriptorHeapAllocation::DescriptorHeapAllocation(
15 |     IDescriptorAllocator* pAllocator,
16 |     ID3D12DescriptorHeap* pHeap,
17 |     D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle,
18 |     D3D12_GPU_DESCRIPTOR_HANDLE GpuHandle,
19 |     uint32_t                    NHandles,
20 |     uint16_t                    AllocationManagerId
21 | ) noexcept :
22 |     m_FirstCpuHandle{ CpuHandle },
23 |     m_FirstGpuHandle{ GpuHandle },
24 |     m_pAllocator{ pAllocator },
25 |     m_NumHandles{ NHandles },
26 |     m_pDescriptorHeap{ pHeap },
27 |     m_AllocationManagerId{ AllocationManagerId }
28 | {
29 |     assert(m_pAllocator != nullptr && m_pDescriptorHeap != nullptr);
30 |     auto DescriptorSize = m_pAllocator->GetDescriptorSize();
31 |     assert("DescriptorSize exceeds allowed limit" && DescriptorSize < std::numeric_limits<uint16_t>::max());
32 |     m_DescriptorSize = static_cast<uint16_t>(DescriptorSize);
33 | }
34 | 
35 | UDX12::DescriptorHeapAllocation::DescriptorHeapAllocation(DescriptorHeapAllocation&& Allocation) noexcept :
36 |     m_FirstCpuHandle{ std::move(Allocation.m_FirstCpuHandle) },
37 |     m_FirstGpuHandle{ std::move(Allocation.m_FirstGpuHandle) },
38 |     m_NumHandles{ std::move(Allocation.m_NumHandles) },
39 |     m_pAllocator{ std::move(Allocation.m_pAllocator) },
40 |     m_AllocationManagerId{ std::move(Allocation.m_AllocationManagerId) },
41 |     m_pDescriptorHeap{ std::move(Allocation.m_pDescriptorHeap) },
42 |     m_DescriptorSize{ std::move(Allocation.m_DescriptorSize) }
43 | {
44 |     Allocation.Reset();
45 | }
46 | 
47 | UDX12::DescriptorHeapAllocation::~DescriptorHeapAllocation() {
48 |     if (!IsNull() && m_pAllocator)
49 |         m_pAllocator->Free(std::move(*this));
50 |     // Allocation must have been disposed by the allocator
51 |     assert("Non-null descriptor is being destroyed" && IsNull());
52 | }
53 | 
54 | UDX12::DescriptorHeapAllocation& UDX12::DescriptorHeapAllocation::operator=(DescriptorHeapAllocation&& Allocation) noexcept {
55 |     m_FirstCpuHandle = std::move(Allocation.m_FirstCpuHandle);
56 |     m_FirstGpuHandle = std::move(Allocation.m_FirstGpuHandle);
57 |     m_NumHandles = std::move(Allocation.m_NumHandles);
58 |     m_pAllocator = std::move(Allocation.m_pAllocator);
59 |     m_AllocationManagerId = std::move(Allocation.m_AllocationManagerId);
60 |     m_pDescriptorHeap = std::move(Allocation.m_pDescriptorHeap);
61 |     m_DescriptorSize = std::move(Allocation.m_DescriptorSize);
62 | 
63 |     Allocation.Reset();
64 | 
65 |     return *this;
66 | }
67 | 
68 | void UDX12::DescriptorHeapAllocation::Reset() noexcept {
69 |     m_FirstCpuHandle.ptr = 0;
70 |     m_FirstGpuHandle.ptr = 0;
71 |     m_pAllocator = nullptr;
72 |     m_pDescriptorHeap = nullptr;
73 |     m_NumHandles = 0;
74 |     m_AllocationManagerId = static_cast<uint16_t>(-1);
75 |     m_DescriptorSize = 0;
76 | }


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/DescriptorHeapWrapper.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/DescriptorHeap/DescriptorHeapWrapper.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | HRESULT UDX12::DescriptorHeapWrapper::Create(
 6 |     ID3D12Device* pDevice,
 7 |     const D3D12_DESCRIPTOR_HEAP_DESC* desc)
 8 | {
 9 |     HRESULT hr = pDevice->CreateDescriptorHeap(desc, IID_PPV_ARGS(raw.GetAddressOf()));
10 |     if (FAILED(hr)) return hr;
11 | 
12 |     hCPUHeapStart = raw->GetCPUDescriptorHandleForHeapStart();
13 |     hGPUHeapStart = raw->GetGPUDescriptorHandleForHeapStart();
14 | 
15 |     HandleIncrementSize = pDevice->GetDescriptorHandleIncrementSize(Desc.Type);
16 |     Desc = *desc;
17 |     return hr;
18 | }
19 | 
20 | HRESULT UDX12::DescriptorHeapWrapper::Create(
21 |     ID3D12Device* pDevice,
22 |     D3D12_DESCRIPTOR_HEAP_TYPE Type,
23 |     UINT NumDescriptors,
24 |     bool bShaderVisible)
25 | {
26 |     D3D12_DESCRIPTOR_HEAP_DESC Desc;
27 |     Desc.Type = Type;
28 |     Desc.NumDescriptors = NumDescriptors;
29 |     Desc.Flags = (bShaderVisible ? D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE : D3D12_DESCRIPTOR_HEAP_FLAG_NONE);
30 |     Desc.NodeMask = 0;
31 | 
32 |     return Create(pDevice, &Desc);
33 | }
34 | 


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/DynamicSuballocMngr.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/DescriptorHeap/DynamicSuballocMngr.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | UDX12::DynamicSuballocMngr::DynamicSuballocMngr(
 6 |     GPUDescriptorHeap* ParentGPUHeap,
 7 |     uint32_t           DynamicChunkSize,
 8 |     std::string        ManagerName)
 9 |     noexcept :
10 |     m_ParentGPUHeap   { ParentGPUHeap },
11 |     m_DynamicChunkSize{ DynamicChunkSize },
12 |     m_ManagerName     { std::move(ManagerName) }
13 | {
14 |     assert(ParentGPUHeap != nullptr);
15 | }
16 | 
17 | UDX12::DynamicSuballocMngr::~DynamicSuballocMngr() {
18 |     assert(m_Suballocations.empty() && m_CurrDescriptorCount == 0 && m_CurrSuballocationsTotalSize == 0 && "All dynamic suballocations must be released!");
19 | }
20 | 
21 | void UDX12::DynamicSuballocMngr::ReleaseAllocations() {
22 |     // Clear the list and dispose all allocated chunks of GPU descriptor heap.
23 |     // The chunks will be added to release queues and eventually returned to the
24 |     // parent GPU heap.
25 |     for (auto& Allocation : m_Suballocations)
26 |         m_ParentGPUHeap->Free(std::move(Allocation));
27 |     m_Suballocations.clear();
28 |     m_CurrDescriptorCount = 0;
29 |     m_CurrSuballocationsTotalSize = 0;
30 | }
31 | 
32 | UDX12::DescriptorHeapAllocation UDX12::DynamicSuballocMngr::Allocate(uint32_t Count) {
33 |     // This method is intentionally lock-free as it is expected to
34 |     // be called through device context from single thread only
35 | 
36 |     // Check if there are no chunks or the last chunk does not have enough space
37 |     if (m_Suballocations.empty() ||
38 |         m_CurrentSuballocationOffset + Count > m_Suballocations.back().GetNumHandles())
39 |     {
40 |         // Request a new chunk from the parent GPU descriptor heap
41 |         auto suballocationSize = std::max(m_DynamicChunkSize, Count);
42 |         auto NewDynamicSubAllocation = m_ParentGPUHeap->AllocateDynamic(suballocationSize);
43 |         if (NewDynamicSubAllocation.IsNull())
44 |             return {};
45 |         m_Suballocations.emplace_back(std::move(NewDynamicSubAllocation));
46 |         m_CurrentSuballocationOffset = 0;
47 | 
48 |         m_CurrSuballocationsTotalSize += suballocationSize;
49 |         m_PeakSuballocationsTotalSize = std::max(m_PeakSuballocationsTotalSize, m_CurrSuballocationsTotalSize);
50 |     }
51 | 
52 |     // Perform suballocation from the last chunk
53 |     auto& currentSuballocation = m_Suballocations.back();
54 | 
55 |     auto managerId = currentSuballocation.GetAllocationManagerId();
56 |     assert(managerId < std::numeric_limits<uint16_t>::max() && "ManagerID exceed allowed limit");
57 |     DescriptorHeapAllocation allocation(
58 |         this,
59 |         currentSuballocation.GetDescriptorHeap(),
60 |         currentSuballocation.GetCpuHandle(m_CurrentSuballocationOffset),
61 |         currentSuballocation.GetGpuHandle(m_CurrentSuballocationOffset),
62 |         Count,
63 |         static_cast<uint16_t>(managerId)
64 |     );
65 |     m_CurrentSuballocationOffset += Count;
66 |     m_CurrDescriptorCount += Count;
67 |     m_PeakDescriptorCount = std::max(m_PeakDescriptorCount, m_CurrDescriptorCount);
68 | 
69 |     return allocation;
70 | }


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/GPUDescriptorHeap.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/DescriptorHeap/GPUDescriptorHeap.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | UDX12::GPUDescriptorHeap::GPUDescriptorHeap(
 6 |     ID3D12Device*               device,
 7 |     uint32_t                    NumDescriptorsInHeap,
 8 |     uint32_t                    NumDynamicDescriptors,
 9 |     D3D12_DESCRIPTOR_HEAP_TYPE  Type,
10 |     D3D12_DESCRIPTOR_HEAP_FLAGS Flags)
11 |     :
12 |     m_Device{device},
13 |     m_HeapDesc
14 |     {
15 |         Type,
16 |         NumDescriptorsInHeap + NumDynamicDescriptors,
17 |         Flags,
18 |         1 // UINT NodeMask;
19 |     },
20 |     m_pd3d12DescriptorHeap
21 |     {
22 |         [&]
23 |         {
24 |               CComPtr<ID3D12DescriptorHeap> pHeap;
25 |               device->CreateDescriptorHeap(&m_HeapDesc, __uuidof(pHeap), reinterpret_cast<void**>(&pHeap));
26 |               return pHeap;
27 |         }()
28 |     },
29 |     m_DescriptorSize           {device->GetDescriptorHandleIncrementSize(Type)},
30 |     m_HeapAllocationManager    {device, *this, StaticHeapAllocatonManagerID, m_pd3d12DescriptorHeap, 0, NumDescriptorsInHeap},
31 |     m_DynamicAllocationsManager{device, *this, DynamicHeapAllocatonManagerID, m_pd3d12DescriptorHeap, NumDescriptorsInHeap, NumDynamicDescriptors}
32 | {
33 | }
34 | 
35 | void UDX12::GPUDescriptorHeap::Free(DescriptorHeapAllocation&& allocation) {
36 |     auto MgrId = allocation.GetAllocationManagerId();
37 |     assert((MgrId == StaticHeapAllocatonManagerID || MgrId == DynamicHeapAllocatonManagerID)
38 |         && "Unexpected allocation manager ID");
39 | 
40 |     if (MgrId == StaticHeapAllocatonManagerID)
41 |         m_HeapAllocationManager.FreeAllocation(std::move(allocation));
42 |     else // MgrId == DynamicHeapAllocatonManagerID
43 |         m_DynamicAllocationsManager.FreeAllocation(std::move(allocation));
44 | }
45 | 


--------------------------------------------------------------------------------
/src/core/DescriptorHeap/IDescriptorAllocator.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ubpa/UDX12/81b381e50e8dbc1b41fc30e074058e2bef707559/src/core/DescriptorHeap/IDescriptorAllocator.cpp


--------------------------------------------------------------------------------
/src/core/DescriptorHeapMngr.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/DescriptorHeapMngr.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | void UDX12::DescriptorHeapMngr::Init(
 6 | 	ID3D12Device* device,
 7 | 	uint32_t numCpuCSU,
 8 | 	uint32_t numCpuRTV,
 9 | 	uint32_t numCpuDSV,
10 | 	uint32_t numGpuCSU_static,
11 | 	uint32_t numGpuCSU_dynamic
12 | ) {
13 | 	assert(!isInit);
14 | 
15 | 	CSU_CpuDH = new CPUDescriptorHeap{
16 | 		device,
17 | 		numCpuCSU,
18 | 		D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
19 | 		D3D12_DESCRIPTOR_HEAP_FLAG_NONE };
20 | 
21 | 	RTV_CpuDH = new CPUDescriptorHeap{
22 | 		device,
23 | 		numCpuRTV,
24 | 		D3D12_DESCRIPTOR_HEAP_TYPE_RTV,
25 | 		D3D12_DESCRIPTOR_HEAP_FLAG_NONE };
26 | 
27 | 	DSV_CpuDH = new CPUDescriptorHeap{
28 | 		device,
29 | 		numCpuDSV,
30 | 		D3D12_DESCRIPTOR_HEAP_TYPE_DSV,
31 | 		D3D12_DESCRIPTOR_HEAP_FLAG_NONE };
32 | 
33 | 	CSU_GpuDH = new GPUDescriptorHeap{
34 | 		device,
35 | 		numGpuCSU_static,
36 | 		numGpuCSU_dynamic,
37 | 		D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
38 | 		D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE };
39 | 
40 | 	isInit = true;
41 | }
42 | 
43 | void UDX12::DescriptorHeapMngr::Clear() {
44 | 	isInit = false;
45 | 
46 | 	delete CSU_CpuDH;
47 | 	delete RTV_CpuDH;
48 | 	delete DSV_CpuDH;
49 | 	delete CSU_GpuDH;
50 | 
51 | 	CSU_CpuDH = nullptr;
52 | 	RTV_CpuDH = nullptr;
53 | 	DSV_CpuDH = nullptr;
54 | 	CSU_GpuDH = nullptr;
55 | }
56 | 
57 | UDX12::DescriptorHeapMngr::~DescriptorHeapMngr() {
58 | 	Clear();
59 | }
60 | 


--------------------------------------------------------------------------------
/src/core/Device.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/Device.h>
 2 | 
 3 | #include <UDX12/Desc.h>
 4 | 
 5 | using namespace Ubpa;
 6 | using namespace Ubpa::UDX12;
 7 | 
 8 | void Device::CreateCommittedResource(
 9 |     D3D12_HEAP_TYPE heap_type,
10 |     SIZE_T size,
11 |     ID3D12Resource** resources)
12 | {
13 |     const auto defaultHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
14 |     const auto bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(size);
15 |     ThrowIfFailed(raw->CreateCommittedResource(
16 |         &defaultHeapProperties,
17 |         D3D12_HEAP_FLAG_NONE,
18 |         &bufferDesc,
19 |         D3D12_RESOURCE_STATE_COMMON,
20 |         nullptr,
21 |         IID_PPV_ARGS(resources)));
22 | }
23 | 
24 | void Device::CreateDescriptorHeap(UINT size, D3D12_DESCRIPTOR_HEAP_TYPE type, ID3D12DescriptorHeap** pHeap) {
25 |     D3D12_DESCRIPTOR_HEAP_DESC cbvHeapDesc;
26 |     cbvHeapDesc.NumDescriptors = size;
27 |     cbvHeapDesc.Type = type;
28 |     cbvHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
29 |     cbvHeapDesc.NodeMask = 0;
30 |     ThrowIfFailed(raw->CreateDescriptorHeap(&cbvHeapDesc,
31 |         IID_PPV_ARGS(pHeap)));
32 | }
33 | 
34 | ComPtr<ID3D12RootSignature> Device::CreateRootSignature(const D3D12_ROOT_SIGNATURE_DESC& desc) {
35 |     Microsoft::WRL::ComPtr<ID3DBlob> pSigBlob;
36 |     Microsoft::WRL::ComPtr<ID3DBlob> pErrorBlob;
37 |     HRESULT hr = D3D12SerializeRootSignature(&desc, D3D_ROOT_SIGNATURE_VERSION_1, &pSigBlob, &pErrorBlob);
38 |     if (FAILED(hr)) {
39 |         OutputDebugStringA((char*)pErrorBlob->GetBufferPointer());
40 |         return nullptr;
41 |     }
42 |     Microsoft::WRL::ComPtr<ID3D12RootSignature> pRootSig;
43 |     ThrowIfFailed(raw->CreateRootSignature(0, pSigBlob->GetBufferPointer(), pSigBlob->GetBufferSize(), IID_PPV_ARGS(&pRootSig)));
44 |     return pRootSig;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/core/FrameGraph/Executor.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/FrameGraph/Executor.h>
  2 | 
  3 | #include <UDX12/FrameGraph/RsrcMngr.h>
  4 | 
  5 | using namespace Ubpa::UDX12::FG;
  6 | using namespace Ubpa::UDX12;
  7 | using namespace Ubpa;
  8 | 
  9 | Executor::Executor(ID3D12Device* device, size_t num_threads) :
 10 | 	device{ device }, threadpool{ num_threads } {}
 11 | 
 12 | Executor& Executor::RegisterPassFunc(size_t passNodeIdx, PassFunction func) {
 13 | 	passFuncs[passNodeIdx] = std::move(func);
 14 | 	return *this;
 15 | }
 16 | 
 17 | void Executor::NewFrame() {
 18 | 	for (auto allocator : used_allocators) {
 19 | 		allocator->Reset();
 20 | 		free_allocators.push_back(allocator);
 21 | 	}
 22 | 	used_allocators.clear();
 23 | }
 24 | 
 25 | Executor& Executor::RegisterCopyPassFunc(size_t passNodeIdx,
 26 | 	std::span<const size_t> srcRsrcNodeIndices,
 27 | 	std::span<const size_t> dstRsrcNodeIndices) {
 28 | 	
 29 | 	std::vector<std::pair<size_t, size_t>> pairs;
 30 | 	for (size_t i = 0; i < srcRsrcNodeIndices.size(); i++)
 31 | 		pairs.emplace_back(srcRsrcNodeIndices[i], dstRsrcNodeIndices[i]);
 32 | 
 33 | 	passFuncs[passNodeIdx] = [pairs = std::move(pairs)](ID3D12GraphicsCommandList* cmdList, const PassRsrcs& rsrcs) {
 34 | 		for (const auto& [in_id, out_id] : pairs) {
 35 | 			auto in_rsrc = rsrcs.at(in_id).resource;
 36 | 			auto out_rsrc = rsrcs.at(out_id).resource;
 37 | 			assert(in_rsrc && out_rsrc);
 38 | 			cmdList->CopyResource(out_rsrc, in_rsrc);
 39 | 		}
 40 | 	};
 41 | 	return *this;
 42 | }
 43 | 
 44 | Executor& Executor::RegisterCopyPassFunc(const UFG::FrameGraph& fg, size_t passNodeIdx) {
 45 | 	const auto inputs = fg.GetPassNodes()[passNodeIdx].Inputs();
 46 | 	const auto outputs = fg.GetPassNodes()[passNodeIdx].Outputs();
 47 | 
 48 | 	return RegisterCopyPassFunc(passNodeIdx, inputs, outputs);
 49 | }
 50 | 
 51 | void Executor::Execute(
 52 | 	ID3D12CommandQueue* cmdQueue,
 53 | 	const UFG::Compiler::Result& crst,
 54 | 	RsrcMngr& rsrcMngr
 55 | ) {
 56 | 	rsrcMngr.DHReserve();
 57 | 	rsrcMngr.AllocateHandle();
 58 | 
 59 | 	const size_t cmdlist_num = crst.sorted_passes.size();
 60 | 	if (cmdlist_num == 0)
 61 | 		return;
 62 | 	
 63 | 	// index by order (not pass index)
 64 | 	std::vector<ID3D12GraphicsCommandList*> cmdlists(cmdlist_num, nullptr);
 65 | 	std::mutex mutex_cnt;
 66 | 	size_t cnt = 0;
 67 | 	std::condition_variable cv_cnt;
 68 | 
 69 | 	std::mutex mutex_rsrcMngr;
 70 | 
 71 | 	for (size_t i = 0; i < cmdlist_num; ++i) {
 72 | 		if (free_allocators.empty()) {
 73 | 			Microsoft::WRL::ComPtr<ID3D12CommandAllocator> allocator;
 74 | 			ThrowIfFailed(device->CreateCommandAllocator(
 75 | 				D3D12_COMMAND_LIST_TYPE_DIRECT,
 76 | 				IID_PPV_ARGS(&allocator)));
 77 | 			free_allocators.push_back(std::move(allocator));
 78 | 		}
 79 | 
 80 | 		Microsoft::WRL::ComPtr<ID3D12CommandAllocator> allocator = free_allocators.back();
 81 | 		free_allocators.pop_back();
 82 | 		used_allocators.push_back(allocator);
 83 | 
 84 | 		ThrowIfFailed(device->CreateCommandList(
 85 | 			0,
 86 | 			D3D12_COMMAND_LIST_TYPE_DIRECT,
 87 | 			allocator.Get(),           // Associated command allocator
 88 | 			nullptr,                   // Initial PipelineStateObject
 89 | 			IID_PPV_ARGS(&cmdlists[i])));
 90 | 	}
 91 | 
 92 | 	if (auto target = crst.pass2info.find(static_cast<size_t>(-1)); target != crst.pass2info.end()) {
 93 | 		const auto& info = target->second;
 94 | 
 95 | 		for (auto rsrc : info.construct_resources)
 96 | 			rsrcMngr.Construct(rsrc);
 97 | 
 98 | 		for (auto rsrc : info.move_resources) {
 99 | 			auto src = rsrc;
100 | 			auto dst = crst.moves_src2dst.at(src);
101 | 			rsrcMngr.Move(dst, src);
102 | 		}
103 | 
104 | 		for (auto rsrc : info.destruct_resources){
105 | 			rsrcMngr.DestructCPU(rsrc);
106 | 			rsrcMngr.DestructGPU(cmdlists.front(), rsrc);
107 | 		}
108 | 	}
109 | 
110 | 	{
111 | 		// let worker threads wait for the main thread
112 | 		std::lock_guard<std::mutex> guard(mutex_rsrcMngr);
113 | 		for (auto pass : crst.sorted_passes) {
114 | 			const auto& passInfo = crst.pass2info.at(pass);
115 | 			for (auto rsrc : passInfo.construct_resources)
116 | 				rsrcMngr.Construct(rsrc);
117 | 			auto cmdlist = cmdlists[crst.pass2order[pass]];// cmdlists[pass]
118 | 			auto passRsrcs = rsrcMngr.RequestPassRsrcs(cmdlist, pass);
119 | 
120 | 			for (auto rsrc : passInfo.move_resources) {
121 | 				auto src = rsrc;
122 | 				auto dst = crst.moves_src2dst.at(src);
123 | 				rsrcMngr.Move(dst, src);
124 | 			}
125 | 
126 | 			for (auto rsrc : passInfo.destruct_resources)
127 | 				rsrcMngr.DestructCPU(rsrc);
128 | 
129 | 			PassFunction passfunc;
130 | 			if (auto target = passFuncs.find(pass); target != passFuncs.end())
131 | 				passfunc = std::move(target->second);
132 | 
133 | 			threadpool.BasicEnqueue(
134 | 				[
135 | 					rsrcs = std::move(passRsrcs), func = std::move(passfunc), cmdlist, pass, cmdlist_num,
136 | 					&crst, &mutex_cnt, &cnt, &cv_cnt, &rsrcMngr, &mutex_rsrcMngr
137 | 				]
138 | 				() {
139 | 					if(func)
140 | 						func(cmdlist, rsrcs);
141 | 
142 | 					const auto& passinfo = crst.pass2info.at(pass);
143 | 					if (!passinfo.destruct_resources.empty()) {
144 | 						// 1. wait main thread
145 | 						// 2. avoid data race with other worker threads
146 | 						std::lock_guard<std::mutex> guard(mutex_rsrcMngr);
147 | 						for (auto rsrc : passinfo.destruct_resources)
148 | 							rsrcMngr.DestructGPU(cmdlist, rsrc);
149 | 					}
150 | 
151 | 					cmdlist->Close();
152 | 
153 | 					{ // add cnt
154 | 						std::lock_guard<std::mutex> lk(mutex_cnt);
155 | 						++cnt;
156 | 						if (cnt == cmdlist_num)
157 | 							cv_cnt.notify_one();
158 | 					}
159 | 				}
160 | 			);
161 | 		}
162 | 	}
163 | 	
164 | 
165 | 	{
166 | 		std::unique_lock<std::mutex> lk(mutex_cnt);
167 | 		if (cnt != cmdlist_num) {
168 | 			cv_cnt.wait(lk);
169 | 			assert(cnt == cmdlist_num);
170 | 		}
171 | 	}
172 | 	cmdQueue->ExecuteCommandLists((UINT)cmdlists.size(), (ID3D12CommandList* const*)cmdlists.data());
173 | 	for (auto* cmdlist : cmdlists)
174 | 		cmdlist->Release();
175 | }
176 | 


--------------------------------------------------------------------------------
/src/core/FrameResource.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/FrameResource.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | void UDX12::FrameResource::Signal(ID3D12CommandQueue* cmdQueue, UINT64 cpuFence) {
 6 | 	this->cpuFence = cpuFence;
 7 | 	cmdQueue->Signal(gpuFence, cpuFence);
 8 | }
 9 | 
10 | void UDX12::FrameResource::BeginFrame(HANDLE sharedEventHandle) {
11 | 	if (gpuFence->GetCompletedValue() < cpuFence) {
12 | 		ThrowIfFailed(gpuFence->SetEventOnCompletion(cpuFence, sharedEventHandle));
13 | 		WaitForSingleObject(sharedEventHandle, INFINITE);
14 |     }
15 | 
16 |     for (const auto& name : delayUnregisterResources)
17 |         UnregisterResource(name);
18 |     delayUnregisterResources.clear();
19 | 
20 |     for (const auto& [name, updator] : delayUpdatorMap)
21 |         updator(resourceMap.at(name));
22 |     delayUpdatorMap.clear();
23 | }
24 | 
25 | UDX12::FrameResource& UDX12::FrameResource::UnregisterResource(std::string_view name) {
26 |     assert(HaveResource(name));
27 | 
28 |     resourceMap.erase(resourceMap.find(name));
29 | 
30 |     return *this;
31 | }
32 | 
33 | UDX12::FrameResource& UDX12::FrameResource::DelayUnregisterResource(std::string name) {
34 |     assert(HaveResource(name));
35 |     delayUnregisterResources.emplace_back(std::move(name));
36 |     return *this;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/core/FrameResourceMngr.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/FrameResourceMngr.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | UDX12::FrameResourceMngr::FrameResourceMngr(size_t numFrame, ID3D12Device* device) {
 6 | 	assert(numFrame > 0 && device);
 7 | 	ThrowIfFailed(device->CreateFence(cpuFence, D3D12_FENCE_FLAG_NONE,
 8 | 		IID_PPV_ARGS(&gpuFence)));
 9 | 	for (size_t i = 0; i < numFrame; i++)
10 | 		frameResources.push_back(std::make_unique<FrameResource>(cpuFence, gpuFence.Get()));
11 | 	eventHandle = CreateEventEx(nullptr, nullptr, false, EVENT_ALL_ACCESS);
12 | }
13 | 
14 | UDX12::FrameResourceMngr::~FrameResourceMngr() {
15 | 	CloseHandle(eventHandle);
16 | }
17 | 
18 | UDX12::FrameResource* UDX12::FrameResourceMngr::GetCurrentFrameResource() noexcept {
19 | 	return frameResources[cpuFence % frameResources.size()].get();
20 | }
21 | 
22 | void UDX12::FrameResourceMngr::BeginFrame() {
23 | 	GetCurrentFrameResource()->BeginFrame(eventHandle);
24 | }
25 | 
26 | void UDX12::FrameResourceMngr::EndFrame(ID3D12CommandQueue* cmdQueue) {
27 | 	GetCurrentFrameResource()->Signal(cmdQueue, ++cpuFence);
28 | }
29 | 


--------------------------------------------------------------------------------
/src/core/GCmdList.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/GCmdList.h>
 2 | 
 3 | #include <UDX12/_deps/DirectXTK12/DirectXHelpers.h>
 4 | 
 5 | using namespace Ubpa;
 6 | 
 7 | void UDX12::GCmdList::Reset(ID3D12CommandAllocator* pAllocator) {
 8 |     ThrowIfFailed(raw->Reset(pAllocator, nullptr));
 9 | }
10 | 
11 | void UDX12::GCmdList::ResourceBarrierTransition(ID3D12Resource* resource, D3D12_RESOURCE_STATES from, D3D12_RESOURCE_STATES to) {
12 |     DirectX::TransitionResource(raw.Get(), resource, from, to);
13 | }
14 | 
15 | void UDX12::GCmdList::RSSetViewport(D3D12_VIEWPORT viewport) {
16 |     raw->RSSetViewports(1, &viewport);
17 | }
18 | 
19 | void UDX12::GCmdList::RSSetScissorRect(D3D12_RECT rect) {
20 |     raw->RSSetScissorRects(1, &rect);
21 | }
22 | 
23 | void UDX12::GCmdList::ClearRenderTargetView(D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, const FLOAT color[4]) {
24 |     raw->ClearRenderTargetView(RenderTargetView, color, 0, nullptr);
25 | }
26 | 
27 | void UDX12::GCmdList::ClearDepthStencilView(D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView) {
28 |     raw->ClearDepthStencilView(DepthStencilView, D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.f, 0, 0, nullptr);
29 | }
30 | 
31 | void UDX12::GCmdList::OMSetRenderTarget(
32 |     D3D12_CPU_DESCRIPTOR_HANDLE rendertarget,
33 |     D3D12_CPU_DESCRIPTOR_HANDLE depthstencil)
34 | {
35 |     raw->OMSetRenderTargets(1, &rendertarget, true, &depthstencil);
36 | }
37 | 
38 | void UDX12::GCmdList::DrawIndexed(
39 |     UINT IndexCount,
40 |     UINT StartIndexLocation,
41 |     INT BaseVertexLocation)
42 | {
43 |     raw->DrawIndexedInstanced(IndexCount, 1, StartIndexLocation, BaseVertexLocation, 0);
44 | }
45 | 


--------------------------------------------------------------------------------
/src/core/MeshGPUBuffer.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/MeshGPUBuffer.h>
  2 | 
  3 | #include <UDX12/_deps/DirectXTK12/BufferHelpers.h>
  4 | 
  5 | using namespace Ubpa;
  6 | 
  7 | UDX12::MeshGPUBuffer::MeshGPUBuffer(
  8 | 	ID3D12Device* device, DirectX::ResourceUploadBatch& resourceUpload,
  9 | 	const void* vb_data, UINT vb_count, UINT vb_stride,
 10 | 	const void* ib_data, UINT ib_count, DXGI_FORMAT ib_format) :
 11 | 	isStatic{ true }
 12 | {
 13 | 	assert(ib_format == DXGI_FORMAT_R16_UINT || ib_format == DXGI_FORMAT_R32_UINT);
 14 | 
 15 | 	UINT ib_stride = ib_format == DXGI_FORMAT_R16_UINT ? 2 : 4;
 16 | 
 17 | 	UINT vb_size = vb_count * vb_stride;
 18 | 	UINT ib_size = ib_count * ib_stride;
 19 | 
 20 | 	DirectX::CreateStaticBuffer(device, resourceUpload, vb_data, vb_count, vb_stride, D3D12_RESOURCE_STATE_GENERIC_READ,
 21 | 		staticVertexBuffer.GetAddressOf());
 22 | 
 23 | 	DirectX::CreateStaticBuffer(device, resourceUpload, ib_data, ib_count, ib_stride, D3D12_RESOURCE_STATE_GENERIC_READ,
 24 | 		staticIndexBuffer.GetAddressOf());
 25 | 
 26 | 	vertexByteStride = vb_stride;
 27 | 	vertexBufferByteSize = vb_size;
 28 | 	indexFormat = ib_format;
 29 | 	indexBufferByteSize = ib_size;
 30 | }
 31 | 
 32 | UDX12::MeshGPUBuffer::MeshGPUBuffer(
 33 | 	ID3D12Device* device, ID3D12GraphicsCommandList* cmdList,
 34 | 	const void* vb_data, UINT vb_count, UINT vb_stride,
 35 | 	const void* ib_data, UINT ib_count, DXGI_FORMAT ib_format) :
 36 | 	isStatic{ false }
 37 | {
 38 | 	vertexUploadBuffer = std::make_unique<DynamicUploadBuffer>(device, 0);
 39 | 	indexUploadBuffer = std::make_unique<DynamicUploadBuffer>(device, 0);
 40 | 	Update(
 41 | 		device, cmdList,
 42 | 		vb_data, vb_count, vb_stride,
 43 | 		ib_data, ib_count, ib_format
 44 | 	);
 45 | }
 46 | 
 47 | void UDX12::MeshGPUBuffer::Update(
 48 | 	ID3D12Device* device, ID3D12GraphicsCommandList* cmdList,
 49 | 	const void* vb_data, UINT vb_count, UINT vb_stride,
 50 | 	const void* ib_data, UINT ib_count, DXGI_FORMAT ib_format
 51 | ) {
 52 | 	assert(!IsStatic());
 53 | 
 54 | 	// 1. update upload heap buffer
 55 | 	assert(ib_format == DXGI_FORMAT_R16_UINT || ib_format == DXGI_FORMAT_R32_UINT);
 56 | 
 57 | 	UINT ib_stride = ib_format == DXGI_FORMAT_R16_UINT ? 2 : 4;
 58 | 
 59 | 	UINT vb_size = vb_count * vb_stride;
 60 | 	UINT ib_size = ib_count * ib_stride;
 61 | 
 62 | 	vertexUploadBuffer->FastReserve(vb_size);
 63 | 	indexUploadBuffer->FastReserve(ib_size);
 64 | 
 65 | 	vertexUploadBuffer->Set(0, vb_data, vb_size);
 66 | 	indexUploadBuffer->Set(0, ib_data, ib_size);
 67 | 
 68 | 	vertexByteStride = vb_stride;
 69 | 	vertexBufferByteSize = vb_size;
 70 | 	indexFormat = ib_format;
 71 | 	indexBufferByteSize = ib_size;
 72 | 
 73 | 	// 2. copy upload heap buffer data to default heap buffer
 74 | 	if (staticVertexBuffer && staticVertexBuffer->GetDesc().Width >= vb_size)
 75 | 		vertexUploadBuffer->CopyAssign(0, 0, vb_size, cmdList, staticVertexBuffer.Get());
 76 | 	else
 77 | 		vertexUploadBuffer->CopyConstruct(0, 0, vb_size, device, cmdList, D3D12_RESOURCE_STATE_GENERIC_READ, &staticVertexBuffer);
 78 | 
 79 | 	if (staticIndexBuffer && staticIndexBuffer->GetDesc().Width >= ib_size)
 80 | 		indexUploadBuffer->CopyAssign(0, 0, ib_size, cmdList, staticIndexBuffer.Get());
 81 | 	else
 82 | 		indexUploadBuffer->CopyConstruct(0, 0, ib_size, device, cmdList, D3D12_RESOURCE_STATE_GENERIC_READ, &staticIndexBuffer);
 83 | }
 84 | 
 85 | void UDX12::MeshGPUBuffer::ConvertToStatic(ResourceDeleteBatch& deleteBatch) {
 86 | 	assert(!IsStatic());
 87 | 	vertexUploadBuffer->Delete(deleteBatch);
 88 | 	indexUploadBuffer->Delete(deleteBatch);
 89 | 	vertexUploadBuffer.reset();
 90 | 	indexUploadBuffer.reset();
 91 | 	isStatic = true;
 92 | }
 93 | 
 94 | void UDX12::MeshGPUBuffer::ConvertToDynamic(ID3D12Device* device) {
 95 | 	assert(IsStatic());
 96 | 	isStatic = false;
 97 | 	vertexUploadBuffer = std::make_unique<DynamicUploadBuffer>(device, 0);
 98 | 	indexUploadBuffer = std::make_unique<DynamicUploadBuffer>(device, 0);
 99 | }
100 | 
101 | void UDX12::MeshGPUBuffer::Delete(ResourceDeleteBatch& deleteBatch) {
102 | 	if (!IsStatic()) {
103 | 		vertexUploadBuffer->Delete(deleteBatch);
104 | 		indexUploadBuffer->Delete(deleteBatch);
105 | 		vertexUploadBuffer.reset();
106 | 		indexUploadBuffer.reset();
107 | 	}
108 | 
109 | 	deleteBatch.Add(std::move(staticVertexBuffer));
110 | 	deleteBatch.Add(std::move(staticIndexBuffer));
111 | }
112 | 
113 | D3D12_VERTEX_BUFFER_VIEW UDX12::MeshGPUBuffer::VertexBufferView() const {
114 | 	D3D12_VERTEX_BUFFER_VIEW vbv;
115 | 	vbv.BufferLocation = staticVertexBuffer->GetGPUVirtualAddress();
116 | 	vbv.StrideInBytes = vertexByteStride;
117 | 	vbv.SizeInBytes = vertexBufferByteSize;
118 | 
119 | 	return vbv;
120 | }
121 | 
122 | D3D12_INDEX_BUFFER_VIEW UDX12::MeshGPUBuffer::IndexBufferView() const {
123 | 	D3D12_INDEX_BUFFER_VIEW ibv;
124 | 	ibv.BufferLocation = staticIndexBuffer->GetGPUVirtualAddress();
125 | 	ibv.Format = indexFormat;
126 | 	ibv.SizeInBytes = indexBufferByteSize;
127 | 
128 | 	return ibv;
129 | }
130 | 


--------------------------------------------------------------------------------
/src/core/ResourceDeleteBatch.cpp:
--------------------------------------------------------------------------------
 1 | #include <UDX12/ResourceDeleteBatch.h>
 2 | 
 3 | using namespace Ubpa;
 4 | 
 5 | UDX12::ResourceDeleteBatch::~ResourceDeleteBatch() { Release(); }
 6 | 
 7 | void UDX12::ResourceDeleteBatch::Add(Microsoft::WRL::ComPtr<ID3D12Resource> resource) { resources.push_back(std::move(resource)); }
 8 | 
 9 | void UDX12::ResourceDeleteBatch::AddCallback(unique_function<void()> callback) { callbacks.push_back(std::move(callback)); }
10 | 
11 | void UDX12::ResourceDeleteBatch::Release() {
12 | 	resources.clear();
13 | 	for (auto& callback : callbacks)
14 | 		callback();
15 | 	callbacks.clear();
16 | }
17 | 


--------------------------------------------------------------------------------
/src/core/UploadBuffer.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/UploadBuffer.h>
  2 | 
  3 | #include <DirectXHelpers.h>
  4 | 
  5 | using namespace Ubpa;
  6 | 
  7 | UDX12::UploadBuffer::UploadBuffer(ID3D12Device* device, UINT64 size, D3D12_RESOURCE_FLAGS flag)
  8 |     : size{ size }
  9 | {
 10 |     assert(size > 0);
 11 | 
 12 | 	const auto uploadHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD);
 13 | 	const auto bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(size, flag);
 14 |     ThrowIfFailed(device->CreateCommittedResource(
 15 |         &uploadHeapProperties,
 16 |         D3D12_HEAP_FLAG_NONE,
 17 |         &bufferDesc,
 18 |         D3D12_RESOURCE_STATE_GENERIC_READ,
 19 |         nullptr,
 20 |         IID_PPV_ARGS(&resource)));
 21 | 
 22 |     ThrowIfFailed(resource->Map(0, nullptr, reinterpret_cast<void**>(&mappedData)));
 23 | }
 24 | 
 25 | UDX12::UploadBuffer::~UploadBuffer() {
 26 |     if(resource)
 27 |         resource->Unmap(0, nullptr);
 28 | }
 29 | 
 30 | void UDX12::UploadBuffer::Set(UINT64 offset, const void* data, UINT64 size) {
 31 |     assert(size > 0 && data);
 32 |     assert(offset + size <= Size());
 33 |     memcpy((std::uint8_t*)mappedData + offset, data, size);
 34 | }
 35 | 
 36 | void UDX12::UploadBuffer::CopyConstruct(
 37 | 	size_t dstOffset, size_t srcOffset, size_t numBytes,
 38 | 	ID3D12Device* device,
 39 | 	ID3D12GraphicsCommandList* cmdList,
 40 | 	D3D12_RESOURCE_STATES afterState,
 41 | 	ID3D12Resource** pBuffer, // out com ptr
 42 | 	D3D12_RESOURCE_FLAGS resFlags
 43 | ) {
 44 | 	assert(resource);
 45 | 	auto desc = CD3DX12_RESOURCE_DESC::Buffer(numBytes, resFlags);
 46 | 
 47 | 	CD3DX12_HEAP_PROPERTIES defaultHeapProperties(D3D12_HEAP_TYPE_DEFAULT);
 48 | 
 49 | 	ComPtr<ID3D12Resource> res;
 50 | 	ThrowIfFailed(device->CreateCommittedResource(
 51 | 		&defaultHeapProperties,
 52 | 		D3D12_HEAP_FLAG_NONE,
 53 | 		&desc,
 54 | 		D3D12_RESOURCE_STATE_COPY_DEST,
 55 | 		nullptr,
 56 | 		IID_GRAPHICS_PPV_ARGS(res.GetAddressOf())));
 57 | 
 58 | 	CopyAssign(
 59 | 		dstOffset, srcOffset, numBytes,
 60 | 		cmdList, res.Get(), D3D12_RESOURCE_STATE_COPY_DEST
 61 | 	);
 62 | 	DirectX::TransitionResource(cmdList, res.Get(), D3D12_RESOURCE_STATE_COPY_DEST, afterState);
 63 | 
 64 | 	*pBuffer = res.Detach();
 65 | }
 66 | 
 67 | void UDX12::UploadBuffer::CopyAssign(
 68 | 	size_t dstOffset, size_t srcOffset, size_t numBytes,
 69 | 	ID3D12GraphicsCommandList* cmdList,
 70 |     ID3D12Resource* dst,
 71 |     D3D12_RESOURCE_STATES state
 72 | ) {
 73 |     assert(resource);
 74 | 	assert(dst->GetDesc().Dimension == D3D12_RESOURCE_DIMENSION_BUFFER);
 75 | 	assert(dstOffset + numBytes <= dst->GetDesc().Width);
 76 | 
 77 | 	DirectX::TransitionResource(cmdList, dst, state, D3D12_RESOURCE_STATE_COPY_DEST);
 78 | 	cmdList->CopyBufferRegion(dst, dstOffset, resource.Get(), srcOffset, size);
 79 | 	DirectX::TransitionResource(cmdList, dst, D3D12_RESOURCE_STATE_COPY_DEST, state);
 80 | }
 81 | 
 82 | void UDX12::UploadBuffer::Delete(ResourceDeleteBatch& deleteBatch) {
 83 | 	assert(resource);
 84 | 	resource->Unmap(0, nullptr);
 85 | 
 86 | 	deleteBatch.Add(std::move(resource));
 87 | 
 88 | 	mappedData = nullptr;
 89 | 	size = 0;
 90 | }
 91 | 
 92 | // ==================================================
 93 | 
 94 | UDX12::DynamicUploadBuffer::DynamicUploadBuffer(ID3D12Device* device, UINT64 size, D3D12_RESOURCE_FLAGS flag)
 95 | 	: device{ device }, flag{ flag }
 96 | {
 97 | 	if(size > 0)
 98 | 		buffer = std::make_unique<UDX12::UploadBuffer>(device, size, flag);
 99 | }
100 | 
101 | ID3D12Resource* UDX12::DynamicUploadBuffer::GetResource() const noexcept {
102 |     return buffer ? buffer->GetResource() : nullptr;
103 | }
104 | 
105 | void* UDX12::DynamicUploadBuffer::GetMappedData() const noexcept {
106 | 	return buffer ? buffer->GetMappedData() : nullptr;
107 | }
108 | 
109 | UINT64 UDX12::DynamicUploadBuffer::Size() const noexcept {
110 |     return buffer ? buffer->Size() : 0;
111 | }
112 | 
113 | void UDX12::DynamicUploadBuffer::Reserve(size_t size) {
114 | 	if (size <= Size())
115 | 		return;
116 | 
117 | 	auto newBuffer = std::make_unique<UDX12::UploadBuffer>(device, size, flag);
118 |     if(buffer)
119 |         newBuffer->Set(0, buffer->GetMappedData(), buffer->Size());
120 | 
121 |     buffer = std::move(newBuffer);
122 | }
123 | 
124 | void UDX12::DynamicUploadBuffer::Resize(size_t size) {
125 | 	auto newBuffer = std::make_unique<UDX12::UploadBuffer>(device, size, flag);
126 | 	if (buffer)
127 | 		newBuffer->Set(0, buffer->GetMappedData(), std::min(size, buffer->Size()));
128 | 
129 | 	buffer = std::move(newBuffer);
130 | }
131 | 
132 | void UDX12::DynamicUploadBuffer::FastReserve(size_t size) {
133 | 	if (size <= Size())
134 | 		return;
135 | 
136 |     buffer = std::make_unique<UDX12::UploadBuffer>(device, size, flag);
137 | }
138 | 
139 | void UDX12::DynamicUploadBuffer::Set(UINT64 offset, const void* data, UINT64 size) {
140 |     assert(buffer);
141 |     buffer->Set(offset, data, size);
142 | }
143 | 
144 | void UDX12::DynamicUploadBuffer::CopyConstruct(
145 | 	size_t dstOffset, size_t srcOffset, size_t numBytes,
146 | 	ID3D12Device* device,
147 | 	ID3D12GraphicsCommandList* cmdList,
148 | 	D3D12_RESOURCE_STATES afterState,
149 | 	ID3D12Resource** pBuffer, // out com ptr
150 | 	D3D12_RESOURCE_FLAGS resFlags
151 | ) {
152 | 	assert(buffer);
153 | 	buffer->CopyConstruct(
154 | 		dstOffset, srcOffset, numBytes,
155 | 		device, cmdList, afterState, pBuffer, resFlags
156 | 	);
157 | }
158 | 
159 | void UDX12::DynamicUploadBuffer::CopyAssign(
160 | 	size_t dstOffset, size_t srcOffset, size_t numBytes,
161 | 	ID3D12GraphicsCommandList* cmdList,
162 | 	ID3D12Resource* dst,
163 | 	D3D12_RESOURCE_STATES state
164 | ) {
165 | 	assert(buffer);
166 | 	buffer->CopyAssign(
167 | 		dstOffset, srcOffset, numBytes,
168 | 		cmdList, dst, state
169 | 	);
170 | }
171 | 
172 | // move resource to deleteBatch
173 | void UDX12::DynamicUploadBuffer::Delete(ResourceDeleteBatch& deleteBatch) {
174 | 	buffer->Delete(deleteBatch);
175 | 	buffer.reset();
176 | }
177 | 


--------------------------------------------------------------------------------
/src/core/Util.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ubpa/UDX12/81b381e50e8dbc1b41fc30e074058e2bef707559/src/core/Util.cpp


--------------------------------------------------------------------------------
/src/core/VarSizeAllocMngr.cpp:
--------------------------------------------------------------------------------
  1 | #include <UDX12/VarSizeAllocMngr.h>
  2 | 
  3 | #include <utility>
  4 | #include <cassert>
  5 | #include <type_traits>
  6 | 
  7 | using namespace Ubpa::UDX12;
  8 | 
  9 | namespace Ubpa::UDX12::details {
 10 |     template <typename T>
 11 |     constexpr bool IsPowerOfTwo(T val) noexcept {
 12 |         if constexpr (std::is_unsigned_v<T>)
 13 |             return (val & (val - 1)) == 0;
 14 |         else
 15 |             return val > 0 && (val & (val - 1)) == 0;
 16 |     }
 17 | 
 18 |     template <typename T>
 19 |     constexpr T Align(T val, T alignment) noexcept {
 20 |         assert(IsPowerOfTwo(alignment));
 21 |         //    ceil(val \div alignment)
 22 |         // == (val + alignment - 1) / alignment
 23 |         // == (val + (alignment - 1)) & ~(alignment - 1)
 24 |         return (val + (alignment - 1)) & ~(alignment - 1);
 25 |     }
 26 | 
 27 |     template <typename T>
 28 |     constexpr T AlignDown(T val, T alignment) noexcept {
 29 |         assert(IsPowerOfTwo(alignment));
 30 |         //    floor(val \div alignment)
 31 |         // == val / alignment
 32 |         // == val & ~(alignment - 1)
 33 |         return val & ~(alignment - 1);
 34 |     }
 35 | }
 36 | 
 37 | VarSizeAllocMngr::VarSizeAllocMngr(size_t capacity) :
 38 |     capacity(capacity),
 39 |     freeSize(capacity)
 40 | {
 41 |     // Insert single maximum-size block
 42 |     AddNewBlock(0, capacity);
 43 |     ResetCurrAlignment();
 44 | }
 45 | 
 46 | VarSizeAllocMngr::VarSizeAllocMngr(VarSizeAllocMngr&& rhs) noexcept :
 47 |     offset2freeblock{ std::move(rhs.offset2freeblock) },
 48 |     size2freeblock{ std::move(rhs.size2freeblock) },
 49 |     capacity{ rhs.capacity },
 50 |     freeSize{ rhs.freeSize },
 51 |     curMinAlignment{ rhs.curMinAlignment }
 52 | {
 53 |     rhs.capacity = 0;
 54 |     rhs.freeSize = 0;
 55 |     rhs.curMinAlignment = 0;
 56 | }
 57 | 
 58 | VarSizeAllocMngr& VarSizeAllocMngr::operator=(VarSizeAllocMngr&& rhs) noexcept {
 59 |     offset2freeblock = std::move(rhs.offset2freeblock);
 60 |     size2freeblock = std::move(rhs.size2freeblock);
 61 |     capacity = rhs.capacity;
 62 |     freeSize = rhs.freeSize;
 63 |     curMinAlignment = rhs.curMinAlignment;
 64 | 
 65 |     rhs.capacity = 0;
 66 |     rhs.freeSize = 0;
 67 |     rhs.curMinAlignment = 0;
 68 | 
 69 |     return *this;
 70 | }
 71 | 
 72 | void VarSizeAllocMngr::AddNewBlock(size_t Offset, size_t Size) {
 73 |     auto [newBlockIter, success] = offset2freeblock.emplace(Offset, Size);
 74 |     assert(success);
 75 |     auto orderIter = size2freeblock.emplace(Size, newBlockIter);
 76 |     newBlockIter->second.OrderBySizeIt = orderIter;
 77 | }
 78 | 
 79 | void VarSizeAllocMngr::ResetCurrAlignment() noexcept {
 80 |     curMinAlignment = 1;
 81 |     while (curMinAlignment * 2 <= capacity)
 82 |         curMinAlignment *= 2;
 83 | }
 84 | 
 85 | VarSizeAllocMngr::Allocation VarSizeAllocMngr::Allocate(size_t size, size_t alignment) {
 86 |     assert(size > 0);
 87 |     assert("alignment must be power of 2" && details::IsPowerOfTwo(alignment));
 88 |     size = details::Align(size, alignment);
 89 |     if (freeSize < size)
 90 |         return Allocation::Invalid();
 91 | 
 92 |     auto alignmentReserve = (alignment > curMinAlignment) ? alignment - curMinAlignment : 0;
 93 |     // Get the first block that is large enough to encompass size + alignmentReserve bytes
 94 |     // lower_bound() returns an iterator pointing to the first element that
 95 |     // is not less (i.e. >= ) than key
 96 |     auto SmallestBlockItIt = size2freeblock.lower_bound(size + alignmentReserve);
 97 |     if (SmallestBlockItIt == size2freeblock.end())
 98 |         return Allocation::Invalid();
 99 | 
100 |     auto SmallestBlockIt = SmallestBlockItIt->second;
101 |     assert(size + alignmentReserve <= SmallestBlockIt->second.size);
102 |     assert(SmallestBlockIt->second.size == SmallestBlockItIt->first);
103 | 
104 |     //     SmallestBlockIt.Offset
105 |     //        |                                  |
106 |     //        |<------SmallestBlockIt.size------>|
107 |     //        |<------size------>|<---newSize--->|
108 |     //        |                  |
109 |     //      offset              newOffset
110 |     //
111 |     auto offset = SmallestBlockIt->first;
112 |     assert(offset % curMinAlignment == 0);
113 |     auto alignedOffset = details::Align(offset, alignment);
114 |     auto adjustedSize = size + (alignedOffset - offset);
115 |     assert(adjustedSize <= size + alignmentReserve);
116 | 
117 |     auto newOffset = offset + adjustedSize;
118 |     auto newSize = SmallestBlockIt->second.size - adjustedSize;
119 |     assert(SmallestBlockItIt == SmallestBlockIt->second.OrderBySizeIt);
120 |     size2freeblock.erase(SmallestBlockItIt);
121 |     offset2freeblock.erase(SmallestBlockIt);
122 |     if (newSize > 0)
123 |         AddNewBlock(newOffset, newSize);
124 | 
125 |     freeSize -= adjustedSize;
126 | 
127 |     if ((size & (curMinAlignment - 1)) != 0) {
128 |         if (details::IsPowerOfTwo(size)) {
129 |             assert(size >= alignment && size < curMinAlignment);
130 |             curMinAlignment = size;
131 |         }
132 |         else
133 |             curMinAlignment = std::min(curMinAlignment, alignment);
134 |     }
135 |     return Allocation{ offset, adjustedSize };
136 | }
137 | 
138 | void VarSizeAllocMngr::Free(size_t offset, size_t size) {
139 |     assert(offset + size <= capacity);
140 | 
141 |     // Find the first element whose offset is greater than the specified offset.
142 |     // upper_bound() returns an iterator pointing to the first element in the
143 |     // container whose key is considered to go after k.
144 |     auto nextBlockIt = offset2freeblock.upper_bound(offset);
145 |     // Block being deallocated must not overlap with the next block
146 |     assert(nextBlockIt == offset2freeblock.end() || offset + size <= nextBlockIt->first);
147 |     auto prevBlockIt = nextBlockIt;
148 |     if (prevBlockIt != offset2freeblock.begin()) {
149 |         --prevBlockIt;
150 |         // Block being deallocated must not overlap with the previous block
151 |         assert(offset >= prevBlockIt->first + prevBlockIt->second.size);
152 |     }
153 |     else
154 |         prevBlockIt = offset2freeblock.end();
155 | 
156 |     size_t newSize, newOffset;
157 |     if (prevBlockIt != offset2freeblock.end() && offset == prevBlockIt->first + prevBlockIt->second.size)
158 |     {
159 |         //  PrevBlock.Offset             Offset
160 |         //       |                          |
161 |         //       |<-----PrevBlock.Size----->|<------Size-------->|
162 |         //
163 |         newSize = prevBlockIt->second.size + size;
164 |         newOffset = prevBlockIt->first;
165 | 
166 |         if (nextBlockIt != offset2freeblock.end() && offset + size == nextBlockIt->first)
167 |         {
168 |             //   PrevBlock.Offset           Offset            NextBlock.Offset
169 |             //     |                          |                    |
170 |             //     |<-----PrevBlock.Size----->|<------Size-------->|<-----NextBlock.Size----->|
171 |             //
172 |             newSize += nextBlockIt->second.size;
173 |             size2freeblock.erase(prevBlockIt->second.OrderBySizeIt);
174 |             size2freeblock.erase(nextBlockIt->second.OrderBySizeIt);
175 |             // Delete the range of two blocks
176 |             ++nextBlockIt;
177 |             offset2freeblock.erase(prevBlockIt, nextBlockIt);
178 |         }
179 |         else
180 |         {
181 |             //   PrevBlock.Offset           Offset                     NextBlock.Offset
182 |             //     |                          |                             |
183 |             //     |<-----PrevBlock.Size----->|<------Size-------->| ~ ~ ~  |<-----NextBlock.Size----->|
184 |             //
185 |             size2freeblock.erase(prevBlockIt->second.OrderBySizeIt);
186 |             offset2freeblock.erase(prevBlockIt);
187 |         }
188 |     }
189 |     else if (nextBlockIt != offset2freeblock.end() && offset + size == nextBlockIt->first)
190 |     {
191 |         //   PrevBlock.Offset                   Offset            NextBlock.Offset
192 |         //     |                                  |                    |
193 |         //     |<-----PrevBlock.Size----->| ~ ~ ~ |<------Size-------->|<-----NextBlock.Size----->|
194 |         //
195 |         newSize = size + nextBlockIt->second.size;
196 |         newOffset = offset;
197 |         size2freeblock.erase(nextBlockIt->second.OrderBySizeIt);
198 |         offset2freeblock.erase(nextBlockIt);
199 |     }
200 |     else
201 |     {
202 |         //   PrevBlock.Offset                   Offset                     NextBlock.Offset
203 |         //     |                                  |                            |
204 |         //     |<-----PrevBlock.Size----->| ~ ~ ~ |<------Size-------->| ~ ~ ~ |<-----NextBlock.Size----->|
205 |         //
206 |         newSize = size;
207 |         newOffset = offset;
208 |     }
209 | 
210 |     AddNewBlock(newOffset, newSize);
211 | 
212 |     freeSize += size;
213 |     if (IsEmpty()) {
214 |         // Reset current alignment
215 |         assert(offset2freeblock.size() == 1);
216 |         ResetCurrAlignment();
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------
/src/core/dxcapi.use.h:
--------------------------------------------------------------------------------
  1 | //*********************************************************
  2 | //
  3 | // Copyright (c) Microsoft. All rights reserved.
  4 | // This code is licensed under the MIT License (MIT).
  5 | // THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
  6 | // ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
  7 | // IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
  8 | // PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
  9 | //
 10 | //*********************************************************
 11 | //////////////////////////////////////////////////////////////////////////////
 12 | //                                                                           //
 13 | // dxcapi.use.h                                                              //
 14 | // Copyright (C) Microsoft Corporation. All rights reserved.                 //
 15 | // This file is distributed under the University of Illinois Open Source     //
 16 | // License. See LICENSE.TXT for details.                                     //
 17 | //                                                                           //
 18 | // Provides support for DXC API users.                                       //
 19 | //                                                                           //
 20 | ///////////////////////////////////////////////////////////////////////////////
 21 | 
 22 | #ifndef __DXCAPI_USE_H__
 23 | #define __DXCAPI_USE_H__
 24 | 
 25 | #include "dxcapi.h"
 26 | 
 27 | namespace dxc {
 28 | 
 29 | // Helper class to dynamically load the dxcompiler or a compatible libraries.
 30 | class DxcDllSupport {
 31 | protected:
 32 |   HMODULE m_dll;
 33 |   DxcCreateInstanceProc m_createFn;
 34 |   DxcCreateInstance2Proc m_createFn2;
 35 | 
 36 |   HRESULT InitializeInternal(LPCWSTR dllName, LPCSTR fnName) {
 37 |     if (m_dll != nullptr) return S_OK;
 38 |     m_dll = LoadLibraryW(dllName);
 39 | 
 40 |     if (m_dll == nullptr) return HRESULT_FROM_WIN32(GetLastError());
 41 |     m_createFn = (DxcCreateInstanceProc)GetProcAddress(m_dll, fnName);
 42 | 
 43 |     if (m_createFn == nullptr) {
 44 |       HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
 45 |       FreeLibrary(m_dll);
 46 |       m_dll = nullptr;
 47 |       return hr;
 48 |     }
 49 | 
 50 |     // Only basic functions used to avoid requiring additional headers.
 51 |     m_createFn2 = nullptr;
 52 |     char fnName2[128];
 53 |     size_t s = strlen(fnName);
 54 |     if (s < sizeof(fnName2) - 2) {
 55 |       memcpy(fnName2, fnName, s);
 56 |       fnName2[s] = '2';
 57 |       fnName2[s + 1] = '\0';
 58 |       m_createFn2 = (DxcCreateInstance2Proc)GetProcAddress(m_dll, fnName2);
 59 |     }
 60 | 
 61 |     return S_OK;
 62 |   }
 63 | 
 64 | public:
 65 |   DxcDllSupport() : m_dll(nullptr), m_createFn(nullptr), m_createFn2(nullptr) {
 66 |   }
 67 | 
 68 |   DxcDllSupport(DxcDllSupport&& other) {
 69 |     m_dll = other.m_dll; other.m_dll = nullptr;
 70 |     m_createFn = other.m_createFn; other.m_createFn = nullptr;
 71 |     m_createFn2 = other.m_createFn2; other.m_createFn2 = nullptr;
 72 |   }
 73 | 
 74 |   ~DxcDllSupport() {
 75 |     Cleanup();
 76 |   }
 77 | 
 78 |   HRESULT Initialize() {
 79 |     return InitializeInternal(L"dxcompiler.dll", "DxcCreateInstance");
 80 |   }
 81 | 
 82 |   HRESULT InitializeForDll(_In_z_ const wchar_t* dll, _In_z_ const char* entryPoint) {
 83 |     return InitializeInternal(dll, entryPoint);
 84 |   }
 85 | 
 86 |   template <typename TInterface>
 87 |   HRESULT CreateInstance(REFCLSID clsid, _Outptr_ TInterface** pResult) {
 88 |     return CreateInstance(clsid, __uuidof(TInterface), (IUnknown**)pResult);
 89 |   }
 90 | 
 91 |   HRESULT CreateInstance(REFCLSID clsid, REFIID riid, _Outptr_ IUnknown **pResult) {
 92 |     if (pResult == nullptr) return E_POINTER;
 93 |     if (m_dll == nullptr) return E_FAIL;
 94 |     HRESULT hr = m_createFn(clsid, riid, (LPVOID*)pResult);
 95 |     return hr;
 96 |   }
 97 | 
 98 |   template <typename TInterface>
 99 |   HRESULT CreateInstance2(IMalloc *pMalloc, REFCLSID clsid, _Outptr_ TInterface** pResult) {
100 |     return CreateInstance2(pMalloc, clsid, __uuidof(TInterface), (IUnknown**)pResult);
101 |   }
102 | 
103 |   HRESULT CreateInstance2(IMalloc *pMalloc, REFCLSID clsid, REFIID riid, _Outptr_ IUnknown **pResult) {
104 |     if (pResult == nullptr) return E_POINTER;
105 |     if (m_dll == nullptr) return E_FAIL;
106 |     if (m_createFn2 == nullptr) return E_FAIL;
107 |     HRESULT hr = m_createFn2(pMalloc, clsid, riid, (LPVOID*)pResult);
108 |     return hr;
109 |   }
110 | 
111 |   bool HasCreateWithMalloc() const {
112 |     return m_createFn2 != nullptr;
113 |   }
114 | 
115 |   bool IsEnabled() const {
116 |     return m_dll != nullptr;
117 |   }
118 | 
119 |   void Cleanup() {
120 |     if (m_dll != nullptr) {
121 |       m_createFn = nullptr;
122 |       m_createFn2 = nullptr;
123 |       FreeLibrary(m_dll);
124 |       m_dll = nullptr;
125 |     }
126 |   }
127 | 
128 |   HMODULE Detach() {
129 |     HMODULE module = m_dll;
130 |     m_dll = nullptr;
131 |     return module;
132 |   }
133 | };
134 | 
135 | inline DxcDefine GetDefine(_In_ LPCWSTR name, LPCWSTR value) {
136 |   DxcDefine result;
137 |   result.Name = name;
138 |   result.Value = value;
139 |   return result;
140 | }
141 | 
142 | // Checks an HRESULT and formats an error message with the appended data.
143 | void IFT_Data(HRESULT hr, _In_opt_ LPCWSTR data);
144 | 
145 | void EnsureEnabled(DxcDllSupport &dxcSupport);
146 | void ReadFileIntoBlob(DxcDllSupport &dxcSupport, _In_ LPCWSTR pFileName,
147 |                       _Outptr_ IDxcBlobEncoding **ppBlobEncoding);
148 | void WriteBlobToConsole(_In_opt_ IDxcBlob *pBlob, DWORD streamType = STD_OUTPUT_HANDLE);
149 | void WriteBlobToFile(_In_opt_ IDxcBlob *pBlob, _In_ LPCWSTR pFileName);
150 | void WriteBlobToHandle(_In_opt_ IDxcBlob *pBlob, HANDLE hFile, _In_opt_ LPCWSTR pFileName);
151 | void WriteUtf8ToConsole(_In_opt_count_(charCount) const char *pText,
152 |                         int charCount, DWORD streamType = STD_OUTPUT_HANDLE);
153 | void WriteUtf8ToConsoleSizeT(_In_opt_count_(charCount) const char *pText,
154 |                              size_t charCount, DWORD streamType = STD_OUTPUT_HANDLE);
155 | void WriteOperationErrorsToConsole(_In_ IDxcOperationResult *pResult,
156 |                                    bool outputWarnings);
157 | void WriteOperationResultToConsole(_In_ IDxcOperationResult *pRewriteResult,
158 |                                    bool outputWarnings);
159 | 
160 | } // namespace dxc
161 | 
162 | #endif


--------------------------------------------------------------------------------
/src/test/00_init/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | Ubpa_GetTargetName(common "${PROJECT_SOURCE_DIR}/src/test/common")
2 | Ubpa_AddTarget(
3 |   TEST
4 |   MODE EXE
5 |   LIB ${common}
6 | )
7 | 


--------------------------------------------------------------------------------
/src/test/00_init/InitDirect3DApp.cpp:
--------------------------------------------------------------------------------
  1 | #include "../common/d3dApp.h"
  2 | #include <DirectXColors.h>
  3 | 
  4 | using namespace DirectX;
  5 | 
  6 | class InitDirect3DApp : public D3DApp
  7 | {
  8 | public:
  9 | 	InitDirect3DApp(HINSTANCE hInstance);
 10 | 	~InitDirect3DApp();
 11 | 
 12 | 	virtual bool Initialize()override;
 13 | 
 14 | private:
 15 |     virtual void OnResize()override;
 16 |     virtual void Update(const GameTimer& gt)override;
 17 |     virtual void Draw(const GameTimer& gt)override;
 18 | 
 19 | };
 20 | 
 21 | int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance,
 22 | 				   PSTR cmdLine, int showCmd)
 23 | {
 24 | 	// Enable run-time memory check for debug builds.
 25 | #if defined(DEBUG) | defined(_DEBUG)
 26 | 	_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
 27 | #endif
 28 | 
 29 |     try
 30 |     {
 31 |         InitDirect3DApp theApp(hInstance);
 32 |         if(!theApp.Initialize())
 33 |             return 0;
 34 | 
 35 |         return theApp.Run();
 36 |     }
 37 |     catch(Ubpa::UDX12::Util::Exception& e)
 38 |     {
 39 |         MessageBox(nullptr, e.ToString().c_str(), L"HR Failed", MB_OK);
 40 |         return 0;
 41 |     }
 42 | }
 43 | 
 44 | InitDirect3DApp::InitDirect3DApp(HINSTANCE hInstance)
 45 | : D3DApp(hInstance) 
 46 | {
 47 | }
 48 | 
 49 | InitDirect3DApp::~InitDirect3DApp()
 50 | {
 51 | }
 52 | 
 53 | bool InitDirect3DApp::Initialize()
 54 | {
 55 |     if(!D3DApp::Initialize())
 56 | 		return false;
 57 | 		
 58 | 	return true;
 59 | }
 60 | 
 61 | void InitDirect3DApp::OnResize()
 62 | {
 63 | 	D3DApp::OnResize();
 64 | }
 65 | 
 66 | void InitDirect3DApp::Update(const GameTimer& gt)
 67 | {
 68 | 
 69 | }
 70 | 
 71 | void InitDirect3DApp::Draw(const GameTimer& gt)
 72 | {
 73 |     // Reuse the memory associated with command recording.
 74 |     // We can only reset when the associated command lists have finished execution on the GPU.
 75 | 	ThrowIfFailed(mDirectCmdListAlloc->Reset());
 76 | 
 77 | 	// A command list can be reset after it has been added to the command queue via ExecuteCommandList.
 78 |     // Reusing the command list reuses memory.
 79 |     ThrowIfFailed(mCommandList->Reset(mDirectCmdListAlloc.Get(), nullptr));
 80 | 
 81 | 	// Indicate a state transition on the resource usage.
 82 | 	DirectX::TransitionResource(mCommandList.Get(), CurrentBackBuffer(),
 83 | 		D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
 84 | 
 85 |     // Set the viewport and scissor rect.  This needs to be reset whenever the command list is reset.
 86 |     mCommandList->RSSetViewports(1, &mScreenViewport);
 87 |     mCommandList->RSSetScissorRects(1, &mScissorRect);
 88 | 
 89 |     // Clear the back buffer and depth buffer.
 90 | 	mCommandList->ClearRenderTargetView(CurrentBackBufferView(), Colors::LightSteelBlue, 0, nullptr);
 91 | 	mCommandList->ClearDepthStencilView(DepthStencilView(), D3D12_CLEAR_FLAG_DEPTH | D3D12_CLEAR_FLAG_STENCIL, 1.0f, 0, 0, nullptr);
 92 | 	
 93 |     // Specify the buffers we are going to render to.
 94 | 	// 'OM' -> Output Merge
 95 | 	const auto curBackView = CurrentBackBufferView();
 96 | 	const auto depthView = DepthStencilView();
 97 | 	mCommandList->OMSetRenderTargets(1, &curBackView, true, &depthView);
 98 | 	
 99 |     // Indicate a state transition on the resource usage.
100 | 	DirectX::TransitionResource(mCommandList.Get(), CurrentBackBuffer(),
101 | 		D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
102 | 
103 |     // Done recording commands.
104 | 	ThrowIfFailed(mCommandList->Close());
105 |  
106 |     // Add the command list to the queue for execution.
107 | 	ID3D12CommandList* cmdsLists[] = { mCommandList.Get() };
108 | 	mCommandQueue->ExecuteCommandLists(_countof(cmdsLists), cmdsLists);
109 | 	
110 | 	// swap the back and front buffers
111 | 	ThrowIfFailed(mSwapChain->Present(0, 0));
112 | 	mCurrBackBuffer = (mCurrBackBuffer + 1) % SwapChainBufferCount;
113 | 
114 | 	// Wait until frame commands are complete.  This waiting is inefficient and is
115 | 	// done for simplicity.  Later we will show how to organize our rendering code
116 | 	// so we do not have to wait per frame.
117 | 	FlushCommandQueue();
118 | }
119 | 


--------------------------------------------------------------------------------
/src/test/common/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | Ubpa_GetTargetName(core ${PROJECT_SOURCE_DIR}/src/core)
2 | Ubpa_AddTarget(
3 |   TEST
4 |   MODE STATIC
5 |   LIB ${core}
6 |   L_OPTION_INTERFACE
7 |     /SUBSYSTEM:WINDOWS
8 | )
9 | 


--------------------------------------------------------------------------------
/src/test/common/Camera.cpp:
--------------------------------------------------------------------------------
  1 | //***************************************************************************************
  2 | // Camera.h by Frank Luna (C) 2011 All Rights Reserved.
  3 | //***************************************************************************************
  4 | 
  5 | #include "Camera.h"
  6 | 
  7 | using namespace DirectX;
  8 | 
  9 | Camera::Camera()
 10 | {
 11 | 	SetLens(0.25f*MathHelper::Pi, 1.0f, 1.0f, 1000.0f);
 12 | }
 13 | 
 14 | Camera::~Camera()
 15 | {
 16 | }
 17 | 
 18 | XMVECTOR Camera::GetPosition()const
 19 | {
 20 | 	return XMLoadFloat3(&mPosition);
 21 | }
 22 | 
 23 | XMFLOAT3 Camera::GetPosition3f()const
 24 | {
 25 | 	return mPosition;
 26 | }
 27 | 
 28 | void Camera::SetPosition(float x, float y, float z)
 29 | {
 30 | 	mPosition = XMFLOAT3(x, y, z);
 31 | 	mViewDirty = true;
 32 | }
 33 | 
 34 | void Camera::SetPosition(const XMFLOAT3& v)
 35 | {
 36 | 	mPosition = v;
 37 | 	mViewDirty = true;
 38 | }
 39 | 
 40 | XMVECTOR Camera::GetRight()const
 41 | {
 42 | 	return XMLoadFloat3(&mRight);
 43 | }
 44 | 
 45 | XMFLOAT3 Camera::GetRight3f()const
 46 | {
 47 | 	return mRight;
 48 | }
 49 | 
 50 | XMVECTOR Camera::GetUp()const
 51 | {
 52 | 	return XMLoadFloat3(&mUp);
 53 | }
 54 | 
 55 | XMFLOAT3 Camera::GetUp3f()const
 56 | {
 57 | 	return mUp;
 58 | }
 59 | 
 60 | XMVECTOR Camera::GetLook()const
 61 | {
 62 | 	return XMLoadFloat3(&mLook);
 63 | }
 64 | 
 65 | XMFLOAT3 Camera::GetLook3f()const
 66 | {
 67 | 	return mLook;
 68 | }
 69 | 
 70 | float Camera::GetNearZ()const
 71 | {
 72 | 	return mNearZ;
 73 | }
 74 | 
 75 | float Camera::GetFarZ()const
 76 | {
 77 | 	return mFarZ;
 78 | }
 79 | 
 80 | float Camera::GetAspect()const
 81 | {
 82 | 	return mAspect;
 83 | }
 84 | 
 85 | float Camera::GetFovY()const
 86 | {
 87 | 	return mFovY;
 88 | }
 89 | 
 90 | float Camera::GetFovX()const
 91 | {
 92 | 	float halfWidth = 0.5f*GetNearWindowWidth();
 93 | 	return 2.0f*atan(halfWidth / mNearZ);
 94 | }
 95 | 
 96 | float Camera::GetNearWindowWidth()const
 97 | {
 98 | 	return mAspect * mNearWindowHeight;
 99 | }
100 | 
101 | float Camera::GetNearWindowHeight()const
102 | {
103 | 	return mNearWindowHeight;
104 | }
105 | 
106 | float Camera::GetFarWindowWidth()const
107 | {
108 | 	return mAspect * mFarWindowHeight;
109 | }
110 | 
111 | float Camera::GetFarWindowHeight()const
112 | {
113 | 	return mFarWindowHeight;
114 | }
115 | 
116 | void Camera::SetLens(float fovY, float aspect, float zn, float zf)
117 | {
118 | 	// cache properties
119 | 	mFovY = fovY;
120 | 	mAspect = aspect;
121 | 	mNearZ = zn;
122 | 	mFarZ = zf;
123 | 
124 | 	mNearWindowHeight = 2.0f * mNearZ * tanf( 0.5f*mFovY );
125 | 	mFarWindowHeight  = 2.0f * mFarZ * tanf( 0.5f*mFovY );
126 | 
127 | 	XMMATRIX P = XMMatrixPerspectiveFovLH(mFovY, mAspect, mNearZ, mFarZ);
128 | 	XMStoreFloat4x4(&mProj, P);
129 | }
130 | 
131 | void Camera::LookAt(FXMVECTOR pos, FXMVECTOR target, FXMVECTOR worldUp)
132 | {
133 | 	XMVECTOR L = XMVector3Normalize(XMVectorSubtract(target, pos));
134 | 	XMVECTOR R = XMVector3Normalize(XMVector3Cross(worldUp, L));
135 | 	XMVECTOR U = XMVector3Cross(L, R);
136 | 
137 | 	XMStoreFloat3(&mPosition, pos);
138 | 	XMStoreFloat3(&mLook, L);
139 | 	XMStoreFloat3(&mRight, R);
140 | 	XMStoreFloat3(&mUp, U);
141 | 
142 | 	mViewDirty = true;
143 | }
144 | 
145 | void Camera::LookAt(const XMFLOAT3& pos, const XMFLOAT3& target, const XMFLOAT3& up)
146 | {
147 | 	XMVECTOR P = XMLoadFloat3(&pos);
148 | 	XMVECTOR T = XMLoadFloat3(&target);
149 | 	XMVECTOR U = XMLoadFloat3(&up);
150 | 
151 | 	LookAt(P, T, U);
152 | 
153 | 	mViewDirty = true;
154 | }
155 | 
156 | XMMATRIX Camera::GetView()const
157 | {
158 | 	assert(!mViewDirty);
159 | 	return XMLoadFloat4x4(&mView);
160 | }
161 | 
162 | XMMATRIX Camera::GetProj()const
163 | {
164 | 	return XMLoadFloat4x4(&mProj);
165 | }
166 | 
167 | 
168 | XMFLOAT4X4 Camera::GetView4x4f()const
169 | {
170 | 	assert(!mViewDirty);
171 | 	return mView;
172 | }
173 | 
174 | XMFLOAT4X4 Camera::GetProj4x4f()const
175 | {
176 | 	return mProj;
177 | }
178 | 
179 | void Camera::Strafe(float d)
180 | {
181 | 	// mPosition += d*mRight
182 | 	XMVECTOR s = XMVectorReplicate(d);
183 | 	XMVECTOR r = XMLoadFloat3(&mRight);
184 | 	XMVECTOR p = XMLoadFloat3(&mPosition);
185 | 	XMStoreFloat3(&mPosition, XMVectorMultiplyAdd(s, r, p));
186 | 
187 | 	mViewDirty = true;
188 | }
189 | 
190 | void Camera::Walk(float d)
191 | {
192 | 	// mPosition += d*mLook
193 | 	XMVECTOR s = XMVectorReplicate(d);
194 | 	XMVECTOR l = XMLoadFloat3(&mLook);
195 | 	XMVECTOR p = XMLoadFloat3(&mPosition);
196 | 	XMStoreFloat3(&mPosition, XMVectorMultiplyAdd(s, l, p));
197 | 
198 | 	mViewDirty = true;
199 | }
200 | 
201 | void Camera::Pitch(float angle)
202 | {
203 | 	// Rotate up and look vector about the right vector.
204 | 
205 | 	XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&mRight), angle);
206 | 
207 | 	XMStoreFloat3(&mUp,   XMVector3TransformNormal(XMLoadFloat3(&mUp), R));
208 | 	XMStoreFloat3(&mLook, XMVector3TransformNormal(XMLoadFloat3(&mLook), R));
209 | 
210 | 	mViewDirty = true;
211 | }
212 | 
213 | void Camera::RotateY(float angle)
214 | {
215 | 	// Rotate the basis vectors about the world y-axis.
216 | 
217 | 	XMMATRIX R = XMMatrixRotationY(angle);
218 | 
219 | 	XMStoreFloat3(&mRight,   XMVector3TransformNormal(XMLoadFloat3(&mRight), R));
220 | 	XMStoreFloat3(&mUp, XMVector3TransformNormal(XMLoadFloat3(&mUp), R));
221 | 	XMStoreFloat3(&mLook, XMVector3TransformNormal(XMLoadFloat3(&mLook), R));
222 | 
223 | 	mViewDirty = true;
224 | }
225 | 
226 | void Camera::UpdateViewMatrix()
227 | {
228 | 	if(mViewDirty)
229 | 	{
230 | 		XMVECTOR R = XMLoadFloat3(&mRight);
231 | 		XMVECTOR U = XMLoadFloat3(&mUp);
232 | 		XMVECTOR L = XMLoadFloat3(&mLook);
233 | 		XMVECTOR P = XMLoadFloat3(&mPosition);
234 | 
235 | 		// Keep camera's axes orthogonal to each other and of unit length.
236 | 		L = XMVector3Normalize(L);
237 | 		U = XMVector3Normalize(XMVector3Cross(L, R));
238 | 
239 | 		// U, L already ortho-normal, so no need to normalize cross product.
240 | 		R = XMVector3Cross(U, L);
241 | 
242 | 		// Fill in the view matrix entries.
243 | 		float x = -XMVectorGetX(XMVector3Dot(P, R));
244 | 		float y = -XMVectorGetX(XMVector3Dot(P, U));
245 | 		float z = -XMVectorGetX(XMVector3Dot(P, L));
246 | 
247 | 		XMStoreFloat3(&mRight, R);
248 | 		XMStoreFloat3(&mUp, U);
249 | 		XMStoreFloat3(&mLook, L);
250 | 
251 | 		mView(0, 0) = mRight.x;
252 | 		mView(1, 0) = mRight.y;
253 | 		mView(2, 0) = mRight.z;
254 | 		mView(3, 0) = x;
255 | 
256 | 		mView(0, 1) = mUp.x;
257 | 		mView(1, 1) = mUp.y;
258 | 		mView(2, 1) = mUp.z;
259 | 		mView(3, 1) = y;
260 | 
261 | 		mView(0, 2) = mLook.x;
262 | 		mView(1, 2) = mLook.y;
263 | 		mView(2, 2) = mLook.z;
264 | 		mView(3, 2) = z;
265 | 
266 | 		mView(0, 3) = 0.0f;
267 | 		mView(1, 3) = 0.0f;
268 | 		mView(2, 3) = 0.0f;
269 | 		mView(3, 3) = 1.0f;
270 | 
271 | 		mViewDirty = false;
272 | 	}
273 | }
274 | 
275 | 
276 | 


--------------------------------------------------------------------------------
/src/test/common/Camera.h:
--------------------------------------------------------------------------------
 1 | //***************************************************************************************
 2 | // Camera.h by Frank Luna (C) 2011 All Rights Reserved.
 3 | //   
 4 | // Simple first person style camera class that lets the viewer explore the 3D scene.
 5 | //   -It keeps track of the camera coordinate system relative to the world space
 6 | //    so that the view matrix can be constructed.  
 7 | //   -It keeps track of the viewing frustum of the camera so that the projection
 8 | //    matrix can be obtained.
 9 | //***************************************************************************************
10 | 
11 | #ifndef CAMERA_H
12 | #define CAMERA_H
13 | 
14 | #include "d3dUtil.h"
15 | 
16 | class Camera
17 | {
18 | public:
19 | 
20 | 	Camera();
21 | 	~Camera();
22 | 
23 | 	// Get/Set world camera position.
24 | 	DirectX::XMVECTOR GetPosition()const;
25 | 	DirectX::XMFLOAT3 GetPosition3f()const;
26 | 	void SetPosition(float x, float y, float z);
27 | 	void SetPosition(const DirectX::XMFLOAT3& v);
28 | 	
29 | 	// Get camera basis vectors.
30 | 	DirectX::XMVECTOR GetRight()const;
31 | 	DirectX::XMFLOAT3 GetRight3f()const;
32 | 	DirectX::XMVECTOR GetUp()const;
33 | 	DirectX::XMFLOAT3 GetUp3f()const;
34 | 	DirectX::XMVECTOR GetLook()const;
35 | 	DirectX::XMFLOAT3 GetLook3f()const;
36 | 
37 | 	// Get frustum properties.
38 | 	float GetNearZ()const;
39 | 	float GetFarZ()const;
40 | 	float GetAspect()const;
41 | 	float GetFovY()const;
42 | 	float GetFovX()const;
43 | 
44 | 	// Get near and far plane dimensions in view space coordinates.
45 | 	float GetNearWindowWidth()const;
46 | 	float GetNearWindowHeight()const;
47 | 	float GetFarWindowWidth()const;
48 | 	float GetFarWindowHeight()const;
49 | 	
50 | 	// Set frustum.
51 | 	void SetLens(float fovY, float aspect, float zn, float zf);
52 | 
53 | 	// Define camera space via LookAt parameters.
54 | 	void LookAt(DirectX::FXMVECTOR pos, DirectX::FXMVECTOR target, DirectX::FXMVECTOR worldUp);
55 | 	void LookAt(const DirectX::XMFLOAT3& pos, const DirectX::XMFLOAT3& target, const DirectX::XMFLOAT3& up);
56 | 
57 | 	// Get View/Proj matrices.
58 | 	DirectX::XMMATRIX GetView()const;
59 | 	DirectX::XMMATRIX GetProj()const;
60 | 
61 | 	DirectX::XMFLOAT4X4 GetView4x4f()const;
62 | 	DirectX::XMFLOAT4X4 GetProj4x4f()const;
63 | 
64 | 	// Strafe/Walk the camera a distance d.
65 | 	void Strafe(float d);
66 | 	void Walk(float d);
67 | 
68 | 	// Rotate the camera.
69 | 	void Pitch(float angle);
70 | 	void RotateY(float angle);
71 | 
72 | 	// After modifying camera position/orientation, call to rebuild the view matrix.
73 | 	void UpdateViewMatrix();
74 | 
75 | private:
76 | 
77 | 	// Camera coordinate system with coordinates relative to world space.
78 | 	DirectX::XMFLOAT3 mPosition = { 0.0f, 0.0f, 0.0f };
79 | 	DirectX::XMFLOAT3 mRight = { 1.0f, 0.0f, 0.0f };
80 | 	DirectX::XMFLOAT3 mUp = { 0.0f, 1.0f, 0.0f };
81 | 	DirectX::XMFLOAT3 mLook = { 0.0f, 0.0f, 1.0f };
82 | 
83 | 	// Cache frustum properties.
84 | 	float mNearZ = 0.0f;
85 | 	float mFarZ = 0.0f;
86 | 	float mAspect = 0.0f;
87 | 	float mFovY = 0.0f;
88 | 	float mNearWindowHeight = 0.0f;
89 | 	float mFarWindowHeight = 0.0f;
90 | 
91 | 	bool mViewDirty = true;
92 | 
93 | 	// Cache View/Proj matrices.
94 | 	DirectX::XMFLOAT4X4 mView = MathHelper::Identity4x4();
95 | 	DirectX::XMFLOAT4X4 mProj = MathHelper::Identity4x4();
96 | };
97 | 
98 | #endif // CAMERA_H


--------------------------------------------------------------------------------
/src/test/common/GameTimer.cpp:
--------------------------------------------------------------------------------
  1 | //***************************************************************************************
  2 | // GameTimer.cpp by Frank Luna (C) 2011 All Rights Reserved.
  3 | //***************************************************************************************
  4 | 
  5 | #include <windows.h>
  6 | #include "GameTimer.h"
  7 | 
  8 | GameTimer::GameTimer()
  9 | : mSecondsPerCount(0.0), mDeltaTime(-1.0), mBaseTime(0), 
 10 |   mPausedTime(0), mPrevTime(0), mCurrTime(0), mStopped(false)
 11 | {
 12 | 	__int64 countsPerSec;
 13 | 	QueryPerformanceFrequency((LARGE_INTEGER*)&countsPerSec);
 14 | 	mSecondsPerCount = 1.0 / (double)countsPerSec;
 15 | }
 16 | 
 17 | // Returns the total time elapsed since Reset() was called, NOT counting any
 18 | // time when the clock is stopped.
 19 | float GameTimer::TotalTime()const
 20 | {
 21 | 	// If we are stopped, do not count the time that has passed since we stopped.
 22 | 	// Moreover, if we previously already had a pause, the distance 
 23 | 	// mStopTime - mBaseTime includes paused time, which we do not want to count.
 24 | 	// To correct this, we can subtract the paused time from mStopTime:  
 25 | 	//
 26 | 	//                     |<--paused time-->|
 27 | 	// ----*---------------*-----------------*------------*------------*------> time
 28 | 	//  mBaseTime       mStopTime        startTime     mStopTime    mCurrTime
 29 | 
 30 | 	if( mStopped )
 31 | 	{
 32 | 		return (float)(((mStopTime - mPausedTime)-mBaseTime)*mSecondsPerCount);
 33 | 	}
 34 | 
 35 | 	// The distance mCurrTime - mBaseTime includes paused time,
 36 | 	// which we do not want to count.  To correct this, we can subtract 
 37 | 	// the paused time from mCurrTime:  
 38 | 	//
 39 | 	//  (mCurrTime - mPausedTime) - mBaseTime 
 40 | 	//
 41 | 	//                     |<--paused time-->|
 42 | 	// ----*---------------*-----------------*------------*------> time
 43 | 	//  mBaseTime       mStopTime        startTime     mCurrTime
 44 | 	
 45 | 	else
 46 | 	{
 47 | 		return (float)(((mCurrTime-mPausedTime)-mBaseTime)*mSecondsPerCount);
 48 | 	}
 49 | }
 50 | 
 51 | float GameTimer::DeltaTime()const
 52 | {
 53 | 	return (float)mDeltaTime;
 54 | }
 55 | 
 56 | void GameTimer::Reset()
 57 | {
 58 | 	__int64 currTime;
 59 | 	QueryPerformanceCounter((LARGE_INTEGER*)&currTime);
 60 | 
 61 | 	mBaseTime = currTime;
 62 | 	mPrevTime = currTime;
 63 | 	mStopTime = 0;
 64 | 	mStopped  = false;
 65 | }
 66 | 
 67 | void GameTimer::Start()
 68 | {
 69 | 	__int64 startTime;
 70 | 	QueryPerformanceCounter((LARGE_INTEGER*)&startTime);
 71 | 
 72 | 
 73 | 	// Accumulate the time elapsed between stop and start pairs.
 74 | 	//
 75 | 	//                     |<-------d------->|
 76 | 	// ----*---------------*-----------------*------------> time
 77 | 	//  mBaseTime       mStopTime        startTime     
 78 | 
 79 | 	if( mStopped )
 80 | 	{
 81 | 		mPausedTime += (startTime - mStopTime);	
 82 | 
 83 | 		mPrevTime = startTime;
 84 | 		mStopTime = 0;
 85 | 		mStopped  = false;
 86 | 	}
 87 | }
 88 | 
 89 | void GameTimer::Stop()
 90 | {
 91 | 	if( !mStopped )
 92 | 	{
 93 | 		__int64 currTime;
 94 | 		QueryPerformanceCounter((LARGE_INTEGER*)&currTime);
 95 | 
 96 | 		mStopTime = currTime;
 97 | 		mStopped  = true;
 98 | 	}
 99 | }
100 | 
101 | void GameTimer::Tick()
102 | {
103 | 	if( mStopped )
104 | 	{
105 | 		mDeltaTime = 0.0;
106 | 		return;
107 | 	}
108 | 
109 | 	__int64 currTime;
110 | 	QueryPerformanceCounter((LARGE_INTEGER*)&currTime);
111 | 	mCurrTime = currTime;
112 | 
113 | 	// Time difference between this frame and the previous.
114 | 	mDeltaTime = (mCurrTime - mPrevTime)*mSecondsPerCount;
115 | 
116 | 	// Prepare for next frame.
117 | 	mPrevTime = mCurrTime;
118 | 
119 | 	// Force nonnegative.  The DXSDK's CDXUTTimer mentions that if the 
120 | 	// processor goes into a power save mode or we get shuffled to another
121 | 	// processor, then mDeltaTime can be negative.
122 | 	if(mDeltaTime < 0.0)
123 | 	{
124 | 		mDeltaTime = 0.0;
125 | 	}
126 | }
127 | 
128 | 


--------------------------------------------------------------------------------
/src/test/common/GameTimer.h:
--------------------------------------------------------------------------------
 1 | //***************************************************************************************
 2 | // GameTimer.h by Frank Luna (C) 2011 All Rights Reserved.
 3 | //***************************************************************************************
 4 | 
 5 | #ifndef GAMETIMER_H
 6 | #define GAMETIMER_H
 7 | 
 8 | class GameTimer
 9 | {
10 | public:
11 | 	GameTimer();
12 | 
13 | 	float TotalTime()const; // in seconds
14 | 	float DeltaTime()const; // in seconds
15 | 
16 | 	void Reset(); // Call before message loop.
17 | 	void Start(); // Call when unpaused.
18 | 	void Stop();  // Call when paused.
19 | 	void Tick();  // Call every frame.
20 | 
21 | private:
22 | 	double mSecondsPerCount;
23 | 	double mDeltaTime;
24 | 
25 | 	__int64 mBaseTime;
26 | 	__int64 mPausedTime;
27 | 	__int64 mStopTime;
28 | 	__int64 mPrevTime;
29 | 	__int64 mCurrTime;
30 | 
31 | 	bool mStopped;
32 | };
33 | 
34 | #endif // GAMETIMER_H


--------------------------------------------------------------------------------
/src/test/common/GeometryGenerator.cpp:
--------------------------------------------------------------------------------
  1 | //***************************************************************************************
  2 | // GeometryGenerator.cpp by Frank Luna (C) 2011 All Rights Reserved.
  3 | //***************************************************************************************
  4 | 
  5 | #include "GeometryGenerator.h"
  6 | #include <algorithm>
  7 | 
  8 | using namespace DirectX;
  9 | 
 10 | GeometryGenerator::MeshData GeometryGenerator::CreateBox(float width, float height, float depth, uint32 numSubdivisions)
 11 | {
 12 |     MeshData meshData;
 13 | 
 14 |     //
 15 | 	// Create the vertices.
 16 | 	//
 17 | 
 18 | 	Vertex v[24];
 19 | 
 20 | 	float w2 = 0.5f*width;
 21 | 	float h2 = 0.5f*height;
 22 | 	float d2 = 0.5f*depth;
 23 |     
 24 | 	// Fill in the front face vertex data.
 25 | 	v[0] = Vertex(-w2, -h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 26 | 	v[1] = Vertex(-w2, +h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
 27 | 	v[2] = Vertex(+w2, +h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
 28 | 	v[3] = Vertex(+w2, -h2, -d2, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
 29 | 
 30 | 	// Fill in the back face vertex data.
 31 | 	v[4] = Vertex(-w2, -h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
 32 | 	v[5] = Vertex(+w2, -h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 33 | 	v[6] = Vertex(+w2, +h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
 34 | 	v[7] = Vertex(-w2, +h2, +d2, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
 35 | 
 36 | 	// Fill in the top face vertex data.
 37 | 	v[8]  = Vertex(-w2, +h2, -d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 38 | 	v[9]  = Vertex(-w2, +h2, +d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
 39 | 	v[10] = Vertex(+w2, +h2, +d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
 40 | 	v[11] = Vertex(+w2, +h2, -d2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
 41 | 
 42 | 	// Fill in the bottom face vertex data.
 43 | 	v[12] = Vertex(-w2, -h2, -d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
 44 | 	v[13] = Vertex(+w2, -h2, -d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 45 | 	v[14] = Vertex(+w2, -h2, +d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
 46 | 	v[15] = Vertex(-w2, -h2, +d2, 0.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);
 47 | 
 48 | 	// Fill in the left face vertex data.
 49 | 	v[16] = Vertex(-w2, -h2, +d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
 50 | 	v[17] = Vertex(-w2, +h2, +d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
 51 | 	v[18] = Vertex(-w2, +h2, -d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
 52 | 	v[19] = Vertex(-w2, -h2, -d2, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);
 53 | 
 54 | 	// Fill in the right face vertex data.
 55 | 	v[20] = Vertex(+w2, -h2, -d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f);
 56 | 	v[21] = Vertex(+w2, +h2, -d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
 57 | 	v[22] = Vertex(+w2, +h2, +d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
 58 | 	v[23] = Vertex(+w2, -h2, +d2, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
 59 | 
 60 | 	meshData.Vertices.assign(&v[0], &v[24]);
 61 |  
 62 | 	//
 63 | 	// Create the indices.
 64 | 	//
 65 | 
 66 | 	uint32 i[36];
 67 | 
 68 | 	// Fill in the front face index data
 69 | 	i[0] = 0; i[1] = 1; i[2] = 2;
 70 | 	i[3] = 0; i[4] = 2; i[5] = 3;
 71 | 
 72 | 	// Fill in the back face index data
 73 | 	i[6] = 4; i[7]  = 5; i[8]  = 6;
 74 | 	i[9] = 4; i[10] = 6; i[11] = 7;
 75 | 
 76 | 	// Fill in the top face index data
 77 | 	i[12] = 8; i[13] =  9; i[14] = 10;
 78 | 	i[15] = 8; i[16] = 10; i[17] = 11;
 79 | 
 80 | 	// Fill in the bottom face index data
 81 | 	i[18] = 12; i[19] = 13; i[20] = 14;
 82 | 	i[21] = 12; i[22] = 14; i[23] = 15;
 83 | 
 84 | 	// Fill in the left face index data
 85 | 	i[24] = 16; i[25] = 17; i[26] = 18;
 86 | 	i[27] = 16; i[28] = 18; i[29] = 19;
 87 | 
 88 | 	// Fill in the right face index data
 89 | 	i[30] = 20; i[31] = 21; i[32] = 22;
 90 | 	i[33] = 20; i[34] = 22; i[35] = 23;
 91 | 
 92 | 	meshData.Indices32.assign(&i[0], &i[36]);
 93 | 
 94 |     // Put a cap on the number of subdivisions.
 95 |     numSubdivisions = std::min<uint32>(numSubdivisions, 6u);
 96 | 
 97 |     for(uint32 i = 0; i < numSubdivisions; ++i)
 98 |         Subdivide(meshData);
 99 | 
100 |     return meshData;
101 | }
102 | 
103 | GeometryGenerator::MeshData GeometryGenerator::CreateSphere(float radius, uint32 sliceCount, uint32 stackCount)
104 | {
105 |     MeshData meshData;
106 | 
107 | 	//
108 | 	// Compute the vertices stating at the top pole and moving down the stacks.
109 | 	//
110 | 
111 | 	// Poles: note that there will be texture coordinate distortion as there is
112 | 	// not a unique point on the texture map to assign to the pole when mapping
113 | 	// a rectangular texture onto a sphere.
114 | 	Vertex topVertex(0.0f, +radius, 0.0f, 0.0f, +1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
115 | 	Vertex bottomVertex(0.0f, -radius, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
116 | 
117 | 	meshData.Vertices.push_back( topVertex );
118 | 
119 | 	float phiStep   = XM_PI/stackCount;
120 | 	float thetaStep = 2.0f*XM_PI/sliceCount;
121 | 
122 | 	// Compute vertices for each stack ring (do not count the poles as rings).
123 | 	for(uint32 i = 1; i <= stackCount-1; ++i)
124 | 	{
125 | 		float phi = i*phiStep;
126 | 
127 | 		// Vertices of ring.
128 |         for(uint32 j = 0; j <= sliceCount; ++j)
129 | 		{
130 | 			float theta = j*thetaStep;
131 | 
132 | 			Vertex v;
133 | 
134 | 			// spherical to cartesian
135 | 			v.Position.x = radius*sinf(phi)*cosf(theta);
136 | 			v.Position.y = radius*cosf(phi);
137 | 			v.Position.z = radius*sinf(phi)*sinf(theta);
138 | 
139 | 			// Partial derivative of P with respect to theta
140 | 			v.TangentU.x = -radius*sinf(phi)*sinf(theta);
141 | 			v.TangentU.y = 0.0f;
142 | 			v.TangentU.z = +radius*sinf(phi)*cosf(theta);
143 | 
144 | 			XMVECTOR T = XMLoadFloat3(&v.TangentU);
145 | 			XMStoreFloat3(&v.TangentU, XMVector3Normalize(T));
146 | 
147 | 			XMVECTOR p = XMLoadFloat3(&v.Position);
148 | 			XMStoreFloat3(&v.Normal, XMVector3Normalize(p));
149 | 
150 | 			v.TexC.x = theta / XM_2PI;
151 | 			v.TexC.y = phi / XM_PI;
152 | 
153 | 			meshData.Vertices.push_back( v );
154 | 		}
155 | 	}
156 | 
157 | 	meshData.Vertices.push_back( bottomVertex );
158 | 
159 | 	//
160 | 	// Compute indices for top stack.  The top stack was written first to the vertex buffer
161 | 	// and connects the top pole to the first ring.
162 | 	//
163 | 
164 |     for(uint32 i = 1; i <= sliceCount; ++i)
165 | 	{
166 | 		meshData.Indices32.push_back(0);
167 | 		meshData.Indices32.push_back(i+1);
168 | 		meshData.Indices32.push_back(i);
169 | 	}
170 | 	
171 | 	//
172 | 	// Compute indices for inner stacks (not connected to poles).
173 | 	//
174 | 
175 | 	// Offset the indices to the index of the first vertex in the first ring.
176 | 	// This is just skipping the top pole vertex.
177 |     uint32 baseIndex = 1;
178 |     uint32 ringVertexCount = sliceCount + 1;
179 | 	for(uint32 i = 0; i < stackCount-2; ++i)
180 | 	{
181 | 		for(uint32 j = 0; j < sliceCount; ++j)
182 | 		{
183 | 			meshData.Indices32.push_back(baseIndex + i*ringVertexCount + j);
184 | 			meshData.Indices32.push_back(baseIndex + i*ringVertexCount + j+1);
185 | 			meshData.Indices32.push_back(baseIndex + (i+1)*ringVertexCount + j);
186 | 
187 | 			meshData.Indices32.push_back(baseIndex + (i+1)*ringVertexCount + j);
188 | 			meshData.Indices32.push_back(baseIndex + i*ringVertexCount + j+1);
189 | 			meshData.Indices32.push_back(baseIndex + (i+1)*ringVertexCount + j+1);
190 | 		}
191 | 	}
192 | 
193 | 	//
194 | 	// Compute indices for bottom stack.  The bottom stack was written last to the vertex buffer
195 | 	// and connects the bottom pole to the bottom ring.
196 | 	//
197 | 
198 | 	// South pole vertex was added last.
199 | 	uint32 southPoleIndex = (uint32)meshData.Vertices.size()-1;
200 | 
201 | 	// Offset the indices to the index of the first vertex in the last ring.
202 | 	baseIndex = southPoleIndex - ringVertexCount;
203 | 	
204 | 	for(uint32 i = 0; i < sliceCount; ++i)
205 | 	{
206 | 		meshData.Indices32.push_back(southPoleIndex);
207 | 		meshData.Indices32.push_back(baseIndex+i);
208 | 		meshData.Indices32.push_back(baseIndex+i+1);
209 | 	}
210 | 
211 |     return meshData;
212 | }
213 |  
214 | void GeometryGenerator::Subdivide(MeshData& meshData)
215 | {
216 | 	// Save a copy of the input geometry.
217 | 	MeshData inputCopy = meshData;
218 | 
219 | 
220 | 	meshData.Vertices.resize(0);
221 | 	meshData.Indices32.resize(0);
222 | 
223 | 	//       v1
224 | 	//       *
225 | 	//      / \
226 | 	//     /   \
227 | 	//  m0*-----*m1
228 | 	//   / \   / \
229 | 	//  /   \ /   \
230 | 	// *-----*-----*
231 | 	// v0    m2     v2
232 | 
233 | 	uint32 numTris = (uint32)inputCopy.Indices32.size()/3;
234 | 	for(uint32 i = 0; i < numTris; ++i)
235 | 	{
236 | 		Vertex v0 = inputCopy.Vertices[ inputCopy.Indices32[i*3+0] ];
237 | 		Vertex v1 = inputCopy.Vertices[ inputCopy.Indices32[i*3+1] ];
238 | 		Vertex v2 = inputCopy.Vertices[ inputCopy.Indices32[i*3+2] ];
239 | 
240 | 		//
241 | 		// Generate the midpoints.
242 | 		//
243 | 
244 |         Vertex m0 = MidPoint(v0, v1);
245 |         Vertex m1 = MidPoint(v1, v2);
246 |         Vertex m2 = MidPoint(v0, v2);
247 | 
248 | 		//
249 | 		// Add new geometry.
250 | 		//
251 | 
252 | 		meshData.Vertices.push_back(v0); // 0
253 | 		meshData.Vertices.push_back(v1); // 1
254 | 		meshData.Vertices.push_back(v2); // 2
255 | 		meshData.Vertices.push_back(m0); // 3
256 | 		meshData.Vertices.push_back(m1); // 4
257 | 		meshData.Vertices.push_back(m2); // 5
258 |  
259 | 		meshData.Indices32.push_back(i*6+0);
260 | 		meshData.Indices32.push_back(i*6+3);
261 | 		meshData.Indices32.push_back(i*6+5);
262 | 
263 | 		meshData.Indices32.push_back(i*6+3);
264 | 		meshData.Indices32.push_back(i*6+4);
265 | 		meshData.Indices32.push_back(i*6+5);
266 | 
267 | 		meshData.Indices32.push_back(i*6+5);
268 | 		meshData.Indices32.push_back(i*6+4);
269 | 		meshData.Indices32.push_back(i*6+2);
270 | 
271 | 		meshData.Indices32.push_back(i*6+3);
272 | 		meshData.Indices32.push_back(i*6+1);
273 | 		meshData.Indices32.push_back(i*6+4);
274 | 	}
275 | }
276 | 
277 | GeometryGenerator::Vertex GeometryGenerator::MidPoint(const Vertex& v0, const Vertex& v1)
278 | {
279 |     XMVECTOR p0 = XMLoadFloat3(&v0.Position);
280 |     XMVECTOR p1 = XMLoadFloat3(&v1.Position);
281 | 
282 |     XMVECTOR n0 = XMLoadFloat3(&v0.Normal);
283 |     XMVECTOR n1 = XMLoadFloat3(&v1.Normal);
284 | 
285 |     XMVECTOR tan0 = XMLoadFloat3(&v0.TangentU);
286 |     XMVECTOR tan1 = XMLoadFloat3(&v1.TangentU);
287 | 
288 |     XMVECTOR tex0 = XMLoadFloat2(&v0.TexC);
289 |     XMVECTOR tex1 = XMLoadFloat2(&v1.TexC);
290 | 
291 |     // Compute the midpoints of all the attributes.  Vectors need to be normalized
292 |     // since linear interpolating can make them not unit length.  
293 |     XMVECTOR pos = 0.5f*(p0 + p1);
294 |     XMVECTOR normal = XMVector3Normalize(0.5f*(n0 + n1));
295 |     XMVECTOR tangent = XMVector3Normalize(0.5f*(tan0+tan1));
296 |     XMVECTOR tex = 0.5f*(tex0 + tex1);
297 | 
298 |     Vertex v;
299 |     XMStoreFloat3(&v.Position, pos);
300 |     XMStoreFloat3(&v.Normal, normal);
301 |     XMStoreFloat3(&v.TangentU, tangent);
302 |     XMStoreFloat2(&v.TexC, tex);
303 | 
304 |     return v;
305 | }
306 | 
307 | GeometryGenerator::MeshData GeometryGenerator::CreateGeosphere(float radius, uint32 numSubdivisions)
308 | {
309 |     MeshData meshData;
310 | 
311 | 	// Put a cap on the number of subdivisions.
312 |     numSubdivisions = std::min<uint32>(numSubdivisions, 6u);
313 | 
314 | 	// Approximate a sphere by tessellating an icosahedron.
315 | 
316 | 	const float X = 0.525731f; 
317 | 	const float Z = 0.850651f;
318 | 
319 | 	XMFLOAT3 pos[12] = 
320 | 	{
321 | 		XMFLOAT3(-X, 0.0f, Z),  XMFLOAT3(X, 0.0f, Z),  
322 | 		XMFLOAT3(-X, 0.0f, -Z), XMFLOAT3(X, 0.0f, -Z),    
323 | 		XMFLOAT3(0.0f, Z, X),   XMFLOAT3(0.0f, Z, -X), 
324 | 		XMFLOAT3(0.0f, -Z, X),  XMFLOAT3(0.0f, -Z, -X),    
325 | 		XMFLOAT3(Z, X, 0.0f),   XMFLOAT3(-Z, X, 0.0f), 
326 | 		XMFLOAT3(Z, -X, 0.0f),  XMFLOAT3(-Z, -X, 0.0f)
327 | 	};
328 | 
329 |     uint32 k[60] =
330 | 	{
331 | 		1,4,0,  4,9,0,  4,5,9,  8,5,4,  1,8,4,    
332 | 		1,10,8, 10,3,8, 8,3,5,  3,2,5,  3,7,2,    
333 | 		3,10,7, 10,6,7, 6,11,7, 6,0,11, 6,1,0, 
334 | 		10,1,6, 11,0,9, 2,11,9, 5,2,9,  11,2,7 
335 | 	};
336 | 
337 |     meshData.Vertices.resize(12);
338 |     meshData.Indices32.assign(&k[0], &k[60]);
339 | 
340 | 	for(uint32 i = 0; i < 12; ++i)
341 | 		meshData.Vertices[i].Position = pos[i];
342 | 
343 | 	for(uint32 i = 0; i < numSubdivisions; ++i)
344 | 		Subdivide(meshData);
345 | 
346 | 	// Project vertices onto sphere and scale.
347 | 	for(uint32 i = 0; i < meshData.Vertices.size(); ++i)
348 | 	{
349 | 		// Project onto unit sphere.
350 | 		XMVECTOR n = XMVector3Normalize(XMLoadFloat3(&meshData.Vertices[i].Position));
351 | 
352 | 		// Project onto sphere.
353 | 		XMVECTOR p = radius*n;
354 | 
355 | 		XMStoreFloat3(&meshData.Vertices[i].Position, p);
356 | 		XMStoreFloat3(&meshData.Vertices[i].Normal, n);
357 | 
358 | 		// Derive texture coordinates from spherical coordinates.
359 |         float theta = atan2f(meshData.Vertices[i].Position.z, meshData.Vertices[i].Position.x);
360 | 
361 |         // Put in [0, 2pi].
362 |         if(theta < 0.0f)
363 |             theta += XM_2PI;
364 | 
365 | 		float phi = acosf(meshData.Vertices[i].Position.y / radius);
366 | 
367 | 		meshData.Vertices[i].TexC.x = theta/XM_2PI;
368 | 		meshData.Vertices[i].TexC.y = phi/XM_PI;
369 | 
370 | 		// Partial derivative of P with respect to theta
371 | 		meshData.Vertices[i].TangentU.x = -radius*sinf(phi)*sinf(theta);
372 | 		meshData.Vertices[i].TangentU.y = 0.0f;
373 | 		meshData.Vertices[i].TangentU.z = +radius*sinf(phi)*cosf(theta);
374 | 
375 | 		XMVECTOR T = XMLoadFloat3(&meshData.Vertices[i].TangentU);
376 | 		XMStoreFloat3(&meshData.Vertices[i].TangentU, XMVector3Normalize(T));
377 | 	}
378 | 
379 |     return meshData;
380 | }
381 | 
382 | GeometryGenerator::MeshData GeometryGenerator::CreateCylinder(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount)
383 | {
384 |     MeshData meshData;
385 | 
386 | 	//
387 | 	// Build Stacks.
388 | 	// 
389 | 
390 | 	float stackHeight = height / stackCount;
391 | 
392 | 	// Amount to increment radius as we move up each stack level from bottom to top.
393 | 	float radiusStep = (topRadius - bottomRadius) / stackCount;
394 | 
395 | 	uint32 ringCount = stackCount+1;
396 | 
397 | 	// Compute vertices for each stack ring starting at the bottom and moving up.
398 | 	for(uint32 i = 0; i < ringCount; ++i)
399 | 	{
400 | 		float y = -0.5f*height + i*stackHeight;
401 | 		float r = bottomRadius + i*radiusStep;
402 | 
403 | 		// vertices of ring
404 | 		float dTheta = 2.0f*XM_PI/sliceCount;
405 | 		for(uint32 j = 0; j <= sliceCount; ++j)
406 | 		{
407 | 			Vertex vertex;
408 | 
409 | 			float c = cosf(j*dTheta);
410 | 			float s = sinf(j*dTheta);
411 | 
412 | 			vertex.Position = XMFLOAT3(r*c, y, r*s);
413 | 
414 | 			vertex.TexC.x = (float)j/sliceCount;
415 | 			vertex.TexC.y = 1.0f - (float)i/stackCount;
416 | 
417 | 			// Cylinder can be parameterized as follows, where we introduce v
418 | 			// parameter that goes in the same direction as the v tex-coord
419 | 			// so that the bitangent goes in the same direction as the v tex-coord.
420 | 			//   Let r0 be the bottom radius and let r1 be the top radius.
421 | 			//   y(v) = h - hv for v in [0,1].
422 | 			//   r(v) = r1 + (r0-r1)v
423 | 			//
424 | 			//   x(t, v) = r(v)*cos(t)
425 | 			//   y(t, v) = h - hv
426 | 			//   z(t, v) = r(v)*sin(t)
427 | 			// 
428 | 			//  dx/dt = -r(v)*sin(t)
429 | 			//  dy/dt = 0
430 | 			//  dz/dt = +r(v)*cos(t)
431 | 			//
432 | 			//  dx/dv = (r0-r1)*cos(t)
433 | 			//  dy/dv = -h
434 | 			//  dz/dv = (r0-r1)*sin(t)
435 | 
436 | 			// This is unit length.
437 | 			vertex.TangentU = XMFLOAT3(-s, 0.0f, c);
438 | 
439 | 			float dr = bottomRadius-topRadius;
440 | 			XMFLOAT3 bitangent(dr*c, -height, dr*s);
441 | 
442 | 			XMVECTOR T = XMLoadFloat3(&vertex.TangentU);
443 | 			XMVECTOR B = XMLoadFloat3(&bitangent);
444 | 			XMVECTOR N = XMVector3Normalize(XMVector3Cross(T, B));
445 | 			XMStoreFloat3(&vertex.Normal, N);
446 | 
447 | 			meshData.Vertices.push_back(vertex);
448 | 		}
449 | 	}
450 | 
451 | 	// Add one because we duplicate the first and last vertex per ring
452 | 	// since the texture coordinates are different.
453 | 	uint32 ringVertexCount = sliceCount+1;
454 | 
455 | 	// Compute indices for each stack.
456 | 	for(uint32 i = 0; i < stackCount; ++i)
457 | 	{
458 | 		for(uint32 j = 0; j < sliceCount; ++j)
459 | 		{
460 | 			meshData.Indices32.push_back(i*ringVertexCount + j);
461 | 			meshData.Indices32.push_back((i+1)*ringVertexCount + j);
462 | 			meshData.Indices32.push_back((i+1)*ringVertexCount + j+1);
463 | 
464 | 			meshData.Indices32.push_back(i*ringVertexCount + j);
465 | 			meshData.Indices32.push_back((i+1)*ringVertexCount + j+1);
466 | 			meshData.Indices32.push_back(i*ringVertexCount + j+1);
467 | 		}
468 | 	}
469 | 
470 | 	BuildCylinderTopCap(bottomRadius, topRadius, height, sliceCount, stackCount, meshData);
471 | 	BuildCylinderBottomCap(bottomRadius, topRadius, height, sliceCount, stackCount, meshData);
472 | 
473 |     return meshData;
474 | }
475 | 
476 | void GeometryGenerator::BuildCylinderTopCap(float bottomRadius, float topRadius, float height,
477 | 											uint32 sliceCount, uint32 stackCount, MeshData& meshData)
478 | {
479 | 	uint32 baseIndex = (uint32)meshData.Vertices.size();
480 | 
481 | 	float y = 0.5f*height;
482 | 	float dTheta = 2.0f*XM_PI/sliceCount;
483 | 
484 | 	// Duplicate cap ring vertices because the texture coordinates and normals differ.
485 | 	for(uint32 i = 0; i <= sliceCount; ++i)
486 | 	{
487 | 		float x = topRadius*cosf(i*dTheta);
488 | 		float z = topRadius*sinf(i*dTheta);
489 | 
490 | 		// Scale down by the height to try and make top cap texture coord area
491 | 		// proportional to base.
492 | 		float u = x/height + 0.5f;
493 | 		float v = z/height + 0.5f;
494 | 
495 | 		meshData.Vertices.push_back( Vertex(x, y, z, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, u, v) );
496 | 	}
497 | 
498 | 	// Cap center vertex.
499 | 	meshData.Vertices.push_back( Vertex(0.0f, y, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f) );
500 | 
501 | 	// Index of center vertex.
502 | 	uint32 centerIndex = (uint32)meshData.Vertices.size()-1;
503 | 
504 | 	for(uint32 i = 0; i < sliceCount; ++i)
505 | 	{
506 | 		meshData.Indices32.push_back(centerIndex);
507 | 		meshData.Indices32.push_back(baseIndex + i+1);
508 | 		meshData.Indices32.push_back(baseIndex + i);
509 | 	}
510 | }
511 | 
512 | void GeometryGenerator::BuildCylinderBottomCap(float bottomRadius, float topRadius, float height,
513 | 											   uint32 sliceCount, uint32 stackCount, MeshData& meshData)
514 | {
515 | 	// 
516 | 	// Build bottom cap.
517 | 	//
518 | 
519 | 	uint32 baseIndex = (uint32)meshData.Vertices.size();
520 | 	float y = -0.5f*height;
521 | 
522 | 	// vertices of ring
523 | 	float dTheta = 2.0f*XM_PI/sliceCount;
524 | 	for(uint32 i = 0; i <= sliceCount; ++i)
525 | 	{
526 | 		float x = bottomRadius*cosf(i*dTheta);
527 | 		float z = bottomRadius*sinf(i*dTheta);
528 | 
529 | 		// Scale down by the height to try and make top cap texture coord area
530 | 		// proportional to base.
531 | 		float u = x/height + 0.5f;
532 | 		float v = z/height + 0.5f;
533 | 
534 | 		meshData.Vertices.push_back( Vertex(x, y, z, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, u, v) );
535 | 	}
536 | 
537 | 	// Cap center vertex.
538 | 	meshData.Vertices.push_back( Vertex(0.0f, y, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.5f, 0.5f) );
539 | 
540 | 	// Cache the index of center vertex.
541 | 	uint32 centerIndex = (uint32)meshData.Vertices.size()-1;
542 | 
543 | 	for(uint32 i = 0; i < sliceCount; ++i)
544 | 	{
545 | 		meshData.Indices32.push_back(centerIndex);
546 | 		meshData.Indices32.push_back(baseIndex + i);
547 | 		meshData.Indices32.push_back(baseIndex + i+1);
548 | 	}
549 | }
550 | 
551 | GeometryGenerator::MeshData GeometryGenerator::CreateGrid(float width, float depth, uint32 m, uint32 n)
552 | {
553 |     MeshData meshData;
554 | 
555 | 	uint32 vertexCount = m*n;
556 | 	uint32 faceCount   = (m-1)*(n-1)*2;
557 | 
558 | 	//
559 | 	// Create the vertices.
560 | 	//
561 | 
562 | 	float halfWidth = 0.5f*width;
563 | 	float halfDepth = 0.5f*depth;
564 | 
565 | 	float dx = width / (n-1);
566 | 	float dz = depth / (m-1);
567 | 
568 | 	float du = 1.0f / (n-1);
569 | 	float dv = 1.0f / (m-1);
570 | 
571 | 	meshData.Vertices.resize(vertexCount);
572 | 	for(uint32 i = 0; i < m; ++i)
573 | 	{
574 | 		float z = halfDepth - i*dz;
575 | 		for(uint32 j = 0; j < n; ++j)
576 | 		{
577 | 			float x = -halfWidth + j*dx;
578 | 
579 | 			meshData.Vertices[i*n+j].Position = XMFLOAT3(x, 0.0f, z);
580 | 			meshData.Vertices[i*n+j].Normal   = XMFLOAT3(0.0f, 1.0f, 0.0f);
581 | 			meshData.Vertices[i*n+j].TangentU = XMFLOAT3(1.0f, 0.0f, 0.0f);
582 | 
583 | 			// Stretch texture over grid.
584 | 			meshData.Vertices[i*n+j].TexC.x = j*du;
585 | 			meshData.Vertices[i*n+j].TexC.y = i*dv;
586 | 		}
587 | 	}
588 |  
589 |     //
590 | 	// Create the indices.
591 | 	//
592 | 
593 | 	meshData.Indices32.resize(faceCount*3); // 3 indices per face
594 | 
595 | 	// Iterate over each quad and compute indices.
596 | 	uint32 k = 0;
597 | 	for(uint32 i = 0; i < m-1; ++i)
598 | 	{
599 | 		for(uint32 j = 0; j < n-1; ++j)
600 | 		{
601 | 			meshData.Indices32[k]   = i*n+j;
602 | 			meshData.Indices32[k+1] = i*n+j+1;
603 | 			meshData.Indices32[k+2] = (i+1)*n+j;
604 | 
605 | 			meshData.Indices32[k+3] = (i+1)*n+j;
606 | 			meshData.Indices32[k+4] = i*n+j+1;
607 | 			meshData.Indices32[k+5] = (i+1)*n+j+1;
608 | 
609 | 			k += 6; // next quad
610 | 		}
611 | 	}
612 | 
613 |     return meshData;
614 | }
615 | 
616 | GeometryGenerator::MeshData GeometryGenerator::CreateQuad(float x, float y, float w, float h, float depth)
617 | {
618 |     MeshData meshData;
619 | 
620 | 	meshData.Vertices.resize(4);
621 | 	meshData.Indices32.resize(6);
622 | 
623 | 	// Position coordinates specified in NDC space.
624 | 	meshData.Vertices[0] = Vertex(
625 |         x, y - h, depth,
626 | 		0.0f, 0.0f, -1.0f,
627 | 		1.0f, 0.0f, 0.0f,
628 | 		0.0f, 1.0f);
629 | 
630 | 	meshData.Vertices[1] = Vertex(
631 | 		x, y, depth,
632 | 		0.0f, 0.0f, -1.0f,
633 | 		1.0f, 0.0f, 0.0f,
634 | 		0.0f, 0.0f);
635 | 
636 | 	meshData.Vertices[2] = Vertex(
637 | 		x+w, y, depth,
638 | 		0.0f, 0.0f, -1.0f,
639 | 		1.0f, 0.0f, 0.0f,
640 | 		1.0f, 0.0f);
641 | 
642 | 	meshData.Vertices[3] = Vertex(
643 | 		x+w, y-h, depth,
644 | 		0.0f, 0.0f, -1.0f,
645 | 		1.0f, 0.0f, 0.0f,
646 | 		1.0f, 1.0f);
647 | 
648 | 	meshData.Indices32[0] = 0;
649 | 	meshData.Indices32[1] = 1;
650 | 	meshData.Indices32[2] = 2;
651 | 
652 | 	meshData.Indices32[3] = 0;
653 | 	meshData.Indices32[4] = 2;
654 | 	meshData.Indices32[5] = 3;
655 | 
656 |     return meshData;
657 | }
658 | 


--------------------------------------------------------------------------------
/src/test/common/GeometryGenerator.h:
--------------------------------------------------------------------------------
  1 | //***************************************************************************************
  2 | // GeometryGenerator.h by Frank Luna (C) 2011 All Rights Reserved.
  3 | //   
  4 | // Defines a static class for procedurally generating the geometry of 
  5 | // common mathematical objects.
  6 | //
  7 | // All triangles are generated "outward" facing.  If you want "inward" 
  8 | // facing triangles (for example, if you want to place the camera inside
  9 | // a sphere to simulate a sky), you will need to:
 10 | //   1. Change the Direct3D cull mode or manually reverse the winding order.
 11 | //   2. Invert the normal.
 12 | //   3. Update the texture coordinates and tangent vectors.
 13 | //***************************************************************************************
 14 | 
 15 | #pragma once
 16 | 
 17 | #include <cstdint>
 18 | #include <DirectXMath.h>
 19 | #include <vector>
 20 | 
 21 | class GeometryGenerator
 22 | {
 23 | public:
 24 | 
 25 |     using uint16 = std::uint16_t;
 26 |     using uint32 = std::uint32_t;
 27 | 
 28 | 	struct Vertex
 29 | 	{
 30 | 		Vertex(){}
 31 |         Vertex(
 32 |             const DirectX::XMFLOAT3& p, 
 33 |             const DirectX::XMFLOAT3& n, 
 34 |             const DirectX::XMFLOAT3& t, 
 35 |             const DirectX::XMFLOAT2& uv) :
 36 |             Position(p), 
 37 |             Normal(n), 
 38 |             TangentU(t), 
 39 |             TexC(uv){}
 40 | 		Vertex(
 41 | 			float px, float py, float pz, 
 42 | 			float nx, float ny, float nz,
 43 | 			float tx, float ty, float tz,
 44 | 			float u, float v) : 
 45 |             Position(px,py,pz), 
 46 |             Normal(nx,ny,nz),
 47 | 			TangentU(tx, ty, tz), 
 48 |             TexC(u,v){}
 49 | 
 50 |         DirectX::XMFLOAT3 Position;
 51 |         DirectX::XMFLOAT3 Normal;
 52 |         DirectX::XMFLOAT3 TangentU;
 53 |         DirectX::XMFLOAT2 TexC;
 54 | 	};
 55 | 
 56 | 	struct MeshData
 57 | 	{
 58 | 		std::vector<Vertex> Vertices;
 59 |         std::vector<uint32> Indices32;
 60 | 
 61 |         std::vector<uint16>& GetIndices16()
 62 |         {
 63 | 			if(mIndices16.empty())
 64 | 			{
 65 | 				mIndices16.resize(Indices32.size());
 66 | 				for(size_t i = 0; i < Indices32.size(); ++i)
 67 | 					mIndices16[i] = static_cast<uint16>(Indices32[i]);
 68 | 			}
 69 | 
 70 | 			return mIndices16;
 71 |         }
 72 | 
 73 | 	private:
 74 | 		std::vector<uint16> mIndices16;
 75 | 	};
 76 | 
 77 | 	///<summary>
 78 | 	/// Creates a box centered at the origin with the given dimensions, where each
 79 |     /// face has m rows and n columns of vertices.
 80 | 	///</summary>
 81 |     MeshData CreateBox(float width, float height, float depth, uint32 numSubdivisions);
 82 | 
 83 | 	///<summary>
 84 | 	/// Creates a sphere centered at the origin with the given radius.  The
 85 | 	/// slices and stacks parameters control the degree of tessellation.
 86 | 	///</summary>
 87 |     MeshData CreateSphere(float radius, uint32 sliceCount, uint32 stackCount);
 88 | 
 89 | 	///<summary>
 90 | 	/// Creates a geosphere centered at the origin with the given radius.  The
 91 | 	/// depth controls the level of tessellation.
 92 | 	///</summary>
 93 |     MeshData CreateGeosphere(float radius, uint32 numSubdivisions);
 94 | 
 95 | 	///<summary>
 96 | 	/// Creates a cylinder parallel to the y-axis, and centered about the origin.  
 97 | 	/// The bottom and top radius can vary to form various cone shapes rather than true
 98 | 	// cylinders.  The slices and stacks parameters control the degree of tessellation.
 99 | 	///</summary>
100 |     MeshData CreateCylinder(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount);
101 | 
102 | 	///<summary>
103 | 	/// Creates an mxn grid in the xz-plane with m rows and n columns, centered
104 | 	/// at the origin with the specified width and depth.
105 | 	///</summary>
106 |     MeshData CreateGrid(float width, float depth, uint32 m, uint32 n);
107 | 
108 | 	///<summary>
109 | 	/// Creates a quad aligned with the screen.  This is useful for postprocessing and screen effects.
110 | 	///</summary>
111 |     MeshData CreateQuad(float x, float y, float w, float h, float depth);
112 | 
113 | private:
114 | 	void Subdivide(MeshData& meshData);
115 |     Vertex MidPoint(const Vertex& v0, const Vertex& v1);
116 |     void BuildCylinderTopCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData);
117 |     void BuildCylinderBottomCap(float bottomRadius, float topRadius, float height, uint32 sliceCount, uint32 stackCount, MeshData& meshData);
118 | };
119 | 
120 | 


--------------------------------------------------------------------------------
/src/test/common/MathHelper.cpp:
--------------------------------------------------------------------------------
 1 | //***************************************************************************************
 2 | // MathHelper.cpp by Frank Luna (C) 2011 All Rights Reserved.
 3 | //***************************************************************************************
 4 | 
 5 | #include "MathHelper.h"
 6 | #include <float.h>
 7 | #include <cmath>
 8 | 
 9 | using namespace DirectX;
10 | 
11 | const float MathHelper::Infinity = FLT_MAX;
12 | const float MathHelper::Pi       = 3.1415926535f;
13 | 
14 | float MathHelper::AngleFromXY(float x, float y)
15 | {
16 | 	float theta = 0.0f;
17 |  
18 | 	// Quadrant I or IV
19 | 	if(x >= 0.0f) 
20 | 	{
21 | 		// If x = 0, then atanf(y/x) = +pi/2 if y > 0
22 | 		//                atanf(y/x) = -pi/2 if y < 0
23 | 		theta = atanf(y / x); // in [-pi/2, +pi/2]
24 | 
25 | 		if(theta < 0.0f)
26 | 			theta += 2.0f*Pi; // in [0, 2*pi).
27 | 	}
28 | 
29 | 	// Quadrant II or III
30 | 	else      
31 | 		theta = atanf(y/x) + Pi; // in [0, 2*pi).
32 | 
33 | 	return theta;
34 | }
35 | 
36 | XMVECTOR MathHelper::RandUnitVec3()
37 | {
38 | 	XMVECTOR One  = XMVectorSet(1.0f, 1.0f, 1.0f, 1.0f);
39 | 	XMVECTOR Zero = XMVectorZero();
40 | 
41 | 	// Keep trying until we get a point on/in the hemisphere.
42 | 	while(true)
43 | 	{
44 | 		// Generate random point in the cube [-1,1]^3.
45 | 		XMVECTOR v = XMVectorSet(MathHelper::RandF(-1.0f, 1.0f), MathHelper::RandF(-1.0f, 1.0f), MathHelper::RandF(-1.0f, 1.0f), 0.0f);
46 | 
47 | 		// Ignore points outside the unit sphere in order to get an even distribution 
48 | 		// over the unit sphere.  Otherwise points will clump more on the sphere near 
49 | 		// the corners of the cube.
50 | 
51 | 		if( XMVector3Greater( XMVector3LengthSq(v), One) )
52 | 			continue;
53 | 
54 | 		return XMVector3Normalize(v);
55 | 	}
56 | }
57 | 
58 | XMVECTOR MathHelper::RandHemisphereUnitVec3(XMVECTOR n)
59 | {
60 | 	XMVECTOR One  = XMVectorSet(1.0f, 1.0f, 1.0f, 1.0f);
61 | 	XMVECTOR Zero = XMVectorZero();
62 | 
63 | 	// Keep trying until we get a point on/in the hemisphere.
64 | 	while(true)
65 | 	{
66 | 		// Generate random point in the cube [-1,1]^3.
67 | 		XMVECTOR v = XMVectorSet(MathHelper::RandF(-1.0f, 1.0f), MathHelper::RandF(-1.0f, 1.0f), MathHelper::RandF(-1.0f, 1.0f), 0.0f);
68 | 
69 | 		// Ignore points outside the unit sphere in order to get an even distribution 
70 | 		// over the unit sphere.  Otherwise points will clump more on the sphere near 
71 | 		// the corners of the cube.
72 | 		
73 | 		if( XMVector3Greater( XMVector3LengthSq(v), One) )
74 | 			continue;
75 | 
76 | 		// Ignore points in the bottom hemisphere.
77 | 		if( XMVector3Less( XMVector3Dot(n, v), Zero ) )
78 | 			continue;
79 | 
80 | 		return XMVector3Normalize(v);
81 | 	}
82 | }


--------------------------------------------------------------------------------
/src/test/common/MathHelper.h:
--------------------------------------------------------------------------------
  1 | //***************************************************************************************
  2 | // MathHelper.h by Frank Luna (C) 2011 All Rights Reserved.
  3 | //
  4 | // Helper math class.
  5 | //***************************************************************************************
  6 | 
  7 | #pragma once
  8 | 
  9 | #include <Windows.h>
 10 | #include <DirectXMath.h>
 11 | #include <cstdint>
 12 | 
 13 | class MathHelper
 14 | {
 15 | public:
 16 | 	// Returns random float in [0, 1).
 17 | 	static float RandF()
 18 | 	{
 19 | 		return (float)(rand()) / (float)RAND_MAX;
 20 | 	}
 21 | 
 22 | 	// Returns random float in [a, b).
 23 | 	static float RandF(float a, float b)
 24 | 	{
 25 | 		return a + RandF()*(b-a);
 26 | 	}
 27 | 
 28 |     static int Rand(int a, int b)
 29 |     {
 30 |         return a + rand() % ((b - a) + 1);
 31 |     }
 32 | 
 33 | 	template<typename T>
 34 | 	static T Min(const T& a, const T& b)
 35 | 	{
 36 | 		return a < b ? a : b;
 37 | 	}
 38 | 
 39 | 	template<typename T>
 40 | 	static T Max(const T& a, const T& b)
 41 | 	{
 42 | 		return a > b ? a : b;
 43 | 	}
 44 | 	 
 45 | 	template<typename T>
 46 | 	static T Lerp(const T& a, const T& b, float t)
 47 | 	{
 48 | 		return a + (b-a)*t;
 49 | 	}
 50 | 
 51 | 	template<typename T>
 52 | 	static T Clamp(const T& x, const T& low, const T& high)
 53 | 	{
 54 | 		return x < low ? low : (x > high ? high : x); 
 55 | 	}
 56 | 
 57 | 	// Returns the polar angle of the point (x,y) in [0, 2*PI).
 58 | 	static float AngleFromXY(float x, float y);
 59 | 
 60 | 	static DirectX::XMVECTOR SphericalToCartesian(float radius, float theta, float phi)
 61 | 	{
 62 | 		return DirectX::XMVectorSet(
 63 | 			radius*sinf(phi)*cosf(theta),
 64 | 			radius*cosf(phi),
 65 | 			radius*sinf(phi)*sinf(theta),
 66 | 			1.0f);
 67 | 	}
 68 | 
 69 |     static DirectX::XMMATRIX InverseTranspose(DirectX::CXMMATRIX M)
 70 | 	{
 71 | 		// Inverse-transpose is just applied to normals.  So zero out 
 72 | 		// translation row so that it doesn't get into our inverse-transpose
 73 | 		// calculation--we don't want the inverse-transpose of the translation.
 74 |         DirectX::XMMATRIX A = M;
 75 |         A.r[3] = DirectX::XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f);
 76 | 
 77 |         DirectX::XMVECTOR det = DirectX::XMMatrixDeterminant(A);
 78 |         return DirectX::XMMatrixTranspose(DirectX::XMMatrixInverse(&det, A));
 79 | 	}
 80 | 
 81 |     static DirectX::XMFLOAT4X4 Identity4x4()
 82 |     {
 83 |         static DirectX::XMFLOAT4X4 I(
 84 |             1.0f, 0.0f, 0.0f, 0.0f,
 85 |             0.0f, 1.0f, 0.0f, 0.0f,
 86 |             0.0f, 0.0f, 1.0f, 0.0f,
 87 |             0.0f, 0.0f, 0.0f, 1.0f);
 88 | 
 89 |         return I;
 90 |     }
 91 | 
 92 |     static DirectX::XMVECTOR RandUnitVec3();
 93 |     static DirectX::XMVECTOR RandHemisphereUnitVec3(DirectX::XMVECTOR n);
 94 | 
 95 | 	static const float Infinity;
 96 | 	static const float Pi;
 97 | 
 98 | 
 99 | };
100 | 
101 | 


--------------------------------------------------------------------------------
/src/test/common/UploadBuffer.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "d3dUtil.h"
 4 | 
 5 | template<typename T>
 6 | class UploadBuffer
 7 | {
 8 | public:
 9 |     // 创建一个上传缓冲区，并把该缓冲区与内存映射，后续可用 CopyData 进行数据更新
10 |     UploadBuffer(ID3D12Device* device, UINT elementCount, bool isConstantBuffer) : 
11 |         mIsConstantBuffer(isConstantBuffer)
12 |     {
13 |         mElementByteSize = sizeof(T);
14 | 
15 |         // Constant buffer elements need to be multiples of 256 bytes.
16 |         // This is because the hardware can only view constant data 
17 |         // at m*256 byte offsets and of n*256 byte lengths. 
18 |         // typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC {
19 |         // UINT64 OffsetInBytes; // multiple of 256
20 |         // UINT   SizeInBytes;   // multiple of 256
21 |         // } D3D12_CONSTANT_BUFFER_VIEW_DESC;
22 |         if(isConstantBuffer)
23 |             mElementByteSize = d3dUtil::CalcConstantBufferByteSize(sizeof(T));
24 | 
25 |         ThrowIfFailed(device->CreateCommittedResource(
26 |             &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD),
27 |             D3D12_HEAP_FLAG_NONE,
28 |             &CD3DX12_RESOURCE_DESC::Buffer(mElementByteSize*elementCount),
29 | 			D3D12_RESOURCE_STATE_GENERIC_READ,
30 |             nullptr,
31 |             IID_PPV_ARGS(&mUploadBuffer)));
32 | 
33 |         ThrowIfFailed(mUploadBuffer->Map(0, nullptr, reinterpret_cast<void**>(&mMappedData)));
34 | 
35 |         // We do not need to unmap until we are done with the resource.  However, we must not write to
36 |         // the resource while it is in use by the GPU (so we must use synchronization techniques).
37 |     }
38 | 
39 |     UploadBuffer(const UploadBuffer& rhs) = delete;
40 |     UploadBuffer& operator=(const UploadBuffer& rhs) = delete;
41 |     ~UploadBuffer()
42 |     {
43 |         if(mUploadBuffer != nullptr)
44 |             mUploadBuffer->Unmap(0, nullptr);
45 | 
46 |         mMappedData = nullptr;
47 |     }
48 | 
49 |     ID3D12Resource* Resource()const
50 |     {
51 |         return mUploadBuffer.Get();
52 |     }
53 | 
54 |     void CopyData(int elementIndex, const T& data)
55 |     {
56 |         memcpy(&mMappedData[elementIndex*mElementByteSize], &data, sizeof(T));
57 |     }
58 | 
59 | private:
60 |     Microsoft::WRL::ComPtr<ID3D12Resource> mUploadBuffer;
61 |     BYTE* mMappedData = nullptr;
62 | 
63 |     UINT mElementByteSize = 0;
64 |     bool mIsConstantBuffer = false;
65 | };


--------------------------------------------------------------------------------
/src/test/common/d3dApp.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Ubpa/UDX12/81b381e50e8dbc1b41fc30e074058e2bef707559/src/test/common/d3dApp.h


--------------------------------------------------------------------------------
/src/test/common/d3dUtil.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "d3dUtil.h"
  3 | #include <comdef.h>
  4 | #include <fstream>
  5 | 
  6 | using Microsoft::WRL::ComPtr;
  7 | 
  8 | bool d3dUtil::IsKeyDown(int vkeyCode)
  9 | {
 10 |     return (GetAsyncKeyState(vkeyCode) & 0x8000) != 0;
 11 | }
 12 | 
 13 | ComPtr<ID3DBlob> d3dUtil::LoadBinary(const std::wstring& filename)
 14 | {
 15 |     std::ifstream fin(filename, std::ios::binary);
 16 | 
 17 |     fin.seekg(0, std::ios_base::end);
 18 |     std::ifstream::pos_type size = (int)fin.tellg();
 19 |     fin.seekg(0, std::ios_base::beg);
 20 | 
 21 |     ComPtr<ID3DBlob> blob;
 22 |     ThrowIfFailed(D3DCreateBlob(size, blob.GetAddressOf()));
 23 | 
 24 |     fin.read((char*)blob->GetBufferPointer(), size);
 25 |     fin.close();
 26 | 
 27 |     return blob;
 28 | }
 29 | 
 30 | Microsoft::WRL::ComPtr<ID3D12Resource> d3dUtil::CreateDefaultBuffer(
 31 |     ID3D12Device* device,
 32 |     ID3D12GraphicsCommandList* cmdList,
 33 |     const void* initData,
 34 |     UINT64 byteSize,
 35 |     Microsoft::WRL::ComPtr<ID3D12Resource>& uploadBuffer)
 36 | {
 37 |     ComPtr<ID3D12Resource> defaultBuffer;
 38 | 
 39 |     // Create the actual default buffer resource.
 40 |     const auto defaultHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT);
 41 |     const auto bufferDesc = CD3DX12_RESOURCE_DESC::Buffer(byteSize);
 42 |     ThrowIfFailed(device->CreateCommittedResource(
 43 |         &defaultHeapProperties,
 44 |         D3D12_HEAP_FLAG_NONE,
 45 |         &bufferDesc,
 46 | 		D3D12_RESOURCE_STATE_COMMON,
 47 |         nullptr,
 48 |         IID_PPV_ARGS(defaultBuffer.GetAddressOf())));
 49 | 
 50 |     // In order to copy CPU memory data into our default buffer, we need to create
 51 |     // an intermediate upload heap. 
 52 |     ThrowIfFailed(device->CreateCommittedResource(
 53 |         &defaultHeapProperties,
 54 | 		D3D12_HEAP_FLAG_NONE,
 55 |         &bufferDesc,
 56 | 		D3D12_RESOURCE_STATE_GENERIC_READ,
 57 |         nullptr,
 58 |         IID_PPV_ARGS(uploadBuffer.GetAddressOf())));
 59 | 
 60 | 
 61 |     // Describe the data we want to copy into the default buffer.
 62 |     D3D12_SUBRESOURCE_DATA subResourceData = {};
 63 |     subResourceData.pData = initData;
 64 |     subResourceData.RowPitch = byteSize;
 65 |     subResourceData.SlicePitch = subResourceData.RowPitch;
 66 | 
 67 |     // Schedule to copy the data to the default buffer resource.  At a high level, the helper function UpdateSubresources
 68 |     // will copy the CPU memory into the intermediate upload heap.  Then, using ID3D12CommandList::CopySubresourceRegion,
 69 |     // the intermediate upload heap data will be copied to mBuffer.
 70 |     DirectX::TransitionResource(cmdList, defaultBuffer.Get(),
 71 |         D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST);
 72 |     UpdateSubresources<1>(cmdList, defaultBuffer.Get(), uploadBuffer.Get(), 0, 0, 1, &subResourceData);
 73 |     DirectX::TransitionResource(cmdList, defaultBuffer.Get(),
 74 |         D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_GENERIC_READ);
 75 | 
 76 |     // Note: uploadBuffer has to be kept alive after the above function calls because
 77 |     // the command list has not been executed yet that performs the actual copy.
 78 |     // The caller can Release the uploadBuffer after it knows the copy has been executed.
 79 | 
 80 | 
 81 |     return defaultBuffer;
 82 | }
 83 | 
 84 | ComPtr<ID3DBlob> d3dUtil::CompileShaderFromFile(
 85 | 	const std::wstring& filename,
 86 | 	const D3D_SHADER_MACRO* defines,
 87 | 	const std::string& entrypoint,
 88 | 	const std::string& target)
 89 | {
 90 | 	UINT compileFlags = 0;
 91 | #if defined(DEBUG) || defined(_DEBUG)  
 92 | 	compileFlags = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
 93 | #endif
 94 | 
 95 | 	HRESULT hr = S_OK;
 96 | 
 97 | 	ComPtr<ID3DBlob> byteCode = nullptr;
 98 | 	ComPtr<ID3DBlob> errors;
 99 | 	hr = D3DCompileFromFile(filename.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE,
100 | 		entrypoint.c_str(), target.c_str(), compileFlags, 0, &byteCode, &errors);
101 | 
102 | 	if(errors != nullptr)
103 | 		OutputDebugStringA((char*)errors->GetBufferPointer());
104 | 
105 | 	ThrowIfFailed(hr);
106 | 
107 | 	return byteCode;
108 | }
109 | 
110 | 


--------------------------------------------------------------------------------
/src/test/common/d3dUtil.h:
--------------------------------------------------------------------------------
  1 | //***************************************************************************************
  2 | // d3dUtil.h by Frank Luna (C) 2015 All Rights Reserved.
  3 | //
  4 | // General helper code.
  5 | //***************************************************************************************
  6 | 
  7 | #pragma once
  8 | 
  9 | #include "MathHelper.h"
 10 | 
 11 | #include <UDX12/_deps/d3dx12.h>
 12 | #include <UDX12/UDX12.h>
 13 | 
 14 | #include <windows.h>
 15 | #include <wrl.h>
 16 | #include <dxgi1_4.h>
 17 | #include <d3d12.h>
 18 | #include <D3Dcompiler.h>
 19 | #include <DirectXMath.h>
 20 | #include <DirectXPackedVector.h>
 21 | #include <DirectXColors.h>
 22 | #include <DirectXCollision.h>
 23 | #include <string>
 24 | #include <memory>
 25 | #include <algorithm>
 26 | #include <vector>
 27 | #include <array>
 28 | #include <unordered_map>
 29 | #include <cstdint>
 30 | #include <fstream>
 31 | #include <sstream>
 32 | #include <cassert>
 33 | 
 34 | extern const int gNumFrameRsrcMngrs;
 35 | 
 36 | inline void d3dSetDebugName(IDXGIObject* obj, const char* name)
 37 | {
 38 |     if(obj)
 39 |     {
 40 |         obj->SetPrivateData(WKPDID_D3DDebugObjectName, lstrlenA(name), name);
 41 |     }
 42 | }
 43 | inline void d3dSetDebugName(ID3D12Device* obj, const char* name)
 44 | {
 45 |     if(obj)
 46 |     {
 47 |         obj->SetPrivateData(WKPDID_D3DDebugObjectName, lstrlenA(name), name);
 48 |     }
 49 | }
 50 | inline void d3dSetDebugName(ID3D12DeviceChild* obj, const char* name)
 51 | {
 52 |     if(obj)
 53 |     {
 54 |         obj->SetPrivateData(WKPDID_D3DDebugObjectName, lstrlenA(name), name);
 55 |     }
 56 | }
 57 | 
 58 | /*
 59 | #if defined(_DEBUG)
 60 |     #ifndef Assert
 61 |     #define Assert(x, description)                                  \
 62 |     {                                                               \
 63 |         static bool ignoreAssert = false;                           \
 64 |         if(!ignoreAssert && !(x))                                   \
 65 |         {                                                           \
 66 |             Debug::AssertResult result = Debug::ShowAssertDialog(   \
 67 |             (L#x), description, AnsiToWString(__FILE__), __LINE__); \
 68 |         if(result == Debug::AssertIgnore)                           \
 69 |         {                                                           \
 70 |             ignoreAssert = true;                                    \
 71 |         }                                                           \
 72 |                     else if(result == Debug::AssertBreak)           \
 73 |         {                                                           \
 74 |             __debugbreak();                                         \
 75 |         }                                                           \
 76 |         }                                                           \
 77 |     }
 78 |     #endif
 79 | #else
 80 |     #ifndef Assert
 81 |     #define Assert(x, description) 
 82 |     #endif
 83 | #endif 		
 84 |     */
 85 | 
 86 | class d3dUtil
 87 | {
 88 | public:
 89 | 
 90 |     static bool IsKeyDown(int vkeyCode);
 91 | 
 92 |     static std::string ToString(HRESULT hr);
 93 | 
 94 |     static UINT CalcConstantBufferByteSize(UINT byteSize)
 95 |     {
 96 |         // Constant buffers must be a multiple of the minimum hardware
 97 |         // allocation size (usually 256 bytes).  So round up to nearest
 98 |         // multiple of 256.  We do this by adding 255 and then masking off
 99 |         // the lower 2 bytes which store all bits < 256.
100 |         // Example: Suppose byteSize = 300.
101 |         // (300 + 255) & ~255
102 |         // 555 & ~255
103 |         // 0x022B & ~0x00ff
104 |         // 0x022B & 0xff00
105 |         // 0x0200
106 |         // 512
107 |         return (byteSize + 255) & ~255;
108 |     }
109 | 
110 |     static Microsoft::WRL::ComPtr<ID3DBlob> LoadBinary(const std::wstring& filename);
111 | 
112 |     static Microsoft::WRL::ComPtr<ID3D12Resource> CreateDefaultBuffer(
113 |         ID3D12Device* device,
114 |         ID3D12GraphicsCommandList* cmdList,
115 |         const void* initData,
116 |         UINT64 byteSize,
117 |         Microsoft::WRL::ComPtr<ID3D12Resource>& uploadBuffer);
118 | 
119 | 	static Microsoft::WRL::ComPtr<ID3DBlob> CompileShaderFromFile(
120 | 		const std::wstring& filename,
121 | 		const D3D_SHADER_MACRO* defines,
122 | 		const std::string& entrypoint,
123 | 		const std::string& target);
124 | };
125 | 
126 | // Defines a subrange of geometry in a MeshGeometry.  This is for when multiple
127 | // geometries are stored in one vertex and index buffer.  It provides the offsets
128 | // and data needed to draw a subset of geometry stores in the vertex and index 
129 | // buffers so that we can implement the technique described by Figure 6.3.
130 | struct SubmeshGeometry
131 | {
132 | 	UINT IndexCount = 0;
133 | 	UINT StartIndexLocation = 0;
134 | 	INT BaseVertexLocation = 0;
135 | 
136 |     // Bounding box of the geometry defined by this submesh. 
137 |     // This is used in later chapters of the book.
138 | 	DirectX::BoundingBox Bounds;
139 | };
140 | 
141 | struct MeshGeometry
142 | {
143 | 	// Give it a name so we can look it up by name.
144 | 	std::string Name;
145 | 
146 | 	// System memory copies.  Use Blobs because the vertex/index format can be generic.
147 | 	// It is up to the client to cast appropriately.  
148 | 	Microsoft::WRL::ComPtr<ID3DBlob> VertexBufferCPU = nullptr;
149 | 	Microsoft::WRL::ComPtr<ID3DBlob> IndexBufferCPU  = nullptr;
150 | 
151 | 	Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferGPU = nullptr;
152 | 	Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferGPU = nullptr;
153 | 
154 | 	Microsoft::WRL::ComPtr<ID3D12Resource> VertexBufferUploader = nullptr;
155 | 	Microsoft::WRL::ComPtr<ID3D12Resource> IndexBufferUploader = nullptr;
156 | 
157 |     // Data about the buffers.
158 | 	UINT VertexByteStride = 0;
159 | 	UINT VertexBufferByteSize = 0;
160 | 	DXGI_FORMAT IndexFormat = DXGI_FORMAT_R16_UINT;
161 | 	UINT IndexBufferByteSize = 0;
162 | 
163 | 	// A MeshGeometry may store multiple geometries in one vertex/index buffer.
164 | 	// Use this container to define the Submesh geometries so we can draw
165 | 	// the Submeshes individually.
166 | 	std::unordered_map<std::string, SubmeshGeometry> DrawArgs;
167 | 
168 | 	D3D12_VERTEX_BUFFER_VIEW VertexBufferView()const
169 | 	{
170 | 		D3D12_VERTEX_BUFFER_VIEW vbv;
171 | 		vbv.BufferLocation = VertexBufferGPU->GetGPUVirtualAddress();
172 | 		vbv.StrideInBytes = VertexByteStride;
173 | 		vbv.SizeInBytes = VertexBufferByteSize;
174 | 
175 | 		return vbv;
176 | 	}
177 | 
178 | 	D3D12_INDEX_BUFFER_VIEW IndexBufferView()const
179 | 	{
180 | 		D3D12_INDEX_BUFFER_VIEW ibv;
181 | 		ibv.BufferLocation = IndexBufferGPU->GetGPUVirtualAddress();
182 | 		ibv.Format = IndexFormat;
183 | 		ibv.SizeInBytes = IndexBufferByteSize;
184 | 
185 | 		return ibv;
186 | 	}
187 | 
188 | 	// We can free this memory after we finish upload to the GPU.
189 | 	void DisposeUploaders()
190 | 	{
191 | 		VertexBufferUploader = nullptr;
192 | 		IndexBufferUploader = nullptr;
193 | 	}
194 | };
195 | 
196 | struct Light
197 | {
198 |     DirectX::XMFLOAT3 Strength = { 0.5f, 0.5f, 0.5f };
199 |     float FalloffStart = 1.0f;                          // point/spot light only
200 |     DirectX::XMFLOAT3 Direction = { 0.0f, -1.0f, 0.0f };// directional/spot light only
201 |     float FalloffEnd = 10.0f;                           // point/spot light only
202 |     DirectX::XMFLOAT3 Position = { 0.0f, 0.0f, 0.0f };  // point/spot light only
203 |     float SpotPower = 64.0f;                            // spot light only
204 | };
205 | 
206 | #define MaxLights 16
207 | 
208 | struct MaterialConstants
209 | {
210 | 	DirectX::XMFLOAT4 DiffuseAlbedo = { 1.0f, 1.0f, 1.0f, 1.0f };
211 | 	DirectX::XMFLOAT3 FresnelR0 = { 0.01f, 0.01f, 0.01f };
212 | 	float Roughness = 0.25f;
213 | 
214 | 	// Used in texture mapping.
215 | 	DirectX::XMFLOAT4X4 MatTransform = MathHelper::Identity4x4();
216 | };
217 | 
218 | // Simple struct to represent a material for our demos.  A production 3D engine
219 | // would likely create a class hierarchy of Materials.
220 | struct Material
221 | {
222 | 	// Unique material name for lookup.
223 | 	std::string Name;
224 | 
225 | 	// Index into constant buffer corresponding to this material.
226 | 	int MatCBIndex = -1;
227 | 
228 | 	// Index into SRV heap for diffuse texture.
229 | 	int DiffuseSrvHeapIndex = -1;
230 | 
231 | 	// Index into SRV heap for normal texture.
232 | 	int NormalSrvHeapIndex = -1;
233 | 
234 | 	// Dirty flag indicating the material has changed and we need to update the constant buffer.
235 | 	// Because we have a material constant buffer for each FrameResource, we have to apply the
236 | 	// update to each FrameResource.  Thus, when we modify a material we should set 
237 | 	// NumFramesDirty = gNumFrameRsrcMngrs so that each frame resource gets the update.
238 | 	int NumFramesDirty = gNumFrameRsrcMngrs;
239 | 
240 | 	// Material constant buffer data used for shading.
241 | 	DirectX::XMFLOAT4 DiffuseAlbedo = { 1.0f, 1.0f, 1.0f, 1.0f };
242 | 	DirectX::XMFLOAT3 FresnelR0 = { 0.01f, 0.01f, 0.01f };
243 | 	float Roughness = .25f;
244 | 	DirectX::XMFLOAT4X4 MatTransform = MathHelper::Identity4x4();
245 | };
246 | 
247 | struct Texture
248 | {
249 | 	// Unique material name for lookup.
250 | 	std::string Name;
251 | 
252 | 	std::wstring Filename;
253 | 
254 | 	Microsoft::WRL::ComPtr<ID3D12Resource> Resource = nullptr;
255 | 	Microsoft::WRL::ComPtr<ID3D12Resource> UploadHeap = nullptr;
256 | };
257 | 
258 | #ifndef ReleaseCom
259 | #define ReleaseCom(x) { if(x){ x->Release(); x = 0; } }
260 | #endif


--------------------------------------------------------------------------------