xyang/unity_native_render_plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
unity_native_render_plugin/NativeRenderPlugin/RenderAPI_D3D12.cpp

1672 lines
68 KiB
C++
Raw Normal View History

init repo
2024-11-01 16:55:46 +08:00
#include "RenderAPI.h"
#include "PlatformBase.h"
// Direct3D 12 implementation of RenderAPI.
#if SUPPORT_D3D12
add qcom afme
2024-11-22 12:09:31 +08:00
#include <cmath>
init repo
2024-11-01 16:55:46 +08:00
#include <assert.h>
#include <dxgi1_6.h>
#include <initguid.h>
#include <d3d12.h>
#include "d3dx12.h"
#include "Unity/IUnityGraphicsD3D12.h"
#include <atomic>
#include <unordered_map>
#include <utility>
#include <map>
#include <iostream>
#define ReturnOnFail(x, hr, OnFailureMsg, onFailureReturnValue) hr = x; if(FAILED(hr)){OutputDebugStringA(OnFailureMsg); return onFailureReturnValue;}
#define D3D12_DEFAULT_HEAP_TRIANGLE_BUFFER_NAME L"Native Plugin Default Heap Triangle Vertex Buffer"
#define D3D12_UPLOAD_HEAP_TRIANGLE_BUFFER_NAME L"Native Plugin Upload Heap Triangle Vertex Buffer"
#define D3D12_UPLOAD_HEAP_TEXTURE_BUFFER_NAME L"Native Plugin Upload Heap Texture"
#define D3D12_UPLOAD_HEAP_VERTEX_BUFFER_NAME L"Native Plugin Upload Heap Vertex Buffer"
// Compiled from:
/*
cbuffer MyCB : register(b0)
{
float4x4 worldMatrix;
}
void VS(float3 pos : POSITION, float4 color : COLOR, out float4 ocolor : COLOR, out float4 opos : SV_Position)
{
opos = mul(worldMatrix, float4(pos, 1));
ocolor = color;
}
float4 PS(float4 color : COLOR) : SV_TARGET
{
return color;
}
*/
// using:
/*
dxc -T vs_6_0 -E VSMain -Fo vertex_shader .\shaders.hlsl -Qstrip_reflect -Qstrip_debug
dxc -T ps_6_0 -E PSMain -Fo pixel_shader .\shaders.hlsl -Qstrip_reflect -Qstrip_debug
*/
const BYTE vertex_shader[] =
{
68,88,66,67,128,57,232,34,242,147,249,9,179,113,162,105,42,26,31,
250,1,0,0,0,109,9,0,0,6,0,0,0,56,0,0,0,72,0,0,
0,167,0,0,0,9,1,0,0,237,1,0,0,9,2,0,0,83,70,73,
48,8,0,0,0,0,0,0,0,0,0,0,0,73,83,71,49,87,0,0,
0,2,0,0,0,8,0,0,0,0,0,0,0,72,0,0,0,0,0,0,
0,0,0,0,0,3,0,0,0,0,0,0,0,7,7,0,0,0,0,0,
0,0,0,0,0,81,0,0,0,0,0,0,0,0,0,0,0,3,0,0,
0,1,0,0,0,15,15,0,0,0,0,0,0,80,79,83,73,84,73,79,
78,0,67,79,76,79,82,0,79,83,71,49,90,0,0,0,2,0,0,0,
8,0,0,0,0,0,0,0,72,0,0,0,0,0,0,0,0,0,0,0,
3,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,
78,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,1,0,0,0,
15,0,0,0,0,0,0,0,67,79,76,79,82,0,83,86,95,80,111,115,
105,116,105,111,110,0,80,83,86,48,220,0,0,0,48,0,0,0,1,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
255,255,1,0,0,0,2,2,0,2,2,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,1,0,0,0,24,0,0,0,2,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,24,0,
0,0,0,80,79,83,73,84,73,79,78,0,67,79,76,79,82,0,67,79,
76,79,82,0,0,0,1,0,0,0,0,0,0,0,16,0,0,0,1,0,
0,0,0,0,0,0,1,0,67,0,3,0,0,0,10,0,0,0,0,0,
0,0,1,1,68,0,3,0,0,0,16,0,0,0,0,0,0,0,1,0,
68,0,3,2,0,0,0,0,0,0,0,0,0,0,1,1,68,3,3,4,
0,0,240,0,0,0,240,0,0,0,240,0,0,0,0,0,0,0,1,0,
0,0,2,0,0,0,4,0,0,0,8,0,0,0,72,65,83,72,20,0,
0,0,0,0,0,0,104,176,13,123,21,10,21,217,124,92,148,133,249,234,
46,114,68,88,73,76,92,7,0,0,96,0,1,0,215,1,0,0,68,88,
73,76,0,1,0,0,16,0,0,0,68,7,0,0,66,67,192,222,33,12,
0,0,206,1,0,0,11,130,32,0,2,0,0,0,19,0,0,0,7,129,
35,145,65,200,4,73,6,16,50,57,146,1,132,12,37,5,8,25,30,4,
139,98,128,20,69,2,66,146,11,66,164,16,50,20,56,8,24,75,10,50,
82,136,72,144,20,32,67,70,136,165,0,25,50,66,228,72,14,144,145,34,
196,80,65,81,129,140,225,131,229,138,4,41,70,6,81,24,0,0,8,0,
0,0,27,140,224,255,255,255,255,7,64,2,168,13,132,240,255,255,255,255,
3,32,109,48,134,255,255,255,255,31,0,9,168,0,73,24,0,0,3,0,
0,0,19,130,96,66,32,76,8,6,0,0,0,0,137,32,0,0,35,0,
0,0,50,34,72,9,32,100,133,4,147,34,164,132,4,147,34,227,132,161,
144,20,18,76,138,140,11,132,164,76,16,104,35,0,37,0,20,102,0,230,
8,192,96,142,0,41,198,32,132,20,66,166,24,128,16,82,6,161,163,134,
203,159,176,135,144,124,110,163,138,149,152,252,226,182,17,49,198,24,84,238,
25,46,127,194,30,66,242,67,160,25,22,2,5,171,16,138,48,66,173,20,
131,140,49,232,205,17,4,197,96,164,16,18,73,14,4,12,35,16,67,18,
212,123,14,71,154,22,0,115,168,201,55,49,110,67,129,165,155,10,4,0,
0,0,19,20,114,192,135,116,96,135,54,104,135,121,104,3,114,192,135,13,
175,80,14,109,208,14,122,80,14,109,0,15,122,48,7,114,160,7,115,32,
7,109,144,14,113,160,7,115,32,7,109,144,14,120,160,7,115,32,7,109,
144,14,113,96,7,122,48,7,114,208,6,233,48,7,114,160,7,115,32,7,
109,144,14,118,64,7,122,96,7,116,208,6,230,16,7,118,160,7,115,32,
7,109,96,14,115,32,7,122,48,7,114,208,6,230,96,7,116,160,7,118,
64,7,109,224,14,120,160,7,113,96,7,122,48,7,114,160,7,118,64,7,
67,158,0,0,0,0,0,0,0,0,0,0,0,134,60,6,16,0,1,0,
0,0,0,0,0,0,12,121,16,32,0,4,0,0,0,0,0,0,0,24,
242,52,64,0,12,0,0,0,0,0,0,0,48,228,121,128,0,8,0,0,
0,0,0,0,0,96,200,35,1,1,48,0,0,0,0,0,0,0,64,22,
8,0,14,0,0,0,50,30,152,20,25,17,76,144,140,9,38,71,198,4,
67,34,37,48,2,80,12,5,24,80,6,229,80,30,84,74,98,4,160,12,
10,161,8,8,207,0,80,30,75,65,16,248,128,15,248,0,2,129,64,0,
0,0,121,24,0,0,87,0,0,0,26,3,76,144,70,2,19,196,49,32,
195,27,67,129,147,75,179,11,163,43,75,1,137,113,185,113,129,113,153,193,
201,177,1,65,129,145,137,49,195,49,155,41,139,73,217,16,4,19,4,194,
152,32,16,199,6,97,32,38,8,4,178,65,24,12,10,118,115,27,6,196,
32,38,8,152,68,96,130,64,36,27,16,66,89,8,98,96,128,13,65,179,
129,0,0,7,152,32,100,211,134,0,154,32,8,0,5,171,41,34,80,79,
83,73,84,73,79,78,19,132,162,153,32,20,206,134,128,152,32,20,207,4,
129,80,38,8,196,178,65,200,180,13,11,65,85,214,101,13,24,97,109,44,
134,158,152,158,164,38,8,5,52,65,32,152,13,66,246,109,88,134,174,178,
46,107,240,6,11,12,54,8,92,24,76,16,138,104,195,66,116,149,117,141,
193,224,17,22,24,112,153,178,250,130,122,155,75,163,75,123,115,219,176,12,
101,80,97,151,55,120,131,5,6,27,4,50,48,131,13,131,24,156,1,176,
161,144,38,52,120,128,42,108,108,118,109,46,105,100,101,110,116,83,130,160,
10,25,158,139,93,153,220,92,218,155,219,148,128,104,66,134,231,98,23,198,
102,87,38,55,37,48,234,144,225,185,204,161,133,145,149,201,53,189,145,149,
177,77,9,144,50,100,120,46,114,101,115,111,117,114,99,101,115,83,2,167,
14,25,158,139,93,90,217,93,18,217,20,93,24,93,217,148,0,170,67,134,
231,82,230,70,39,151,7,245,150,230,70,55,55,37,64,3,0,0,121,24,
0,0,76,0,0,0,51,8,128,28,196,225,28,102,20,1,61,136,67,56,
132,195,140,66,128,7,121,120,7,115,152,113,12,230,0,15,237,16,14,244,
128,14,51,12,66,30,194,193,29,206,161,28,102,48,5,61,136,67,56,132,
131,27,204,3,61,200,67,61,140,3,61,204,120,140,116,112,7,123,8,7,
121,72,135,112,112,7,122,112,3,118,120,135,112,32,135,25,204,17,14,236,
144,14,225,48,15,110,48,15,227,240,14,240,80,14,51,16,196,29,222,33,
28,216,33,29,194,97,30,102,48,137,59,188,131,59,208,67,57,180,3,60,
188,131,60,132,3,59,204,240,20,118,96,7,123,104,7,55,104,135,114,104,
7,55,128,135,112,144,135,112,96,7,118,40,7,118,248,5,118,120,135,119,
128,135,95,8,135,113,24,135,114,152,135,121,152,129,44,238,240,14,238,224,
14,245,192,14,236,48,3,98,200,161,28,228,161,28,204,161,28,228,161,28,
220,97,28,202,33,28,196,129,29,202,97,6,214,144,67,57,200,67,57,152,
67,57,200,67,57,184,195,56,148,67,56,136,3,59,148,195,47,188,131,60,
252,130,59,212,3,59,176,195,12,196,33,7,124,112,3,122,40,135,118,128,
135,25,209,67,14,248,224,6,228,32,14,231,224,6,246,16,14,242,192,14,
225,144,15,239,80,15,244,0,0,0,113,32,0,0,24,0,0,0,6,32,
188,172,13,108,195,229,59,143,47,4,84,81,16,81,233,0,67,73,24,128,
128,249,197,109,91,129,52,92,190,243,248,66,68,0,19,17,2,205,176,16,
22,48,13,151,239,60,254,226,0,131,216,60,212,228,23,183,109,2,213,112,
249,206,227,75,147,19,17,40,53,61,212,228,23,183,109,4,210,112,249,206,
227,79,68,52,33,64,132,249,197,109,3,0,0,0,97,32,0,0,122,0,
0,0,19,4,65,44,16,0,0,0,5,0,0,0,68,138,171,20,10,97,
6,160,236,74,174,8,168,148,0,197,17,0,0,0,35,6,9,0,130,96,
32,97,4,99,89,193,136,65,2,128,32,24,24,29,130,93,208,49,98,144,
0,32,8,6,134,151,100,24,129,140,24,36,0,8,130,129,241,41,90,246,
36,35,6,9,0,130,96,96,128,193,178,105,146,50,98,144,0,32,8,6,
70,24,48,219,70,45,35,6,9,0,130,96,96,136,65,195,113,8,51,98,
144,0,32,8,6,198,24,56,93,55,53,35,6,7,0,130,96,208,136,65,
131,120,163,9,1,48,154,32,4,163,9,131,48,154,64,12,35,6,7,0,
130,96,208,156,129,212,144,193,104,66,0,140,38,8,193,104,194,32,140,38,
16,195,136,193,1,128,32,24,52,108,112,73,213,104,66,0,140,38,8,193,
104,194,32,140,38,16,195,136,193,1,128,32,24,52,113,192,93,106,48,154,
16,0,163,9,66,48,154,48,8,163,9,196,96,211,37,159,17,3,4,0,
65,48,120,236,192,12,158,43,24,49,64,0,16,4,131,231,14,206,96,185,
2,11,14,232,152,181,201,103,196,0,1,64,16,12,30,61,80,3,105,11,
70,12,16,0,4,193,224,217,131,53,112,182,192,2,5,58,150,125,242,25,
49,64,0,16,4,131,199,15,220,160,250,130,17,3,4,0,65,48,120,254,
224,13,162,47,176,160,129,142,113,99,32,159,17,3,4,0,65,48,120,68,
65,14,176,49,8,70,12,16,0,4,193,224,25,133,57,160,198,32,176,0,
130,206,136,65,2,128,32,24,32,167,64,7,163,32,10,123,208,140,24,36,
0,8,130,1,114,10,116,48,10,162,224,6,201,136,65,2,128,32,24,32,
167,64,7,163,32,10,120,80,140,24,36,0,8,130,1,114,10,116,48,10,
162,160,7,193,136,65,2,128,32,24,32,167,64,7,162,32,10,123,176,6,
35,6,9,0,130,96,128,156,2,29,136,130,40,184,129,26,140,24,36,0,
8,130,1,114,10,116,32,10,162,128,7,105,48,98,144,0,32,8,6,200,
41,208,129,40,136,130,30,160,1,2,0,0,0,0
};
const BYTE pixel_shader[] =
{
68,88,66,67,155,38,61,235,152,175,36,0,5,163,174,225,114,25,46,
165,1,0,0,0,48,6,0,0,6,0,0,0,56,0,0,0,72,0,0,
0,126,0,0,0,184,0,0,0,64,1,0,0,92,1,0,0,83,70,73,
48,8,0,0,0,0,0,0,0,0,0,0,0,73,83,71,49,46,0,0,
0,1,0,0,0,8,0,0,0,0,0,0,0,40,0,0,0,0,0,0,
0,0,0,0,0,3,0,0,0,0,0,0,0,15,15,0,0,0,0,0,
0,67,79,76,79,82,0,79,83,71,49,50,0,0,0,1,0,0,0,8,
0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,64,0,0,0,3,
0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,83,86,95,84,97,
114,103,101,116,0,80,83,86,48,128,0,0,0,48,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,
255,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,8,0,0,0,0,67,79,76,79,82,0,
0,1,0,0,0,0,0,0,0,16,0,0,0,1,0,0,0,0,0,0,
0,1,0,68,0,3,2,0,0,0,0,0,0,0,0,0,0,1,0,68,
16,3,0,0,0,1,0,0,0,2,0,0,0,4,0,0,0,8,0,0,
0,72,65,83,72,20,0,0,0,0,0,0,0,12,2,178,107,86,235,87,
236,39,12,117,190,13,71,209,140,68,88,73,76,204,4,0,0,96,0,0,
0,51,1,0,0,68,88,73,76,0,1,0,0,16,0,0,0,180,4,0,
0,66,67,192,222,33,12,0,0,42,1,0,0,11,130,32,0,2,0,0,
0,19,0,0,0,7,129,35,145,65,200,4,73,6,16,50,57,146,1,132,
12,37,5,8,25,30,4,139,98,128,16,69,2,66,146,11,66,132,16,50,
20,56,8,24,75,10,50,66,136,72,144,20,32,67,70,136,165,0,25,50,
66,228,72,14,144,17,34,196,80,65,81,129,140,225,131,229,138,4,33,70,
6,81,24,0,0,6,0,0,0,27,140,224,255,255,255,255,7,64,2,168,
13,132,240,255,255,255,255,3,32,1,0,0,0,73,24,0,0,2,0,0,
0,19,130,96,66,32,0,0,0,137,32,0,0,15,0,0,0,50,34,8,
9,32,100,133,4,19,34,164,132,4,19,34,227,132,161,144,20,18,76,136,
140,11,132,132,76,16,48,35,0,37,0,138,25,128,57,2,48,152,35,64,
138,49,68,84,68,86,12,32,162,26,194,129,128,52,32,0,0,19,20,114,
192,135,116,96,135,54,104,135,121,104,3,114,192,135,13,175,80,14,109,208,
14,122,80,14,109,0,15,122,48,7,114,160,7,115,32,7,109,144,14,113,
160,7,115,32,7,109,144,14,120,160,7,115,32,7,109,144,14,113,96,7,
122,48,7,114,208,6,233,48,7,114,160,7,115,32,7,109,144,14,118,64,
7,122,96,7,116,208,6,230,16,7,118,160,7,115,32,7,109,96,14,115,
32,7,122,48,7,114,208,6,230,96,7,116,160,7,118,64,7,109,224,14,
120,160,7,113,96,7,122,48,7,114,160,7,118,64,7,67,158,0,0,0,
0,0,0,0,0,0,0,0,134,60,6,16,0,1,0,0,0,0,0,0,
0,12,121,16,32,0,4,0,0,0,0,0,0,0,200,2,1,11,0,0,
0,50,30,152,16,25,17,76,144,140,9,38,71,198,4,67,162,18,24,1,
40,134,50,40,15,170,146,24,1,40,130,66,40,16,218,177,12,130,8,4,
2,1,0,0,0,121,24,0,0,65,0,0,0,26,3,76,144,70,2,19,
196,49,32,195,27,67,129,147,75,179,11,163,43,75,1,137,113,185,113,129,
113,153,193,201,177,1,65,129,145,137,49,195,49,155,41,139,73,217,16,4,
19,4,98,152,32,16,196,6,97,32,38,8,68,177,65,24,12,10,112,115,
27,6,196,32,38,8,75,179,33,80,38,8,2,64,1,106,138,197,208,19,
211,147,212,4,161,64,38,8,69,178,33,32,38,8,133,50,65,40,150,9,
2,97,76,16,136,99,131,64,85,27,22,194,121,160,72,26,38,2,178,54,
4,23,147,41,171,47,170,48,185,179,50,186,9,66,193,108,88,136,236,209,
34,104,152,8,200,218,16,108,27,6,140,3,54,20,76,211,1,64,21,54,
54,187,54,151,52,178,50,55,186,41,65,80,133,12,207,197,174,76,110,46,
237,205,109,74,64,52,33,195,115,177,11,99,179,43,147,155,18,24,117,200,
240,92,230,208,194,200,202,228,154,222,200,202,216,166,4,72,29,50,60,23,
187,180,178,187,36,178,41,186,48,186,178,41,129,82,135,12,207,165,204,141,
78,46,15,234,45,205,141,110,110,74,208,1,0,121,24,0,0,76,0,0,
0,51,8,128,28,196,225,28,102,20,1,61,136,67,56,132,195,140,66,128,
7,121,120,7,115,152,113,12,230,0,15,237,16,14,244,128,14,51,12,66,
30,194,193,29,206,161,28,102,48,5,61,136,67,56,132,131,27,204,3,61,
200,67,61,140,3,61,204,120,140,116,112,7,123,8,7,121,72,135,112,112,
7,122,112,3,118,120,135,112,32,135,25,204,17,14,236,144,14,225,48,15,
110,48,15,227,240,14,240,80,14,51,16,196,29,222,33,28,216,33,29,194,
97,30,102,48,137,59,188,131,59,208,67,57,180,3,60,188,131,60,132,3,
59,204,240,20,118,96,7,123,104,7,55,104,135,114,104,7,55,128,135,112,
144,135,112,96,7,118,40,7,118,248,5,118,120,135,119,128,135,95,8,135,
113,24,135,114,152,135,121,152,129,44,238,240,14,238,224,14,245,192,14,236,
48,3,98,200,161,28,228,161,28,204,161,28,228,161,28,220,97,28,202,33,
28,196,129,29,202,97,6,214,144,67,57,200,67,57,152,67,57,200,67,57,
184,195,56,148,67,56,136,3,59,148,195,47,188,131,60,252,130,59,212,3,
59,176,195,12,196,33,7,124,112,3,122,40,135,118,128,135,25,209,67,14,
248,224,6,228,32,14,231,224,6,246,16,14,242,192,14,225,144,15,239,80,
15,244,0,0,0,113,32,0,0,10,0,0,0,6,32,164,172,5,76,195,
229,59,143,191,56,192,32,54,15,53,249,197,109,155,64,53,92,190,243,248,
210,228,68,4,74,77,15,53,249,197,109,3,0,97,32,0,0,30,0,0,
0,19,4,65,44,16,0,0,0,3,0,0,0,68,133,48,3,80,10,84,
37,80,6,0,0,35,6,9,0,130,96,96,72,197,243,40,196,136,65,2,
128,32,24,24,147,1,65,67,49,98,144,0,32,8,6,6,117,68,209,98,
140,24,36,0,8,130,129,81,33,146,68,28,35,6,9,0,130,96,128,84,
199,52,57,196,136,65,2,128,32,24,32,213,49,77,198,48,98,144,0,32,
8,6,72,117,76,83,35,140,24,36,0,8,130,1,82,29,211,84,4,8,
0,0,0,0,0
};
struct Vec3
{
float x;
float y;
float z;
};
struct Vec4
{
float x;
float y;
float z;
float w;
};
struct Vertex
{
Vec3 position;
Vec4 color;
};
static void handle_hr(HRESULT hr, const char* error = "")
{
if (FAILED(hr))
{
OutputDebugStringA(error);
std::cerr << error << "\n";
abort();
}
}
struct D3D12MemoryObject
{
ID3D12Resource* resource;
void* mapped;
D3D12_HEAP_TYPE heapType;
D3D12_RESOURCE_FLAGS resourceFlags;
UINT64 deviceMemorySize;
};
struct D3D12DefaultBufferMemoryObject
{
D3D12MemoryObject uploadResource;
D3D12MemoryObject defaultResource;
};
class RenderAPI_D3D12 : public RenderAPI
{
public:
RenderAPI_D3D12();
virtual ~RenderAPI_D3D12() override { }
virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces) override;
virtual bool GetUsesReverseZ() override { return true; }
//-----------------------------------------------------------
// These functions will be called from unity render thread,
// see kUnityD3D12GraphicsQueueAccess_DontCare
// Demonstrates how to use the CommandRecordingState
virtual void DrawSimpleTriangles(const float worldMatrix[16], int triangleCount, const void* verticesFloat3Byte4) override;
// These demonstrate how to submit work via ExecuteCommandList
virtual void* BeginModifyTexture(void* textureHandle, int textureWidth, int textureHeight, int* outRowPitch) override;
virtual void EndModifyTexture(void* textureHandle, int textureWidth, int textureHeight, int rowPitch, void* dataPtr) override;
virtual void* BeginModifyVertexBuffer(void* bufferHandle, size_t* outBufferSize) override;
virtual void EndModifyVertexBuffer(void* bufferHandle) override;
virtual void drawToRenderTexture() override;
//-----------------------------------------------------------
//-----------------------------------------------------------
// These functions will be called from unity submission thread,
// see kUnityD3D12GraphicsQueueAccess_Allow
// Demonstrates how to submit work to unity command queue
// directly via GetCommandQueue
virtual void drawToPluginTexture() override;
//-----------------------------------------------------------
virtual void* getRenderTexture() override;
virtual void setRenderTextureResource(UnityRenderBuffer rb) override;
virtual bool isSwapChainAvailable() override;
virtual unsigned int getPresentFlags() override;
virtual unsigned int getSyncInterval() override;
virtual unsigned int getBackbufferWidth() override;
virtual unsigned int getBackbufferHeight() override;
private:
UINT64 align_pow2(UINT64 value);
// Aligns texture to power of 2 boundary
UINT64 get_aligned_size(int width, int height, int pixelSize, int rowPitch);
// Creates a new buffer on D3D12_HEAP_TYPE_UPLOAD when resource points to a nullptr.
// When resource points to a existing ID3D12Resource* we only check if it's big enough
// to hold the size, if not return false
bool get_upload_resource(ID3D12Resource** resource, UINT64 size, LPCWSTR name);
// Creates dx12 buffer, if heapType allows CPU-access the resource will be also mapped
bool create_D3D12_buffer(size_t sizeInBytes, D3D12_HEAP_TYPE heapType, D3D12_RESOURCE_FLAGS resourceFlags, D3D12_RESOURCE_STATES initialResourceState, LPCWSTR resourceName, D3D12MemoryObject* buffer);
// Creates two buffers; one on D3D12_HEAP_TYPE_UPLOAD and one on D3D12_HEAP_TYPE_DEFAULT,
// copies contents from initData to -> upload buffer -> default buffer
bool create_D3D12_default_buffer(ID3D12GraphicsCommandList* cmdLst, const void* initData, unsigned int bufferSizeInBytes, LPCWSTR uploadHeapResourceName, LPCWSTR defaultHeapResourceName, D3D12DefaultBufferMemoryObject& outMemoryObj);
ID3D12PipelineState* create_triangle_pipeline();
void create_triangle_input_layout();
bool create_triangle_root_signature();
// Push buffer to deletion queue
void safe_destroy(unsigned long long frameNumber, const D3D12MemoryObject& buffer);
// Processes deletion queue
void garbage_collect(bool force = false);
// Destroy buffer without deletion queue
void immediate_destroy_d3d12_buffer(D3D12MemoryObject& buffer);
// Creates and initializes all resources that are used across multiple frames
void initialize_and_create_resources();
void release_resources();
// Records commands that draw a single triangle to target_texture
void record_draw_cmd_list(ID3D12CommandAllocator* cmd_alloc, ID3D12GraphicsCommandList* cmd, ID3D12RootSignature* rootsig, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, D3D12_VERTEX_BUFFER_VIEW* vbview, const float* world_matrix, D3D12_VIEWPORT* viewport, ID3D12PipelineState* pso, ID3D12Resource* target_texture, D3D12_RESOURCE_STATES target_state);
// Demonstrates how to submit work to unity worker thread via ExecuteCommandList API
UINT64 submit_cmd_to_unity_worker(ID3D12GraphicsCommandList* cmd, UnityGraphicsD3D12ResourceState* resource_states, int state_count);
// Creates a texture that can be used as render target
ID3D12Resource* create_render_texture();
void create_render_texture_rtv(ID3D12DescriptorHeap* desc_heap, ID3D12Resource* target, UINT offset);
void transition_barrier(ID3D12GraphicsCommandList* cmd, ID3D12Resource* resource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after);
// When unity frame fence changes we can be sure that previously submitted command lists have finished executing
void wait_for_unity_frame_fence(UINT64 fence_value);
// Wait on any user provided fence
void wait_on_fence(UINT64 fence_value, ID3D12Fence* fence, HANDLE fence_event);
DXGI_FORMAT typeless_fmt_to_typed(DXGI_FORMAT format);
typedef std::vector<D3D12MemoryObject> D3D12Buffers;
typedef std::map<unsigned long long, D3D12Buffers> DeleteQueue;
typedef std::unordered_map<void*, void*> MappedVertexBuffers;
IUnityGraphicsD3D12v7* s_d3d12;
ID3D12Resource* s_upload_texture;
ID3D12Resource* s_upload_buffer;
ID3D12PipelineState* m_triangle_pso;
D3D12_INPUT_ELEMENT_DESC m_triangle_layout[2];
ID3D12RootSignature* m_triangle_rootsig;
D3D12DefaultBufferMemoryObject m_triangle_vertex_buffer;
ID3D12DescriptorHeap* m_triangle_rtv_desc_heap;
ID3D12DescriptorHeap* m_triangle_dsv_desc_heap;
DeleteQueue m_DeleteQueue;
MappedVertexBuffers m_mapped_triangle_vertex_buffers;
ID3D12DescriptorHeap* m_texture_rtv_desc_heap;
UINT m_texture_rtv_desc_size;
ID3D12Resource* m_render_texture_vertex_buffer;
D3D12_VERTEX_BUFFER_VIEW m_texture_vertex_buffer_view;
std::atomic<ID3D12Resource*> m_render_texture;
std::atomic<ID3D12Resource*> m_plugin_texture;
UINT m_texture_width = 256;
UINT m_texture_height = 256;
ID3D12CommandAllocator* m_render_texture_cmd_allocator;
ID3D12GraphicsCommandList* m_render_texture_cmd_list;
ID3D12CommandAllocator* m_plugin_texture_cmd_allocator;
ID3D12GraphicsCommandList* m_plugin_texture_cmd_list;
ID3DBlob* m_render_texture_root_blob;
ID3D12RootSignature* m_texture_root_sig;
ID3D12PipelineState* m_texture_pso;
std::atomic<bool> m_are_resources_initialized = false;
UINT64 m_plugin_texture_fence_value = 0;
ID3D12Fence* m_plugin_texture_fence;
HANDLE m_plugin_texture_fence_event;
ID3D12CommandAllocator* m_vertex_copy_cmd_allocator;
ID3D12GraphicsCommandList* m_vertex_copy_cmd_list;
ID3D12CommandAllocator* m_texture_copy_cmd_allocator;
ID3D12GraphicsCommandList* m_texture_copy_cmd_list;
UINT64 m_vertex_copy_fence = 0;
UINT64 m_texture_copy_fence = 0;
UINT64 m_render_texture_draw_fence = 0;
HANDLE m_fence_event;
bool m_is_render_texture_created_by_unity = false;
};
RenderAPI* CreateRenderAPI_D3D12()
{
return new RenderAPI_D3D12();
}
const UINT kNodeMask = 0;
RenderAPI_D3D12::RenderAPI_D3D12()
: s_d3d12(NULL)
, s_upload_texture(NULL)
, s_upload_buffer(NULL)
, m_triangle_pso(NULL)
, m_triangle_rootsig(NULL)
, m_triangle_rtv_desc_heap(NULL)
, m_triangle_dsv_desc_heap(NULL)
, m_texture_rtv_desc_heap(NULL)
, m_texture_rtv_desc_size(NULL)
, m_render_texture_vertex_buffer(NULL)
, m_render_texture_cmd_allocator(NULL)
, m_render_texture_cmd_list(NULL)
{
}
UINT64 CalcByteAlignedValue(unsigned int byteSize, unsigned int byteAlignment)
{
UINT byteAlignmentMinusOne = byteAlignment - 2;
return (byteSize + byteAlignmentMinusOne) & ~byteAlignmentMinusOne;
}
UINT64 RenderAPI_D3D12::align_pow2(UINT64 value)
{
UINT64 aligned = static_cast<UINT64>(pow(2, (int)log2(value)));
return aligned >= value ? aligned : aligned * 2;
}
UINT64 RenderAPI_D3D12::get_aligned_size(int width, int height, int pixelSize, int rowPitch)
{
UINT64 size = width * height * pixelSize;
size = align_pow2(size);
if (size < D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT)
{
return D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT;
}
else if (width * pixelSize < rowPitch)
{
return rowPitch * height;
}
else
{
return size;
}
}
bool RenderAPI_D3D12::create_D3D12_default_buffer(ID3D12GraphicsCommandList* cmdLst, const void* initData, unsigned int bufferSizeInBytes, LPCWSTR uploadHeapResourceName, LPCWSTR defaultHeapResourceName, D3D12DefaultBufferMemoryObject& outMemoryObj)
{
if (!cmdLst)
return false;
if (!create_D3D12_buffer(bufferSizeInBytes, D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_GENERIC_READ, uploadHeapResourceName, &outMemoryObj.uploadResource))
return false;
if (!create_D3D12_buffer(bufferSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_COMMON, defaultHeapResourceName, &outMemoryObj.defaultResource))
return false;
ID3D12Resource* uploadResource = outMemoryObj.uploadResource.resource;
ID3D12Resource* defaultResource = outMemoryObj.defaultResource.resource;
D3D12_SUBRESOURCE_DATA subResourceDataDesc;
subResourceDataDesc.pData = initData;
subResourceDataDesc.RowPitch = outMemoryObj.uploadResource.deviceMemorySize;
subResourceDataDesc.SlicePitch = subResourceDataDesc.RowPitch;
transition_barrier(cmdLst, defaultResource, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST);
UpdateSubresources<1>(cmdLst, defaultResource, uploadResource, 0, 0, 1, &subResourceDataDesc);
transition_barrier(cmdLst, defaultResource, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COMMON);
return true;
}
bool RenderAPI_D3D12::create_D3D12_buffer(size_t sizeInBytes, D3D12_HEAP_TYPE heapType, D3D12_RESOURCE_FLAGS resourceFlags, D3D12_RESOURCE_STATES initialResourceState, LPCWSTR resourceName, D3D12MemoryObject* buffer)
{
ID3D12Device* device = s_d3d12->GetDevice();
UINT64 alignedBufferSizeInBytes = CalcByteAlignedValue(static_cast<unsigned int>(sizeInBytes), 256);
HRESULT hr = S_OK;
CD3DX12_HEAP_PROPERTIES heap_props = CD3DX12_HEAP_PROPERTIES(heapType);
CD3DX12_RESOURCE_DESC resource_desc = CD3DX12_RESOURCE_DESC::Buffer(alignedBufferSizeInBytes, resourceFlags);
ReturnOnFail(
device->CreateCommittedResource(
&heap_props,
D3D12_HEAP_FLAG_NONE,
&resource_desc,
initialResourceState,
NULL,
IID_PPV_ARGS(&buffer->resource)),
hr,
"CreateD3D12Buffer Failed\n",
false
);
if (heapType == D3D12_HEAP_TYPE_UPLOAD)
{
hr = buffer->resource->Map(0, NULL, &buffer->mapped);
if (FAILED(hr))
{
OutputDebugStringA("Failed to map buffer.\n");
buffer->resource->Release();
buffer->resource = NULL;
return false;
}
}
else
buffer->mapped = NULL;
buffer->heapType = heapType;
buffer->resourceFlags = resourceFlags;
buffer->deviceMemorySize = alignedBufferSizeInBytes;
buffer->resourceFlags = resourceFlags;
if (resourceName != NULL)
buffer->resource->SetName(resourceName);
return true;
}
void RenderAPI_D3D12::create_triangle_input_layout()
{
m_triangle_layout[0] = D3D12_INPUT_ELEMENT_DESC(
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
);
m_triangle_layout[1] = D3D12_INPUT_ELEMENT_DESC(
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
);
}
bool RenderAPI_D3D12::create_triangle_root_signature()
{
HRESULT hr = S_OK;
CD3DX12_ROOT_PARAMETER slotRootParameter[1];
slotRootParameter[0].InitAsConstants(64, 0, 0, D3D12_SHADER_VISIBILITY_ALL);
CD3DX12_ROOT_SIGNATURE_DESC rsDesc(1, slotRootParameter, 0, NULL, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
ID3DBlob* serializedRootSigBlob = NULL;
ID3DBlob* errorBlob = NULL;
ReturnOnFail(
D3D12SerializeRootSignature(&rsDesc, D3D_ROOT_SIGNATURE_VERSION_1, &serializedRootSigBlob, &errorBlob),
hr,
"D3D12SerializeRootSignature Failed\n",
false
);
ID3D12Device* device = s_d3d12->GetDevice();
ReturnOnFail(
device->CreateRootSignature(0, serializedRootSigBlob->GetBufferPointer(), serializedRootSigBlob->GetBufferSize(), __uuidof(ID3D12RootSignature), reinterpret_cast<void**>(&m_triangle_rootsig)); ,
hr,
"CreateRootSignature Failed\n",
false
);
return true;
}
ID3D12PipelineState* RenderAPI_D3D12::create_triangle_pipeline()
{
HRESULT hr = S_OK;
if (!create_triangle_root_signature())
return NULL;
create_triangle_input_layout();
D3D12_GRAPHICS_PIPELINE_STATE_DESC desc;
ZeroMemory(&desc, sizeof(D3D12_GRAPHICS_PIPELINE_STATE_DESC));
desc.InputLayout = { m_triangle_layout, 2 };
desc.pRootSignature = m_triangle_rootsig;
desc.VS = {
vertex_shader,
sizeof(vertex_shader)
};
desc.PS = {
pixel_shader,
sizeof(pixel_shader)
};
desc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT);
desc.RasterizerState.MultisampleEnable = true;
desc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
desc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
desc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
desc.DepthStencilState = CD3DX12_DEPTH_STENCIL_DESC(D3D12_DEFAULT);
desc.DepthStencilState.DepthEnable = true;
desc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; // Unity uses reverse z depth
desc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_GREATER_EQUAL;
desc.SampleMask = UINT_MAX;
desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
desc.NumRenderTargets = 1;
desc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.DSVFormat = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
ID3D12Device* device = s_d3d12->GetDevice();
ReturnOnFail(
device->CreateGraphicsPipelineState(&desc, __uuidof(ID3D12PipelineState), reinterpret_cast<void**>(&m_triangle_pso)),
hr,
"CreateGraphicsPipelineState Failed\n",
NULL
);
return m_triangle_pso;
}
bool RenderAPI_D3D12::get_upload_resource(ID3D12Resource** outResource, UINT64 size, LPCWSTR name)
{
ID3D12Resource*& resource = *outResource;
if (resource)
{
D3D12_RESOURCE_DESC desc = resource->GetDesc();
if (desc.Width == size)
return true;
else
{
resource->Release();
return false;
}
}
// Texture upload buffer
D3D12_HEAP_PROPERTIES heapProps = {};
heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = kNodeMask;
heapProps.VisibleNodeMask = kNodeMask;
D3D12_RESOURCE_DESC heapDesc = {};
heapDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
heapDesc.Alignment = 0;
heapDesc.Width = size;
heapDesc.Height = 1;
heapDesc.DepthOrArraySize = 1;
heapDesc.MipLevels = 1;
heapDesc.Format = DXGI_FORMAT_UNKNOWN;
heapDesc.SampleDesc.Count = 1;
heapDesc.SampleDesc.Quality = 0;
heapDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
heapDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
HRESULT hr = S_OK;
ID3D12Device* device = s_d3d12->GetDevice();
ReturnOnFail(
device->CreateCommittedResource(
&heapProps,
D3D12_HEAP_FLAG_NONE,
&heapDesc,
D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr,
IID_PPV_ARGS(&resource)),
hr,
"CreateCommittedResource Failed\n",
false
);
if (name != NULL)
resource->SetName(name);
return true;
}
void RenderAPI_D3D12::ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces)
{
switch (type)
{
case kUnityGfxDeviceEventInitialize:
s_d3d12 = interfaces->Get<IUnityGraphicsD3D12v7>();
UnityD3D12PluginEventConfig config_1;
config_1.graphicsQueueAccess = kUnityD3D12GraphicsQueueAccess_DontCare;
config_1.flags = kUnityD3D12EventConfigFlag_SyncWorkerThreads | kUnityD3D12EventConfigFlag_ModifiesCommandBuffersState | kUnityD3D12EventConfigFlag_EnsurePreviousFrameSubmission;
config_1.ensureActiveRenderTextureIsBound = true;
s_d3d12->ConfigureEvent(1, &config_1);
UnityD3D12PluginEventConfig config_2;
config_2.graphicsQueueAccess = kUnityD3D12GraphicsQueueAccess_Allow;
config_2.flags = kUnityD3D12EventConfigFlag_SyncWorkerThreads | kUnityD3D12EventConfigFlag_ModifiesCommandBuffersState | kUnityD3D12EventConfigFlag_EnsurePreviousFrameSubmission;
config_2.ensureActiveRenderTextureIsBound = false;
s_d3d12->ConfigureEvent(2, &config_2);
initialize_and_create_resources();
break;
case kUnityGfxDeviceEventShutdown:
release_resources();
break;
}
}
void RenderAPI_D3D12::DrawSimpleTriangles(const float worldMatrix[16], int triangleCount, const void* verticesFloat3Byte4)
{
UnityGraphicsD3D12RecordingState recordingState;
if (!s_d3d12->CommandRecordingState(&recordingState))
return;
if (m_triangle_pso == NULL)
{
m_triangle_pso = create_triangle_pipeline();
}
if (m_triangle_pso != NULL)
{
ID3D12GraphicsCommandList* cmdLst = recordingState.commandList;
garbage_collect();
const int kVertexSize = 12 + 4; // 12 bytes for position and 4 bytes for color
const UINT vertexBufferSizeInBytes = kVertexSize * 3 * triangleCount;
if (!create_D3D12_default_buffer(cmdLst, verticesFloat3Byte4, vertexBufferSizeInBytes, D3D12_UPLOAD_HEAP_TRIANGLE_BUFFER_NAME, D3D12_DEFAULT_HEAP_TRIANGLE_BUFFER_NAME, m_triangle_vertex_buffer))
return;
cmdLst->SetPipelineState(m_triangle_pso);
cmdLst->SetGraphicsRootSignature(m_triangle_rootsig);
cmdLst->SetGraphicsRoot32BitConstants(0, 64, worldMatrix, 0);
D3D12_VERTEX_BUFFER_VIEW vbView;
vbView.BufferLocation = m_triangle_vertex_buffer.defaultResource.resource->GetGPUVirtualAddress();
vbView.SizeInBytes = vertexBufferSizeInBytes;
vbView.StrideInBytes = kVertexSize;
cmdLst->IASetVertexBuffers(0, 1, &vbView);
cmdLst->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
cmdLst->DrawInstanced(triangleCount * 3, 1, 0, 0);
UINT64 nextval = s_d3d12->GetNextFrameFenceValue();
ID3D12Fence* fence = s_d3d12->GetFrameFence();
UINT64 lastCompletedFenceValue = fence->GetCompletedValue();
lastCompletedFenceValue += 3;
safe_destroy(lastCompletedFenceValue, m_triangle_vertex_buffer.uploadResource);
safe_destroy(lastCompletedFenceValue, m_triangle_vertex_buffer.defaultResource);
}
}
void RenderAPI_D3D12::safe_destroy(unsigned long long frameNumber, const D3D12MemoryObject& buffer)
{
m_DeleteQueue[frameNumber].push_back(buffer);
}
void RenderAPI_D3D12::garbage_collect(bool force /*= false*/)
{
ID3D12Fence* fence = s_d3d12->GetFrameFence();
UINT64 lastCompletedFenceValue = fence->GetCompletedValue();
DeleteQueue::iterator it = m_DeleteQueue.begin();
while (it != m_DeleteQueue.end())
{
if (force || it->first <= lastCompletedFenceValue)
{
for (size_t i = 0; i < it->second.size(); ++i)
immediate_destroy_d3d12_buffer(it->second[i]);
m_DeleteQueue.erase(it++);
}
else
++it;
}
}
void RenderAPI_D3D12::immediate_destroy_d3d12_buffer(D3D12MemoryObject& buffer)
{
if (buffer.resource == NULL)
return;
if (buffer.mapped)
{
buffer.resource->Unmap(0, NULL);
buffer.mapped = 0;
}
SAFE_RELEASE(buffer.resource);
}
void RenderAPI_D3D12::initialize_and_create_resources()
{
if (m_are_resources_initialized)
return;
ID3D12Device* device = s_d3d12->GetDevice();
assert(device != nullptr);
UnityGraphicsD3D12PhysicalVideoMemoryControlValues control_values;
control_values.reservation = 64000000;
control_values.systemMemoryThreshold = 64000000;
control_values.residencyHysteresisThreshold = 128000000;
control_values.nonEvictableRelativeThreshold = 0.25;
s_d3d12->SetPhysicalVideoMemoryControlValues(&control_values);
constexpr Vertex vertices[] {
// position color
// <---------------> <-------------------->
{{ 0.0f, 1.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
{{ 1.0f, -1.0f, 0.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
{{ -1.0f, -1.0f, 0.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
};
D3D12_INPUT_ELEMENT_DESC position = {};
position.SemanticName = "POSITION";
position.SemanticIndex = 0;
position.Format = DXGI_FORMAT_R32G32B32_FLOAT;
position.AlignedByteOffset = 0;
position.InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
position.InstanceDataStepRate = 0;
D3D12_INPUT_ELEMENT_DESC color = {};
color.SemanticName = "COLOR";
color.SemanticIndex = 0;
color.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
color.AlignedByteOffset = 12;
color.InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
color.InstanceDataStepRate = 0;
D3D12_INPUT_ELEMENT_DESC input_element_desc[] = {position, color};
D3D12_RESOURCE_DESC vertex_buffer_desc = {};
vertex_buffer_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
vertex_buffer_desc.Alignment = 0;
vertex_buffer_desc.Width = sizeof(vertices);
vertex_buffer_desc.Height = 1;
vertex_buffer_desc.DepthOrArraySize = 1;
vertex_buffer_desc.MipLevels = 1;
vertex_buffer_desc.Format = DXGI_FORMAT_UNKNOWN;
vertex_buffer_desc.SampleDesc.Count = 1;
vertex_buffer_desc.SampleDesc.Quality = 0;
vertex_buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
vertex_buffer_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
D3D12_HEAP_PROPERTIES vertex_buffer_heap_props = {};
vertex_buffer_heap_props.Type = D3D12_HEAP_TYPE_UPLOAD;
vertex_buffer_heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
vertex_buffer_heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
vertex_buffer_heap_props.CreationNodeMask = 1;
vertex_buffer_heap_props.VisibleNodeMask = 1;
handle_hr(device->CreateCommittedResource(&vertex_buffer_heap_props, D3D12_HEAP_FLAG_NONE, &vertex_buffer_desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_render_texture_vertex_buffer)),
"Failed to create vertex buffer for render texture\n");
char* data;
D3D12_RANGE read_range{ 0, 0 };
handle_hr(m_render_texture_vertex_buffer->Map(0, &read_range, reinterpret_cast<void**>(&data)));
memcpy(data, vertices, sizeof(vertices));
m_render_texture_vertex_buffer->Unmap(0, nullptr);
m_texture_vertex_buffer_view = {};
m_texture_vertex_buffer_view.BufferLocation = m_render_texture_vertex_buffer->GetGPUVirtualAddress();
m_texture_vertex_buffer_view.SizeInBytes = sizeof(vertices);
m_texture_vertex_buffer_view.StrideInBytes = sizeof(Vertex);
// 1st descriptor is for m_render_texture and 2nd one is for m_plugin_texture
D3D12_DESCRIPTOR_HEAP_DESC rtv_heap_desc = {};
rtv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtv_heap_desc.NumDescriptors = 2;
rtv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
rtv_heap_desc.NodeMask = 0;
handle_hr(device->CreateDescriptorHeap(&rtv_heap_desc, IID_PPV_ARGS(&m_texture_rtv_desc_heap)),
"Failed to create descriptor heap for render texture RTVs\n");
m_texture_rtv_desc_size = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
// When Unity does create it's own RenderBuffer and passes it to the plugin
// using setRenderTexture() we don't have to create one here.
if (!m_is_render_texture_created_by_unity)
m_render_texture = create_render_texture();
m_plugin_texture = create_render_texture();
create_render_texture_rtv(m_texture_rtv_desc_heap, m_render_texture, 0);
create_render_texture_rtv(m_texture_rtv_desc_heap, m_plugin_texture, 1);
m_render_texture.load()->SetName(L"plugin render texture\n");
// we store the world matrix in the root signature
D3D12_ROOT_CONSTANTS root_constants = {};
root_constants.ShaderRegister = 0;
root_constants.RegisterSpace = 0;
root_constants.Num32BitValues = 64; // maximum size for root sig
D3D12_ROOT_PARAMETER root_param = {};
root_param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
root_param.Constants = root_constants;
root_param.ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX;
D3D12_ROOT_SIGNATURE_DESC root_signature_desc = {};
root_signature_desc.NumParameters = 1;
root_signature_desc.pParameters = &root_param;
root_signature_desc.NumStaticSamplers = 0;
root_signature_desc.pStaticSamplers = nullptr;
root_signature_desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
handle_hr(D3D12SerializeRootSignature(&root_signature_desc, D3D_ROOT_SIGNATURE_VERSION_1, &m_render_texture_root_blob, nullptr),
"Failed to serialize root signature for render texture\n");
handle_hr(device->CreateRootSignature(0, m_render_texture_root_blob->GetBufferPointer(), m_render_texture_root_blob->GetBufferSize(), IID_PPV_ARGS(&m_texture_root_sig)),
"Failed to create root signature for render texture\n");
D3D12_RASTERIZER_DESC rasterizer_desc = {};
rasterizer_desc.FillMode = D3D12_FILL_MODE_SOLID;
rasterizer_desc.CullMode = D3D12_CULL_MODE_NONE;
rasterizer_desc.FrontCounterClockwise = FALSE;
rasterizer_desc.DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
rasterizer_desc.DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
rasterizer_desc.SlopeScaledDepthBias = 0;
rasterizer_desc.MultisampleEnable = FALSE;
rasterizer_desc.MultisampleEnable = FALSE;
rasterizer_desc.AntialiasedLineEnable = FALSE;
rasterizer_desc.ForcedSampleCount = 0;
rasterizer_desc.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
D3D12_RENDER_TARGET_BLEND_DESC render_target_blend_desc = {};
render_target_blend_desc.BlendEnable = FALSE;
render_target_blend_desc.LogicOpEnable = FALSE;
render_target_blend_desc.SrcBlend = D3D12_BLEND_ONE;
render_target_blend_desc.DestBlend = D3D12_BLEND_ZERO;
render_target_blend_desc.BlendOp = D3D12_BLEND_OP_ADD;
render_target_blend_desc.SrcBlendAlpha = D3D12_BLEND_ONE;
render_target_blend_desc.DestBlendAlpha = D3D12_BLEND_ZERO;
render_target_blend_desc.BlendOpAlpha = D3D12_BLEND_OP_ADD;
render_target_blend_desc.LogicOp = D3D12_LOGIC_OP_NOOP;
render_target_blend_desc.RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
D3D12_BLEND_DESC blend_desc = {};
blend_desc.AlphaToCoverageEnable = FALSE;
blend_desc.IndependentBlendEnable = FALSE;
blend_desc.RenderTarget[0] = render_target_blend_desc;
D3D12_DEPTH_STENCIL_DESC depth_stencil_desc = {};
depth_stencil_desc.DepthEnable = FALSE;
depth_stencil_desc.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ZERO;
depth_stencil_desc.DepthFunc = D3D12_COMPARISON_FUNC_NEVER;
depth_stencil_desc.StencilEnable = FALSE;
D3D12_SHADER_BYTECODE vertex_bytecode = {};
vertex_bytecode.pShaderBytecode = (void*)(vertex_shader);
vertex_bytecode.BytecodeLength = sizeof(vertex_shader);
D3D12_SHADER_BYTECODE pixel_bytecode = {};
pixel_bytecode.pShaderBytecode = (void*)(pixel_shader);
pixel_bytecode.BytecodeLength = sizeof(pixel_shader);
D3D12_INPUT_LAYOUT_DESC input_layout_desc = {};
input_layout_desc.pInputElementDescs = input_element_desc;
input_layout_desc.NumElements = _countof(input_element_desc);
DXGI_SAMPLE_DESC dxgi_sample_desc = {};
dxgi_sample_desc.Count = 1;
dxgi_sample_desc.Quality = 0;
D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc = {};
pso_desc.pRootSignature = m_texture_root_sig;
pso_desc.VS = vertex_bytecode;
pso_desc.PS = pixel_bytecode;
pso_desc.DS = { nullptr, 0 };
pso_desc.HS = { nullptr, 0 };
pso_desc.GS = { nullptr, 0 };
pso_desc.StreamOutput = {};
pso_desc.BlendState = blend_desc;
pso_desc.SampleMask = 1;
pso_desc.RasterizerState = rasterizer_desc;
pso_desc.DepthStencilState = depth_stencil_desc;
pso_desc.InputLayout = input_layout_desc;
pso_desc.IBStripCutValue = {};
pso_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pso_desc.NumRenderTargets = 1;
pso_desc.RTVFormats[0] = {DXGI_FORMAT_R8G8B8A8_UNORM};
pso_desc.DSVFormat = {};
pso_desc.SampleDesc = dxgi_sample_desc;
pso_desc.NodeMask = 0;
pso_desc.CachedPSO = { nullptr, 0 };
pso_desc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
handle_hr(device->CreateGraphicsPipelineState(&pso_desc, IID_PPV_ARGS(&m_texture_pso)),
"Failed to create PSO for render texture\n");
handle_hr(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_render_texture_cmd_allocator)),
"Failed to create cmd allocator for render texture\n");
handle_hr(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_render_texture_cmd_allocator, nullptr, IID_PPV_ARGS(&m_render_texture_cmd_list)),
"Failed to create cmd list for render texture\n");
handle_hr(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_plugin_texture_cmd_allocator)),
"Failed to create cmd allocator for plugin texture\n");
handle_hr(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_plugin_texture_cmd_allocator, nullptr, IID_PPV_ARGS(&m_plugin_texture_cmd_list)),
"Failed to create cmd list for render texture2\n");
handle_hr(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_texture_copy_cmd_allocator)),
"Failed to create cmd allocator for texture copy\n");
handle_hr(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_vertex_copy_cmd_allocator)),
"Failed to create cmd allocator for vertex copy\n");
handle_hr(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_texture_copy_cmd_allocator, nullptr, IID_PPV_ARGS(&m_texture_copy_cmd_list)),
"Failed to create texture copy cmd list\n");
handle_hr(device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_vertex_copy_cmd_allocator, nullptr, IID_PPV_ARGS(&m_vertex_copy_cmd_list)),
"Failed to create vertex copy cmd list\n");
handle_hr(device->CreateFence(m_plugin_texture_fence_value, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_plugin_texture_fence)),
"Failed to create fence for plugin texture");
m_texture_copy_cmd_allocator->SetName(L"texture copy cmd allocator");
m_vertex_copy_cmd_allocator->SetName(L"vertex copy cmd allocator");
m_render_texture_cmd_allocator->SetName(L"render texture cmd allocator");
m_vertex_copy_cmd_list->SetName(L"vertex copy cmd list");
m_texture_copy_cmd_list->SetName(L"texture copy cmd list");
m_render_texture_cmd_list->SetName(L"render texture cmd list");
handle_hr(m_vertex_copy_cmd_list->Close(), "Failed to close cmd list for vertex copy\n");
handle_hr(m_texture_copy_cmd_list->Close(), "Failed to close cmd list for texture copy\n");
handle_hr(m_render_texture_cmd_list->Close(), "Failed to close cmd list for render texture\n");
handle_hr(m_plugin_texture_cmd_list->Close(), "Failed to close cmd list for plugin texture\n");
m_fence_event = CreateEvent(NULL, false, false, nullptr);
m_plugin_texture_fence_event = CreateEvent(NULL, false, false, nullptr);
D3D12_DESCRIPTOR_HEAP_DESC rtvDesc = {};
rtvDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
rtvDesc.NumDescriptors = 1;
rtvDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
rtvDesc.NodeMask = 0;
handle_hr(device->CreateDescriptorHeap(&rtvDesc, IID_PPV_ARGS(&m_triangle_rtv_desc_heap)),
"CreateDescriptorHeap Failed\n");
D3D12_DESCRIPTOR_HEAP_DESC dsvDesc = {};
dsvDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
dsvDesc.NumDescriptors = 1;
dsvDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
dsvDesc.NodeMask = 0;
handle_hr(device->CreateDescriptorHeap(&dsvDesc, IID_PPV_ARGS(&m_triangle_dsv_desc_heap)),
"CreateDescriptorHeap Failed\n");
m_are_resources_initialized = true;
}
void RenderAPI_D3D12::release_resources()
{
SAFE_RELEASE(m_render_texture_cmd_list);
SAFE_RELEASE(m_render_texture_cmd_allocator);
SAFE_RELEASE(m_plugin_texture_cmd_list);
SAFE_RELEASE(m_plugin_texture_cmd_allocator);
SAFE_RELEASE(m_texture_pso);
SAFE_RELEASE(m_texture_root_sig);
SAFE_RELEASE(m_render_texture_root_blob);
SAFE_RELEASE(m_texture_rtv_desc_heap);
if (!m_is_render_texture_created_by_unity)
{
ID3D12Resource* render_texture = m_render_texture.load();
if (render_texture)
{
render_texture->Release();
m_render_texture = nullptr;
}
}
SAFE_RELEASE(m_render_texture_vertex_buffer);
SAFE_RELEASE(m_triangle_pso);
SAFE_RELEASE(m_triangle_rootsig);
SAFE_RELEASE(m_triangle_rtv_desc_heap);
SAFE_RELEASE(m_triangle_dsv_desc_heap);
SAFE_RELEASE(s_upload_texture);
SAFE_RELEASE(s_upload_buffer);
SAFE_RELEASE(m_vertex_copy_cmd_list);
SAFE_RELEASE(m_texture_copy_cmd_list);
SAFE_RELEASE(m_vertex_copy_cmd_allocator);
SAFE_RELEASE(m_texture_copy_cmd_allocator);
if (ID3D12Resource* plugin_texture = m_plugin_texture.load())
{
plugin_texture->Release();
m_plugin_texture = nullptr;
}
CloseHandle(m_fence_event);
CloseHandle(m_plugin_texture_fence_event);
garbage_collect(true);
m_mapped_triangle_vertex_buffers.clear();
}
void RenderAPI_D3D12::record_draw_cmd_list(ID3D12CommandAllocator* cmd_alloc, ID3D12GraphicsCommandList* cmd, ID3D12RootSignature* rootsig, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, D3D12_VERTEX_BUFFER_VIEW* vbview, const float* world_matrix, D3D12_VIEWPORT* viewport, ID3D12PipelineState* pso, ID3D12Resource* target, D3D12_RESOURCE_STATES target_state)
{
constexpr FLOAT clear_color[4] = { 0.5f, 0.5f, 0.5f, 1.f };
handle_hr(cmd_alloc->Reset(), "Failed to reset cmd allocator\n");
handle_hr(cmd->Reset(cmd_alloc, pso), "Failed to reset cmd list\n");
cmd->SetGraphicsRootSignature(rootsig);
cmd->SetGraphicsRoot32BitConstants(0, 64, world_matrix, 0);
if (target_state != D3D12_RESOURCE_STATE_RENDER_TARGET)
{
transition_barrier(cmd, target, target_state, D3D12_RESOURCE_STATE_RENDER_TARGET);
}
cmd->OMSetRenderTargets(1, &rtv_handle, FALSE, nullptr);
cmd->ClearRenderTargetView(rtv_handle, clear_color, 0, nullptr);
D3D12_RECT scissor;
scissor.left = 0;
scissor.top = 0;
scissor.right = static_cast<LONG>(viewport->Width);
scissor.bottom = static_cast<LONG>(viewport->Height);
cmd->RSSetViewports(1, viewport);
cmd->RSSetScissorRects(1, &scissor);
cmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
cmd->IASetVertexBuffers(0, 1, vbview);
const UINT vertices = vbview->SizeInBytes / vbview->StrideInBytes;
cmd->DrawInstanced(vertices, 1, 0, 0);
if (target_state != D3D12_RESOURCE_STATE_RENDER_TARGET)
{
transition_barrier(cmd, target, D3D12_RESOURCE_STATE_RENDER_TARGET, target_state);
}
handle_hr(cmd->Close(), "Failed to close draw cmd list\n");
}
UINT64 RenderAPI_D3D12::submit_cmd_to_unity_worker(ID3D12GraphicsCommandList* cmd, UnityGraphicsD3D12ResourceState* resource_states, int state_count)
{
return s_d3d12->ExecuteCommandList(cmd, state_count, resource_states);
}
ID3D12Resource* RenderAPI_D3D12::create_render_texture()
{
ID3D12Device* device = s_d3d12->GetDevice();
DXGI_SAMPLE_DESC dxgi_sample_desc = {};
dxgi_sample_desc.Count = 1;
dxgi_sample_desc.Quality = 0;
D3D12_RESOURCE_DESC render_texture_desc = {};
render_texture_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
render_texture_desc.Width = m_texture_width;
render_texture_desc.Height = m_texture_height;
render_texture_desc.DepthOrArraySize = 1;
render_texture_desc.MipLevels = 1;
render_texture_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
render_texture_desc.SampleDesc = dxgi_sample_desc;
render_texture_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
render_texture_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
D3D12_HEAP_PROPERTIES render_texture_heap_props = {};
render_texture_heap_props.Type = D3D12_HEAP_TYPE_DEFAULT;
render_texture_heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
render_texture_heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
render_texture_heap_props.CreationNodeMask = 1;
render_texture_heap_props.VisibleNodeMask = 1;
ID3D12Resource* pRendertex;
handle_hr(device->CreateCommittedResource(&render_texture_heap_props, D3D12_HEAP_FLAG_NONE, &render_texture_desc, D3D12_RESOURCE_STATE_RENDER_TARGET, nullptr, IID_PPV_ARGS(&pRendertex)),
"Failed to create a render texture\n");
return pRendertex;
}
void RenderAPI_D3D12::create_render_texture_rtv(ID3D12DescriptorHeap* heap, ID3D12Resource* target, UINT offset)
{
CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle{ heap->GetCPUDescriptorHandleForHeapStart() };
rtv_handle.Offset(offset, m_texture_rtv_desc_size);
D3D12_TEX2D_RTV rtv;
rtv.MipSlice = 0;
rtv.PlaneSlice = 0;
D3D12_RENDER_TARGET_VIEW_DESC desc;
desc.Format = typeless_fmt_to_typed(target->GetDesc().Format);
desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
desc.Texture2D = rtv;
s_d3d12->GetDevice()->CreateRenderTargetView(target, &desc, rtv_handle);
}
void RenderAPI_D3D12::transition_barrier(ID3D12GraphicsCommandList* cmd, ID3D12Resource* resource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after)
{
D3D12_RESOURCE_TRANSITION_BARRIER transition = {};
transition.pResource = resource;
transition.Subresource = 0;
transition.StateBefore = before;
transition.StateAfter = after;
D3D12_RESOURCE_BARRIER barrier = {};
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition = transition;
cmd->ResourceBarrier(1, &barrier);
}
void RenderAPI_D3D12::wait_for_unity_frame_fence(UINT64 fence_value)
{
ID3D12Fence* unity_fence = s_d3d12->GetFrameFence();
UINT64 current_fence_value = unity_fence->GetCompletedValue();
if (current_fence_value < fence_value)
{
handle_hr(unity_fence->SetEventOnCompletion(fence_value, m_fence_event), "Failed to set fence event on completion\n");
WaitForSingleObject(m_fence_event, INFINITE);
}
}
void RenderAPI_D3D12::wait_on_fence(UINT64 fence_value, ID3D12Fence* fence, HANDLE fence_event)
{
UINT64 current_fence_value = fence->GetCompletedValue();
if (current_fence_value < fence_value)
{
handle_hr(fence->SetEventOnCompletion(fence_value, fence_event));
WaitForSingleObject(fence_event, INFINITE);
}
}
DXGI_FORMAT RenderAPI_D3D12::typeless_fmt_to_typed(DXGI_FORMAT format)
{
switch (format)
{
case DXGI_FORMAT_R32G32B32A32_TYPELESS:
return DXGI_FORMAT_R32G32B32A32_UINT;
case DXGI_FORMAT_R32G32B32_TYPELESS:
return DXGI_FORMAT_R32G32B32_UINT;
case DXGI_FORMAT_R16G16B16A16_TYPELESS:
return DXGI_FORMAT_R16G16B16A16_UNORM;
case DXGI_FORMAT_R32G32_TYPELESS:
return DXGI_FORMAT_R32G32_UINT;
case DXGI_FORMAT_R32G8X24_TYPELESS:
return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT;
case DXGI_FORMAT_R10G10B10A2_TYPELESS:
return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT;
case DXGI_FORMAT_R8G8B8A8_TYPELESS:
return DXGI_FORMAT_R8G8B8A8_UNORM;
case DXGI_FORMAT_R16G16_TYPELESS:
return DXGI_FORMAT_R16G16_UNORM;
case DXGI_FORMAT_R32_TYPELESS:
return DXGI_FORMAT_R32_UINT;
case DXGI_FORMAT_R24G8_TYPELESS:
return DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
case DXGI_FORMAT_R8G8_TYPELESS:
return DXGI_FORMAT_R8G8_UNORM;
case DXGI_FORMAT_R16_TYPELESS:
return DXGI_FORMAT_R16_UNORM;
case DXGI_FORMAT_R8_TYPELESS:
return DXGI_FORMAT_R8_UNORM;
case DXGI_FORMAT_BC1_TYPELESS:
return DXGI_FORMAT_BC1_UNORM;
case DXGI_FORMAT_BC2_TYPELESS:
return DXGI_FORMAT_BC2_UNORM;
case DXGI_FORMAT_BC3_TYPELESS:
return DXGI_FORMAT_BC3_UNORM;
case DXGI_FORMAT_BC4_TYPELESS:
return DXGI_FORMAT_BC4_UNORM;
case DXGI_FORMAT_BC5_TYPELESS:
return DXGI_FORMAT_BC5_UNORM;
case DXGI_FORMAT_B8G8R8A8_TYPELESS:
return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
case DXGI_FORMAT_B8G8R8X8_TYPELESS:
return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
case DXGI_FORMAT_BC6H_TYPELESS:
return DXGI_FORMAT_BC6H_UF16;
case DXGI_FORMAT_BC7_TYPELESS:
return DXGI_FORMAT_BC7_UNORM;
default:
return format;
}
}
void* RenderAPI_D3D12::BeginModifyTexture(void* textureHandle, int textureWidth, int textureHeight, int* outRowPitch)
{
wait_for_unity_frame_fence(m_texture_copy_fence);
// Fill data
// Clamp to minimum rowPitch of RGBA32
*outRowPitch = static_cast<int>(max(align_pow2(textureWidth * 4), 256));
const UINT64 kDataSize = get_aligned_size(textureWidth, textureHeight, 4, *outRowPitch);
if (!get_upload_resource(&s_upload_texture, kDataSize, D3D12_UPLOAD_HEAP_TEXTURE_BUFFER_NAME))
return NULL;
void* mapped = NULL;
s_upload_texture->Map(0, NULL, &mapped);
return mapped;
}
void RenderAPI_D3D12::EndModifyTexture(void* textureHandle, int textureWidth, int textureHeight, int rowPitch, void* dataPtr)
{
ID3D12Device* device = s_d3d12->GetDevice();
const UINT64 kDataSize = get_aligned_size(textureWidth, textureHeight, 4, rowPitch);
if (!get_upload_resource(&s_upload_texture, kDataSize, D3D12_UPLOAD_HEAP_TEXTURE_BUFFER_NAME))
return;
s_upload_texture->Unmap(0, 0);
ID3D12Resource* resource = (ID3D12Resource*)textureHandle;
D3D12_RESOURCE_DESC desc = resource->GetDesc();
assert(desc.Width == textureWidth);
assert(desc.Height == textureHeight);
D3D12_TEXTURE_COPY_LOCATION srcLoc = {};
srcLoc.pResource = s_upload_texture;
srcLoc.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
device->GetCopyableFootprints(&desc, 0, 1, 0, &srcLoc.PlacedFootprint, nullptr, nullptr, nullptr);
D3D12_TEXTURE_COPY_LOCATION dstLoc = {};
dstLoc.pResource = resource;
dstLoc.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
dstLoc.SubresourceIndex = 0;
m_texture_copy_cmd_allocator->Reset();
m_texture_copy_cmd_list->Reset(m_texture_copy_cmd_allocator, nullptr);
transition_barrier(m_texture_copy_cmd_list, resource, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST);
m_texture_copy_cmd_list->CopyTextureRegion(&dstLoc, 0, 0, 0, &srcLoc, nullptr);
transition_barrier(m_texture_copy_cmd_list, resource, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COMMON);
m_texture_copy_cmd_list->Close();
UnityGraphicsD3D12ResourceState resource_states = {};
resource_states.resource = resource;
resource_states.expected = D3D12_RESOURCE_STATE_COMMON;
resource_states.current = D3D12_RESOURCE_STATE_COMMON;
m_texture_copy_fence = submit_cmd_to_unity_worker(m_texture_copy_cmd_list, &resource_states, 1);
}
void* RenderAPI_D3D12::BeginModifyVertexBuffer(void* bufferHandle, size_t* outBufferSize)
{
wait_for_unity_frame_fence(m_vertex_copy_fence);
if (bufferHandle == NULL)
return NULL;
ID3D12Resource* unity_vertex_buffer = reinterpret_cast<ID3D12Resource*>(bufferHandle);
D3D12_RESOURCE_DESC desc = unity_vertex_buffer->GetDesc();
*outBufferSize = static_cast<size_t>(desc.Width);
if (!get_upload_resource(&s_upload_buffer, desc.Width, D3D12_UPLOAD_HEAP_VERTEX_BUFFER_NAME))
return NULL;
MappedVertexBuffers::iterator it = m_mapped_triangle_vertex_buffers.find(bufferHandle);
if (it == m_mapped_triangle_vertex_buffers.end())
m_mapped_triangle_vertex_buffers.insert(std::make_pair(bufferHandle, reinterpret_cast<void*>(new int())));
HRESULT hr = s_upload_buffer->Map(0, 0, &m_mapped_triangle_vertex_buffers[bufferHandle]);
return m_mapped_triangle_vertex_buffers[bufferHandle];
}
void RenderAPI_D3D12::EndModifyVertexBuffer(void* bufferHandle)
{
m_vertex_copy_cmd_allocator->Reset();
m_vertex_copy_cmd_list->Reset(m_vertex_copy_cmd_allocator, nullptr);
if (bufferHandle == NULL)
return;
UnityGraphicsD3D12RecordingState recordingState;
if (!s_d3d12->CommandRecordingState(&recordingState))
return;
ID3D12Resource* unity_vertex_buffer = reinterpret_cast<ID3D12Resource*>(bufferHandle);
D3D12_RESOURCE_DESC desc = unity_vertex_buffer->GetDesc();
if (!get_upload_resource(&s_upload_buffer, desc.Width, D3D12_UPLOAD_HEAP_VERTEX_BUFFER_NAME))
return;
assert(desc.Height == 1);
s_upload_buffer->Unmap(0, 0);
D3D12_HEAP_PROPERTIES heap_props;
handle_hr(unity_vertex_buffer->GetHeapProperties(&heap_props, nullptr), "Failed to get heap properties for unitys vertex buffer");
// On DX12 Mesh.MarkDynamic() doesn't guarantee the underlying resource to be CPU mappable. In the case when it's not we need to
// place correct transition barriers before and after the copy command.
if (heap_props.Type == D3D12_HEAP_TYPE_DEFAULT)
transition_barrier(m_vertex_copy_cmd_list, unity_vertex_buffer, D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_COPY_DEST);
m_vertex_copy_cmd_list->CopyBufferRegion(unity_vertex_buffer, 0, s_upload_buffer, 0, desc.Width);
if (heap_props.Type == D3D12_HEAP_TYPE_DEFAULT)
transition_barrier(m_vertex_copy_cmd_list, unity_vertex_buffer, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COMMON);
handle_hr(m_vertex_copy_cmd_list->Close(), "Failed to close vertex copy cmd list");
UnityGraphicsD3D12ResourceState resource_states = {};
if (heap_props.Type == D3D12_HEAP_TYPE_DEFAULT)
{
resource_states.resource = unity_vertex_buffer;
resource_states.expected = D3D12_RESOURCE_STATE_COMMON;
resource_states.current = D3D12_RESOURCE_STATE_COMMON;
}
m_vertex_copy_fence = submit_cmd_to_unity_worker(m_vertex_copy_cmd_list, &resource_states, 1);
}
void RenderAPI_D3D12::drawToPluginTexture()
{
if (!m_plugin_texture)
return;
wait_on_fence(m_plugin_texture_fence_value, m_plugin_texture_fence, m_plugin_texture_fence_event);
// Draw the triangle upside down
constexpr float world_matrix[16] = { 1, 0, 0, 0,
0,-1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
D3D12_VIEWPORT viewport = {};
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = static_cast<FLOAT>(m_texture_width);
viewport.Height = static_cast<FLOAT>(m_texture_height);
viewport.MinDepth = D3D12_MIN_DEPTH;
viewport.MaxDepth = D3D12_MAX_DEPTH;
CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle { m_texture_rtv_desc_heap->GetCPUDescriptorHandleForHeapStart() };
rtv_handle.Offset(1, m_texture_rtv_desc_size);
// We can reuse some of the resources for both plugin_texture and render_texture
record_draw_cmd_list(m_plugin_texture_cmd_allocator,
m_plugin_texture_cmd_list,
m_texture_root_sig,
rtv_handle,
&m_texture_vertex_buffer_view,
world_matrix, &viewport,
m_texture_pso,
m_plugin_texture,
D3D12_RESOURCE_STATE_RENDER_TARGET);
ID3D12CommandQueue* unity_command_queue = s_d3d12->GetCommandQueue();
unity_command_queue->ExecuteCommandLists(1, (ID3D12CommandList**)&m_plugin_texture_cmd_list);
unity_command_queue->Signal(m_plugin_texture_fence, ++m_plugin_texture_fence_value);
}
void RenderAPI_D3D12::drawToRenderTexture()
{
wait_for_unity_frame_fence(m_render_texture_draw_fence);
if (!m_render_texture)
return;
// Draw the triangle upright
constexpr float world_matrix[16] = { 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1 };
D3D12_VIEWPORT viewport = {};
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = static_cast<FLOAT>(m_texture_width);
viewport.Height = static_cast<FLOAT>(m_texture_height);
viewport.MinDepth = D3D12_MIN_DEPTH;
viewport.MaxDepth = D3D12_MAX_DEPTH;
CD3DX12_CPU_DESCRIPTOR_HANDLE rtv_handle { m_texture_rtv_desc_heap->GetCPUDescriptorHandleForHeapStart() };
rtv_handle.Offset(0, m_texture_rtv_desc_size);
D3D12_RESOURCE_STATES target_state;
if (m_is_render_texture_created_by_unity)
{
target_state = D3D12_RESOURCE_STATE_COMMON;
}
else
{
target_state = D3D12_RESOURCE_STATE_RENDER_TARGET;
}
record_draw_cmd_list(m_render_texture_cmd_allocator,
m_render_texture_cmd_list,
m_texture_root_sig,
rtv_handle,
&m_texture_vertex_buffer_view,
world_matrix, &viewport,
m_texture_pso,
m_render_texture,
target_state);
UnityGraphicsD3D12ResourceState resource_states;
resource_states.resource = m_render_texture;
resource_states.expected = D3D12_RESOURCE_STATE_COMMON;
resource_states.current = D3D12_RESOURCE_STATE_COMMON;
m_render_texture_draw_fence = submit_cmd_to_unity_worker(m_render_texture_cmd_list, &resource_states, 1);
}
void* RenderAPI_D3D12::getRenderTexture()
{
return reinterpret_cast<void*>(m_render_texture.load());
}
void RenderAPI_D3D12::setRenderTextureResource(UnityRenderBuffer rb)
{
// Release existing resource if there is already one that wasn't created by Unity C# script
if (!m_is_render_texture_created_by_unity && m_render_texture)
{
m_render_texture.load()->Release();
m_render_texture = nullptr;
}
// rb == nullptr is used to signal that the previously used UnityRenderBuffer
// is not available anymore (i.e when it gets destroyed)
if (!rb)
{
m_render_texture = nullptr;
m_is_render_texture_created_by_unity = false;
return;
}
// TextureFromRenderBuffer might not be immediately available when this function is called.
ID3D12Resource* rb_resource = nullptr;
while (!rb_resource)
{
rb_resource = s_d3d12->TextureFromRenderBuffer(rb);
}
D3D12_RESOURCE_DESC desc = rb_resource->GetDesc();
m_texture_width = desc.Width;
m_texture_height = desc.Height;
assert(desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D);
assert(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET);
m_render_texture = rb_resource;
// we need to update the rtv if we won't be calling initialize_render_texture_resources() after
// (when it's already initialized)
if (m_are_resources_initialized)
create_render_texture_rtv(m_texture_rtv_desc_heap, m_render_texture, 0);
m_is_render_texture_created_by_unity = true;
}
bool RenderAPI_D3D12::isSwapChainAvailable()
{
return s_d3d12->GetSwapChain();
}
unsigned int RenderAPI_D3D12::getPresentFlags()
{
return s_d3d12->GetPresentFlags();
};
unsigned int RenderAPI_D3D12::getSyncInterval()
{
return s_d3d12->GetSyncInterval();
}
unsigned int RenderAPI_D3D12::getBackbufferWidth()
{
IDXGISwapChain* swap_chain = s_d3d12->GetSwapChain();
if (!swap_chain)
return 0;
DXGI_SWAP_CHAIN_DESC desc;
handle_hr(swap_chain->GetDesc(&desc), "Failed to get DXGI swap chain desc\n");
return desc.BufferDesc.Width;
}
unsigned int RenderAPI_D3D12::getBackbufferHeight()
{
IDXGISwapChain* swap_chain = s_d3d12->GetSwapChain();
if (!swap_chain)
return 0;
DXGI_SWAP_CHAIN_DESC desc;
handle_hr(swap_chain->GetDesc(&desc), "Failed to get DXGI swap chain desc\n");
return desc.BufferDesc.Height;
}
#undef ReturnOnFail
#endif // #if SUPPORT_D3D12
Reference in New Issue Copy Permalink