3577 lines
135 KiB
C
3577 lines
135 KiB
C
#pragma warning(push, 0)
|
|
# define UNICODE
|
|
# define COBJMACROS
|
|
# include <Windows.h>
|
|
# include <d3d12.h>
|
|
# include <dxgidebug.h>
|
|
# include <dxgi1_6.h>
|
|
# include <combaseapi.h>
|
|
# include <d3dcompiler.h>
|
|
#pragma warning(pop)
|
|
|
|
#pragma comment(lib, "d3d12")
|
|
#pragma comment(lib, "dxgi")
|
|
#pragma comment(lib, "dxguid")
|
|
#pragma comment(lib, "d3dcompiler")
|
|
|
|
#if ProfilingIsEnabled_GPU
|
|
/* For RegOpenKeyEx */
|
|
# include <winreg.h>
|
|
# pragma comment(lib, "advapi32")
|
|
#endif
|
|
|
|
#define DX12_ALLOW_TEARING 1
|
|
#define DX12_WAIT_FRAME_LATENCY 1
|
|
#define DX12_SWAPCHAIN_FLAGS (((DX12_ALLOW_TEARING != 0) * DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING) | ((DX12_WAIT_FRAME_LATENCY != 0) * DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
|
|
#define DX12_SWAPCHAIN_BUFFER_COUNT (4)
|
|
|
|
/* Arbitrary limits */
|
|
#define DX12_NUM_CBV_SRV_UAV_DESCRIPTORS (1024 * 64)
|
|
#define DX12_NUM_RTV_DESCRIPTORS (1024 * 1)
|
|
#define DX12_COMMAND_BUFFER_MIN_SIZE (1024 * 64)
|
|
|
|
#define DX12_MULTI_QUEUE !ProfilingIsEnabled
|
|
#if DX12_MULTI_QUEUE
|
|
# define DX12_QUEUE_DIRECT 0
|
|
# define DX12_QUEUE_COMPUTE 1
|
|
# define DX12_QUEUE_COPY 2
|
|
# define DX12_QUEUE_COPY_BACKGROUND 3
|
|
# define DX12_NUM_QUEUES 4
|
|
#else
|
|
# define DX12_QUEUE_DIRECT 0
|
|
# define DX12_QUEUE_COMPUTE 0
|
|
# define DX12_QUEUE_COPY 0
|
|
# define DX12_QUEUE_COPY_BACKGROUND 0
|
|
# define DX12_NUM_QUEUES 1
|
|
#endif
|
|
|
|
#if RtcIsEnabled
|
|
# define DX12_DEBUG 1
|
|
# define DX12_SHADER_DEBUG 1
|
|
#else
|
|
# define DX12_DEBUG 0
|
|
# define DX12_SHADER_DEBUG 0
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* internal structs
|
|
* ========================== */
|
|
|
|
struct shader_desc {
|
|
String file;
|
|
String func;
|
|
};
|
|
|
|
struct pipeline_rtv_desc {
|
|
DXGI_FORMAT format;
|
|
b32 blending;
|
|
};
|
|
|
|
struct pipeline_desc {
|
|
String name;
|
|
|
|
/* If a dxc string is set, then it will be used directly instead of looking up dxc from archive using pipeline name */
|
|
String vs_dxc;
|
|
String ps_dxc;
|
|
String cs_dxc;
|
|
|
|
struct pipeline_rtv_desc rtvs[8];
|
|
};
|
|
|
|
struct pipeline {
|
|
String name;
|
|
u64 hash;
|
|
b32 success;
|
|
b32 is_gfx;
|
|
String error;
|
|
i64 compilation_time_ns;
|
|
|
|
/* Lock global pipelines mutex when accessing */
|
|
i64 refcount;
|
|
|
|
ID3D12PipelineState *pso;
|
|
ID3D12RootSignature *rootsig;
|
|
struct pipeline_desc desc;
|
|
|
|
struct pipeline *next;
|
|
};
|
|
|
|
struct pipeline_error {
|
|
String msg;
|
|
struct pipeline_error *next;
|
|
};
|
|
|
|
struct pipeline_include {
|
|
String name;
|
|
u64 name_hash;
|
|
struct pipeline_include *next;
|
|
};
|
|
|
|
struct pipeline_scope {
|
|
Arena *arena;
|
|
Dict *refs;
|
|
struct pipeline_scope *next_free;
|
|
};
|
|
|
|
struct command_queue_desc {
|
|
enum D3D12_COMMAND_LIST_TYPE type;
|
|
enum D3D12_COMMAND_QUEUE_PRIORITY priority;
|
|
String dbg_name;
|
|
};
|
|
|
|
struct command_queue {
|
|
struct command_queue_desc desc;
|
|
ID3D12CommandQueue *cq;
|
|
Arena *arena;
|
|
|
|
P_Mutex submit_fence_mutex;
|
|
u64 submit_fence_target;
|
|
ID3D12Fence *submit_fence;
|
|
|
|
struct command_list_pool *cl_pool;
|
|
|
|
#if ProfilingIsEnabled_GPU
|
|
__prof_dx12_ctx(prof);
|
|
#endif
|
|
};
|
|
|
|
struct command_list_pool {
|
|
struct command_queue *cq;
|
|
Arena *arena;
|
|
P_Mutex mutex;
|
|
struct command_list *first_submitted_command_list;
|
|
struct command_list *last_submitted_command_list;
|
|
};
|
|
|
|
struct command_list {
|
|
struct command_queue *cq;
|
|
struct command_list_pool *pool;
|
|
struct ID3D12CommandAllocator *ca;
|
|
struct ID3D12GraphicsCommandList *cl;
|
|
P_Lock global_record_lock;
|
|
|
|
struct pipeline *cur_pipeline;
|
|
|
|
struct command_descriptor_heap *first_command_descriptor_heap;
|
|
struct command_buffer *first_command_buffer;
|
|
|
|
u64 submitted_fence_target;
|
|
struct command_list *prev_submitted;
|
|
struct command_list *next_submitted;
|
|
};
|
|
|
|
struct command_descriptor_heap {
|
|
D3D12_DESCRIPTOR_HEAP_TYPE type;
|
|
ID3D12DescriptorHeap *heap;
|
|
D3D12_CPU_DESCRIPTOR_HANDLE start_cpu_handle;
|
|
D3D12_GPU_DESCRIPTOR_HANDLE start_gpu_handle;
|
|
|
|
struct command_descriptor_heap *next_in_command_list;
|
|
|
|
u64 submitted_fence_target;
|
|
struct command_queue *submitted_cq;
|
|
struct command_descriptor_heap *prev_submitted;
|
|
struct command_descriptor_heap *next_submitted;
|
|
};
|
|
|
|
struct command_buffer {
|
|
struct command_buffer_group *group;
|
|
|
|
u64 size;
|
|
struct dx12_resource *resource;
|
|
D3D12_VERTEX_BUFFER_VIEW vbv;
|
|
D3D12_INDEX_BUFFER_VIEW Ibv;
|
|
|
|
struct command_buffer *next_in_command_list;
|
|
|
|
u64 submitted_fence_target;
|
|
struct command_queue *submitted_cq;
|
|
struct command_buffer *prev_submitted;
|
|
struct command_buffer *next_submitted;
|
|
};
|
|
|
|
struct command_buffer_group {
|
|
struct command_buffer *first_submitted;
|
|
struct command_buffer *last_submitted;
|
|
};
|
|
|
|
struct descriptor {
|
|
struct cpu_descriptor_heap *heap;
|
|
|
|
u32 index;
|
|
D3D12_CPU_DESCRIPTOR_HANDLE handle;
|
|
|
|
struct descriptor *next_free;
|
|
};
|
|
|
|
struct dx12_resource {
|
|
enum D3D12_RESOURCE_STATES state;
|
|
ID3D12Resource *resource;
|
|
struct descriptor *cbv_descriptor;
|
|
struct descriptor *srv_descriptor;
|
|
struct descriptor *uav_descriptor;
|
|
struct descriptor *rtv_descriptor;
|
|
|
|
D3D12_GPU_VIRTUAL_ADDRESS gpu_address; /* NOTE: 0 for textures */
|
|
|
|
Vec2I32 texture_size;
|
|
struct dx12_resource *next_free;
|
|
};
|
|
|
|
struct swapchain_buffer {
|
|
struct swapchain *swapchain;
|
|
ID3D12Resource *resource;
|
|
struct descriptor *rtv_descriptor;
|
|
D3D12_RESOURCE_STATES state;
|
|
};
|
|
|
|
struct swapchain {
|
|
IDXGISwapChain3 *swapchain;
|
|
HWND hwnd;
|
|
HANDLE waitable;
|
|
Vec2I32 resolution;
|
|
struct swapchain_buffer buffers[DX12_SWAPCHAIN_BUFFER_COUNT];
|
|
|
|
struct swapchain *next_free;
|
|
};
|
|
|
|
struct cpu_descriptor_heap {
|
|
enum D3D12_DESCRIPTOR_HEAP_TYPE type;
|
|
Arena *arena;
|
|
P_Mutex mutex;
|
|
|
|
u32 descriptor_size;
|
|
u32 num_descriptors_reserved;
|
|
u32 num_descriptors_capacity;
|
|
|
|
struct descriptor *first_free_descriptor;
|
|
|
|
ID3D12DescriptorHeap *heap;
|
|
struct D3D12_CPU_DESCRIPTOR_HANDLE handle;
|
|
};
|
|
|
|
enum fenced_release_kind {
|
|
FENCED_RELEASE_KIND_NONE,
|
|
FENCED_RELEASE_KIND_RESOURCE,
|
|
FENCED_RELEASE_KIND_PIPELINE
|
|
};
|
|
|
|
struct fenced_release_data {
|
|
enum fenced_release_kind kind;
|
|
void *ptr;
|
|
};
|
|
|
|
/* ========================== *
|
|
* internal procs
|
|
* ========================== */
|
|
|
|
internal P_ExitFuncDef(gp_shutdown);
|
|
|
|
internal void dx12_init_device(void);
|
|
|
|
internal void dx12_init_objects(void);
|
|
|
|
internal void dx12_init_pipelines(void);
|
|
|
|
internal void dx12_init_noise(void);
|
|
|
|
internal struct cpu_descriptor_heap *cpu_descriptor_heap_alloc(enum D3D12_DESCRIPTOR_HEAP_TYPE type);
|
|
|
|
internal void command_queue_release(struct command_queue *cq);
|
|
|
|
internal P_JobDef(dx12_evictor_job, _);
|
|
|
|
internal void fenced_release(void *data, enum fenced_release_kind kind);
|
|
|
|
internal struct dx12_resource *dx12_resource_alloc(D3D12_HEAP_PROPERTIES heap_props, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_DESC desc, D3D12_RESOURCE_STATES initial_state);
|
|
|
|
internal struct descriptor *descriptor_alloc(struct cpu_descriptor_heap *dh);
|
|
|
|
struct command_queue_alloc_job_sig { struct command_queue_desc *descs_in; struct command_queue **cqs_out; };
|
|
internal P_JobDef(command_queue_alloc_job, job);
|
|
|
|
struct pipeline_alloc_job_sig { struct pipeline_desc *descs_in; struct pipeline **pipelines_out; };
|
|
internal P_JobDef(pipeline_alloc_job, job);
|
|
|
|
struct dx12_upload_job_sig { struct dx12_resource *resource; void *data; };
|
|
internal P_JobDef(dx12_upload_job, job);
|
|
|
|
#if RESOURCE_RELOADING
|
|
internal WATCH_CALLBACK_FUNC_DEF(pipeline_watch_callback, name);
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Global state
|
|
* ========================== */
|
|
|
|
Global struct {
|
|
Atomic32 initialized;
|
|
|
|
/* Descriptor heaps pool */
|
|
P_Mutex command_descriptor_heaps_mutex;
|
|
Arena *command_descriptor_heaps_arena;
|
|
struct command_descriptor_heap *first_submitted_command_descriptor_heap;
|
|
struct command_descriptor_heap *last_submitted_command_descriptor_heap;
|
|
|
|
/* Command buffers pool */
|
|
P_Mutex command_buffers_mutex;
|
|
Arena *command_buffers_arena;
|
|
Dict *command_buffers_dict;
|
|
|
|
/* Resources pool */
|
|
P_Mutex resources_mutex;
|
|
Arena *resources_arena;
|
|
struct dx12_resource *first_free_resource;
|
|
|
|
/* Swapchains pool */
|
|
P_Mutex swapchains_mutex;
|
|
Arena *swapchains_arena;
|
|
struct swapchain *first_free_swapchain;
|
|
|
|
/* Shader bytecode archive */
|
|
struct tar_archive dxc_archive;
|
|
|
|
/* Pipeline cache */
|
|
P_Mutex pipelines_mutex;
|
|
Arena *pipelines_arena;
|
|
struct pipeline *first_free_pipeline;
|
|
Dict *pipeline_descs;
|
|
Dict *top_pipelines; /* Latest pipelines */
|
|
Dict *top_successful_pipelines; /* Latest pipelines that successfully compiled */
|
|
struct pipeline_scope *first_free_pipeline_scope;
|
|
|
|
/* Fenced release queue */
|
|
P_Mutex fenced_releases_mutex;
|
|
Arena *fenced_releases_arena;
|
|
u64 fenced_release_targets[DX12_NUM_QUEUES];
|
|
|
|
/* Factory */
|
|
IDXGIFactory6 *factory;
|
|
|
|
/* Adapter */
|
|
IDXGIAdapter1 *adapter;
|
|
|
|
/* Device */
|
|
ID3D12Device *device;
|
|
|
|
/* Descriptor sizes */
|
|
u32 desc_sizes[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES];
|
|
u32 desc_counts[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES];
|
|
|
|
/* Global descriptor heaps */
|
|
struct cpu_descriptor_heap *cbv_srv_uav_heap;
|
|
struct cpu_descriptor_heap *rtv_heap;
|
|
|
|
/* Command queues */
|
|
P_Mutex global_command_list_record_mutex;
|
|
P_Mutex global_submit_mutex;
|
|
struct command_queue *command_queues[DX12_NUM_QUEUES];
|
|
|
|
/* Evictor job */
|
|
P_Counter evictor_job_counter;
|
|
P_Cv evictor_wake_cv;
|
|
P_Mutex evictor_wake_mutex;
|
|
i64 evictor_wake_gen;
|
|
b32 evictor_shutdown;
|
|
} G = ZI, DebugAlias(G, G_gp_dx12);
|
|
|
|
/* ========================== *
|
|
* Startup
|
|
* ========================== */
|
|
|
|
void gp_startup(void)
|
|
{
|
|
__prof;
|
|
if (Atomic32FetchTestSet(&G.initialized, 0, 1) != 0) {
|
|
P_Panic(Lit("GP layer already initialized"));
|
|
}
|
|
|
|
/* Initialize command descriptor heaps pool */
|
|
G.command_descriptor_heaps_arena = AllocArena(Gibi(64));
|
|
|
|
/* Initialize command buffers pool */
|
|
G.command_buffers_arena = AllocArena(Gibi(64));
|
|
G.command_buffers_dict = InitDict(G.command_buffers_arena, 4096);
|
|
|
|
/* Initialize resources pool */
|
|
G.resources_arena = AllocArena(Gibi(64));
|
|
|
|
/* Initialize swapchains pool */
|
|
G.swapchains_arena = AllocArena(Gibi(64));
|
|
|
|
/* Initialize pipeline cache */
|
|
G.pipelines_arena = AllocArena(Gibi(64));
|
|
G.pipeline_descs = InitDict(G.pipelines_arena, 1024);
|
|
G.top_pipelines = InitDict(G.pipelines_arena, 1024);
|
|
G.top_successful_pipelines = InitDict(G.pipelines_arena, 1024);
|
|
|
|
/* Initialize fenced releases queue */
|
|
G.fenced_releases_arena = AllocArena(Gibi(64));
|
|
|
|
/* Initialize embedded shader archive */
|
|
String embedded_data = INC_GetDxcTar();
|
|
if (embedded_data.len <= 0) {
|
|
P_Panic(Lit("No embedded shaders found"));
|
|
}
|
|
G.dxc_archive = tar_parse(G.pipelines_arena, embedded_data, Lit(""));
|
|
|
|
/* Initialize dx12 */
|
|
/* TODO: Parallelize phases */
|
|
dx12_init_device();
|
|
dx12_init_objects();
|
|
dx12_init_pipelines();
|
|
dx12_init_noise();
|
|
|
|
/* Register callbacks */
|
|
#if RESOURCE_RELOADING
|
|
watch_register_callback(pipeline_watch_callback);
|
|
#endif
|
|
P_OnExit(gp_shutdown);
|
|
|
|
/* Start evictor job */
|
|
P_Run(1, dx12_evictor_job, 0, P_Pool_Background, P_Priority_Low, &G.evictor_job_counter);
|
|
}
|
|
|
|
internal P_ExitFuncDef(gp_shutdown)
|
|
{
|
|
__prof;
|
|
#if 0
|
|
/* Release objects to make live object reporting less noisy */
|
|
//IDXGISwapChain3_Release(G.swapchain);
|
|
for (u32 i = 0; i < countof(G.command_queues); ++i) {
|
|
struct command_queue *cq = G.command_queues[i];
|
|
cmomand_queue_release(cq);
|
|
}
|
|
ID3D12Device_Release(G.device);
|
|
#else
|
|
(UNUSED)command_queue_release;
|
|
#endif
|
|
|
|
{
|
|
P_Lock lock = P_LockE(&G.evictor_wake_mutex);
|
|
G.evictor_shutdown = 1;
|
|
P_SignalCv(&G.evictor_wake_cv, I32Max);
|
|
P_Unlock(&lock);
|
|
}
|
|
P_WaitOnCounter(&G.evictor_job_counter);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Dx12 device initialization
|
|
* ========================== */
|
|
|
|
internal void dx12_init_error(String error)
|
|
{
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
String msg = StringFormat(scratch.arena, Lit("Failed to initialize DirectX 12.\n\n%F"), FmtString(error));
|
|
P_Panic(msg);
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
internal void dx12_init_device(void)
|
|
{
|
|
__prof;
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
HRESULT hr = 0;
|
|
|
|
/* Enable debug layer */
|
|
u32 dxgi_factory_flags = 0;
|
|
#if DX12_DEBUG
|
|
{
|
|
__profn("Enable debug layer");
|
|
ID3D12Debug *debug_controller0 = 0;
|
|
hr = D3D12GetDebugInterface(&IID_ID3D12Debug, (void **)&debug_controller0);
|
|
if (FAILED(hr)) {
|
|
dx12_init_error(Lit("Failed to create ID3D12Debug0"));
|
|
}
|
|
|
|
ID3D12Debug1 *debug_controller1 = 0;
|
|
hr = ID3D12Debug_QueryInterface(debug_controller0, &IID_ID3D12Debug1, (void **)&debug_controller1);
|
|
if (FAILED(hr)) {
|
|
dx12_init_error(Lit("Failed to create ID3D12Debug1"));
|
|
}
|
|
|
|
ID3D12Debug_EnableDebugLayer(debug_controller0);
|
|
|
|
/* FIXME: Enable this */
|
|
//ID3D12Debug1_SetEnableGPUBasedValidation(debug_controller1, 1);
|
|
|
|
ID3D12Debug_Release(debug_controller1);
|
|
ID3D12Debug_Release(debug_controller0);
|
|
dxgi_factory_flags |= DXGI_CREATE_FACTORY_DEBUG;
|
|
}
|
|
#endif
|
|
|
|
/* Create factory */
|
|
{
|
|
__profn("Create factory");
|
|
hr = CreateDXGIFactory2(dxgi_factory_flags, &IID_IDXGIFactory6, (void **)&G.factory);
|
|
if (FAILED(hr)) {
|
|
dx12_init_error(Lit("Failed to initialize DXGI factory"));
|
|
}
|
|
}
|
|
|
|
/* Create device */
|
|
{
|
|
__profn("Create device");
|
|
IDXGIAdapter1 *adapter = 0;
|
|
ID3D12Device *device = 0;
|
|
String error = Lit("Could not initialize GPU device.");
|
|
String first_gpu_name = ZI;
|
|
u32 adapter_index = 0;
|
|
b32 skip = 0; /* For debugging iGPU */
|
|
for (;;) {
|
|
{
|
|
hr = IDXGIFactory6_EnumAdapterByGpuPreference(G.factory, adapter_index, DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, &IID_IDXGIAdapter1, (void **)&adapter);
|
|
}
|
|
if (SUCCEEDED(hr)) {
|
|
DXGI_ADAPTER_DESC1 desc;
|
|
IDXGIAdapter1_GetDesc1(adapter, &desc);
|
|
if (first_gpu_name.len == 0) {
|
|
first_gpu_name = StringFromWstrNoLimit(scratch.arena, desc.Description);
|
|
}
|
|
{
|
|
hr = D3D12CreateDevice((IUnknown *)adapter, D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device, (void **)&device);
|
|
}
|
|
if (SUCCEEDED(hr) && !skip ) {
|
|
break;
|
|
}
|
|
skip = 0;
|
|
ID3D12Device_Release(device);
|
|
IDXGIAdapter1_Release(adapter);
|
|
adapter = 0;
|
|
device = 0;
|
|
++adapter_index;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (!device) {
|
|
if (first_gpu_name.len > 0) {
|
|
String fmt = Lit("Could not initialize device '%F' with D3D_FEATURE_LEVEL_12_0. Ensure that the device is capable and drivers are up to date.");
|
|
error = StringFormat(scratch.arena, fmt, FmtString(first_gpu_name));
|
|
}
|
|
dx12_init_error(error);
|
|
}
|
|
G.adapter = adapter;
|
|
G.device = device;
|
|
}
|
|
|
|
#if DX12_DEBUG
|
|
/* Enable D3D12 Debug break */
|
|
{
|
|
__profn("Enable d3d12 debug break");
|
|
ID3D12InfoQueue *info = 0;
|
|
hr = ID3D12Device_QueryInterface(G.device, &IID_ID3D12InfoQueue, (void **)&info);
|
|
if (FAILED(hr)) {
|
|
dx12_init_error(Lit("Failed to query ID3D12Device interface"));
|
|
}
|
|
ID3D12InfoQueue_SetBreakOnSeverity(info, D3D12_MESSAGE_SEVERITY_CORRUPTION, 1);
|
|
ID3D12InfoQueue_SetBreakOnSeverity(info, D3D12_MESSAGE_SEVERITY_ERROR, 1);
|
|
ID3D12InfoQueue_Release(info);
|
|
}
|
|
|
|
/* Enable DXGI Debug break */
|
|
{
|
|
__profn("Enable dxgi debug break");
|
|
IDXGIInfoQueue *dxgi_info = 0;
|
|
hr = DXGIGetDebugInterface1(0, &IID_IDXGIInfoQueue, (void **)&dxgi_info);
|
|
if (FAILED(hr)) {
|
|
dx12_init_error(Lit("Failed to get DXGI debug interface"));
|
|
}
|
|
IDXGIInfoQueue_SetBreakOnSeverity(dxgi_info, DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, 1);
|
|
IDXGIInfoQueue_SetBreakOnSeverity(dxgi_info, DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, 1);
|
|
IDXGIInfoQueue_Release(dxgi_info);
|
|
}
|
|
#endif
|
|
|
|
#if ProfilingIsEnabled_GPU && ProfilingIsEnabled_GPU_STABLE_POWER_STATE
|
|
/* Enable stable power state */
|
|
{
|
|
__profn("Set stable power state");
|
|
b32 success = 1;
|
|
HKEY key = 0;
|
|
success = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\AppModelUnlock", 0, KEY_READ, &key) == ERROR_SUCCESS;
|
|
if (success) {
|
|
DWORD value = ZI;
|
|
DWORD dword_size = sizeof(DWORD);
|
|
success = RegQueryValueExW(key, L"AllowDevelopmentWithoutDevLicense", 0, 0, (LPBYTE)&value, &dword_size) == ERROR_SUCCESS;
|
|
RegCloseKey(key);
|
|
if (success) {
|
|
success = value != 0;
|
|
}
|
|
}
|
|
P_LogInfoF("D3D12 profiling is enabled, attempting to set stable power state (this will increase GPU timing stability at the cost of performance)");
|
|
if (success) {
|
|
P_LogInfoF("Machine is in developer mode, calling ID3D12Device::SetStablePowerState");
|
|
hr = ID3D12Device_SetStablePowerState(G.device, 1);
|
|
if (SUCCEEDED(hr)) {
|
|
P_LogInfoF("ID3D12Device::SetStablePowerState succeeded");
|
|
} else {
|
|
success = 0;
|
|
P_LogErrorF("ID3D12Device::SetStablePowerState failed");
|
|
}
|
|
} else {
|
|
P_LogWarningF("Machine is not in developer mode, cannot call ID3D12Device::SetStablePowerState");
|
|
}
|
|
if (!success) {
|
|
P_LogWarningF("Profiling is enabled, but ID3D12Device::SetStablePowerState could not be called. This means that GPU timing may be unreliable.");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Dx12 object initialization
|
|
* ========================== */
|
|
|
|
internal void dx12_init_objects(void)
|
|
{
|
|
__prof;
|
|
|
|
/* Initialize desc sizes */
|
|
G.desc_sizes[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV] = ID3D12Device_GetDescriptorHandleIncrementSize(G.device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
|
|
G.desc_sizes[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER] = ID3D12Device_GetDescriptorHandleIncrementSize(G.device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
|
|
G.desc_sizes[D3D12_DESCRIPTOR_HEAP_TYPE_RTV] = ID3D12Device_GetDescriptorHandleIncrementSize(G.device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
|
|
G.desc_sizes[D3D12_DESCRIPTOR_HEAP_TYPE_DSV] = ID3D12Device_GetDescriptorHandleIncrementSize(G.device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
|
|
|
|
/* Initialize desc counts */
|
|
G.desc_counts[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV] = DX12_NUM_CBV_SRV_UAV_DESCRIPTORS;
|
|
G.desc_counts[D3D12_DESCRIPTOR_HEAP_TYPE_RTV] = DX12_NUM_RTV_DESCRIPTORS;
|
|
|
|
/* Create global descriptor heaps */
|
|
G.cbv_srv_uav_heap = cpu_descriptor_heap_alloc(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
|
|
G.rtv_heap = cpu_descriptor_heap_alloc(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
|
|
|
|
/* Create command queues */
|
|
{
|
|
__profn("Allocate command queues");
|
|
struct command_queue_desc params[] = {
|
|
{.type = D3D12_COMMAND_LIST_TYPE_DIRECT, .priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL, .dbg_name = Lit("Direct queue") },
|
|
{.type = D3D12_COMMAND_LIST_TYPE_COMPUTE, .priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL, .dbg_name = Lit("Compute queue") },
|
|
{.type = D3D12_COMMAND_LIST_TYPE_COPY, .priority = D3D12_COMMAND_QUEUE_PRIORITY_HIGH, .dbg_name = Lit("Copyqueue") },
|
|
{.type = D3D12_COMMAND_LIST_TYPE_COPY, .priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL, .dbg_name = Lit("Background copy queue") }
|
|
};
|
|
struct command_queue_alloc_job_sig sig = ZI;
|
|
sig.descs_in = params;
|
|
sig.cqs_out = G.command_queues;
|
|
{
|
|
P_Counter counter = ZI;
|
|
P_Run(DX12_NUM_QUEUES, command_queue_alloc_job, &sig, P_Pool_Inherit, P_Priority_Inherit, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
#if ProfilingIsEnabled
|
|
{
|
|
/* Initialize serially for consistent order in profiler */
|
|
__profn("Initialize command queue profiling contexts");
|
|
for (i32 i = 0; i < DX12_NUM_QUEUES; ++i) {
|
|
struct command_queue *cq = G.command_queues[i];
|
|
String dbg_name = params[i].dbg_name;
|
|
__prof_dx12_ctx_alloc(cq->prof, G.device, cq->cq, dbg_name.text, dbg_name.len);
|
|
(UNUSED)dbg_name;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Dx12 pipeline initialization
|
|
* ========================== */
|
|
|
|
internal void pipeline_register(u64 num_pipelines, struct pipeline **pipelines);
|
|
|
|
internal void dx12_init_pipelines(void)
|
|
{
|
|
__prof;
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
|
|
/* Register pipeline descs */
|
|
{
|
|
/* Material pipeline */
|
|
{
|
|
struct pipeline_desc *desc = PushStruct(G.pipelines_arena, struct pipeline_desc);
|
|
desc->name = Lit("kernel_material");
|
|
desc->rtvs[0].format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
desc->rtvs[0].blending = 1;
|
|
desc->rtvs[1].format = DXGI_FORMAT_R16G16B16A16_FLOAT;
|
|
desc->rtvs[1].blending = 1;
|
|
SetDictValue(G.pipelines_arena, G.pipeline_descs, HashFnv64(Fnv64Basis, desc->name), (u64)desc);
|
|
}
|
|
/* Flood pipeline */
|
|
{
|
|
struct pipeline_desc *desc = PushStruct(G.pipelines_arena, struct pipeline_desc);
|
|
desc->name = Lit("kernel_flood");
|
|
SetDictValue(G.pipelines_arena, G.pipeline_descs, HashFnv64(Fnv64Basis, desc->name), (u64)desc);
|
|
}
|
|
/* Shade pipeline */
|
|
{
|
|
struct pipeline_desc *desc = PushStruct(G.pipelines_arena, struct pipeline_desc);
|
|
desc->name = Lit("kernel_shade");
|
|
SetDictValue(G.pipelines_arena, G.pipeline_descs, HashFnv64(Fnv64Basis, desc->name), (u64)desc);
|
|
}
|
|
/* Shape pipeline */
|
|
{
|
|
struct pipeline_desc *desc = PushStruct(G.pipelines_arena, struct pipeline_desc);
|
|
desc->name = Lit("kernel_shape");
|
|
desc->rtvs[0].format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
desc->rtvs[0].blending = 1;
|
|
SetDictValue(G.pipelines_arena, G.pipeline_descs, HashFnv64(Fnv64Basis, desc->name), (u64)desc);
|
|
}
|
|
/* UI pipeline */
|
|
{
|
|
struct pipeline_desc *desc = PushStruct(G.pipelines_arena, struct pipeline_desc);
|
|
desc->name = Lit("kernel_ui");
|
|
desc->rtvs[0].format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
desc->rtvs[0].blending = 1;
|
|
SetDictValue(G.pipelines_arena, G.pipeline_descs, HashFnv64(Fnv64Basis, desc->name), (u64)desc);
|
|
}
|
|
/* Blit pipeilne */
|
|
{
|
|
struct pipeline_desc *desc = PushStruct(G.pipelines_arena, struct pipeline_desc);
|
|
desc->name = Lit("kernel_blit");
|
|
desc->rtvs[0].format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
desc->rtvs[0].blending = 1;
|
|
SetDictValue(G.pipelines_arena, G.pipeline_descs, HashFnv64(Fnv64Basis, desc->name), (u64)desc);
|
|
}
|
|
}
|
|
|
|
/* Compile pipelines */
|
|
u32 num_pipelines = 0;
|
|
struct pipeline_desc *descs = PushDry(scratch.arena, struct pipeline_desc);
|
|
for (DictEntry *entry = G.pipeline_descs->first; entry; entry = entry->next) {
|
|
struct pipeline_desc *desc = (struct pipeline_desc *)entry->value;
|
|
*PushStruct(scratch.arena, struct pipeline_desc) = *desc;
|
|
++num_pipelines;
|
|
}
|
|
struct pipeline **pipelines = PushStructs(scratch.arena, struct pipeline *, num_pipelines);
|
|
{
|
|
__profn("Allocate pipelines");
|
|
struct pipeline_alloc_job_sig sig = ZI;
|
|
sig.descs_in = descs;
|
|
sig.pipelines_out = pipelines;
|
|
P_Counter counter = ZI;
|
|
P_Run(num_pipelines, pipeline_alloc_job, &sig, P_Pool_Inherit, P_Priority_Inherit, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
for (u32 i = 0; i < num_pipelines; ++i) {
|
|
struct pipeline *pipeline = pipelines[i];
|
|
if (pipeline->success) {
|
|
P_LogSuccessF("Successfully compiled pipeline \"%F\" in %F seconds", FmtString(pipeline->name), FmtFloat(SecondsFromNs(pipeline->compilation_time_ns)));
|
|
if (pipeline->error.len) {
|
|
String msg = StringFormat(scratch.arena, Lit("Warning while compiling pipeline \"%F\":\n%F"), FmtString(pipeline->name), FmtString(pipeline->error));
|
|
P_LogWarning(msg);
|
|
}
|
|
} else {
|
|
String error = pipeline->error.len > 0 ? pipeline->error : Lit("Unknown error");
|
|
String msg = StringFormat(scratch.arena, Lit("Error initializing pipeline \"%F\":\n\n%F"), FmtString(pipeline->name), FmtString(error));
|
|
P_LogError(msg);
|
|
P_MessageBox(P_MessageBoxKind_Warning, msg);
|
|
}
|
|
}
|
|
pipeline_register(num_pipelines, pipelines);
|
|
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Noise texture initialization
|
|
* ========================== */
|
|
|
|
internal void dx12_init_noise(void)
|
|
{
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
|
|
{
|
|
String noise_res_name = Lit("noise_128x128x64_16.dat");
|
|
R_Resource noise_res = resource_open(noise_res_name);
|
|
DXGI_FORMAT format = DXGI_FORMAT_R16_UINT;
|
|
//u32 expected_size = K_BLUE_NOISE_TEX_WIDTH * K_BLUE_NOISE_TEX_HEIGHT * K_BLUE_NOISE_TEX_DEPTH * 2;
|
|
u32 expected_size = K_BLUE_NOISE_TEX_WIDTH * K_BLUE_NOISE_TEX_HEIGHT * K_BLUE_NOISE_TEX_DEPTH * 2;
|
|
if (resource_exists(&noise_res)) {
|
|
String data = resource_get_data(&noise_res);
|
|
if (data.len != expected_size) {
|
|
P_Panic(StringFormat(scratch.arena,
|
|
Lit("Noise texture has unexpected size for a %Fx%Fx%F texture (expected %F, got %F)"),
|
|
FmtUint(K_BLUE_NOISE_TEX_WIDTH), FmtUint(K_BLUE_NOISE_TEX_HEIGHT), FmtUint(K_BLUE_NOISE_TEX_DEPTH),
|
|
FmtUint(expected_size), FmtUint(data.len)));
|
|
}
|
|
{
|
|
D3D12_HEAP_PROPERTIES heap_props = { .Type = D3D12_HEAP_TYPE_DEFAULT };
|
|
heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
|
|
D3D12_HEAP_FLAGS heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
|
|
|
|
D3D12_RESOURCE_DESC desc = ZI;
|
|
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE3D;
|
|
|
|
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
|
|
desc.Format = format;
|
|
desc.Alignment = 0;
|
|
desc.Width = K_BLUE_NOISE_TEX_WIDTH;
|
|
desc.Height = K_BLUE_NOISE_TEX_HEIGHT;
|
|
desc.DepthOrArraySize = K_BLUE_NOISE_TEX_DEPTH;
|
|
desc.MipLevels = 1;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.SampleDesc.Quality = 0;
|
|
|
|
struct dx12_resource *r = dx12_resource_alloc(heap_props, heap_flags, desc, D3D12_RESOURCE_STATE_COPY_DEST);
|
|
r->srv_descriptor = descriptor_alloc(G.cbv_srv_uav_heap);
|
|
ID3D12Device_CreateShaderResourceView(G.device, r->resource, 0, r->srv_descriptor->handle);
|
|
|
|
/* Upload texture */
|
|
{
|
|
P_Counter counter = ZI;
|
|
struct dx12_upload_job_sig sig = ZI;
|
|
sig.resource = r;
|
|
sig.data = data.text;
|
|
P_Run(1, dx12_upload_job, &sig, P_Pool_Inherit, P_Priority_Inherit, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
}
|
|
} else {
|
|
P_Panic(StringFormat(scratch.arena, Lit("Noise resource \"%F\" not found"), FmtString(noise_res_name)));
|
|
}
|
|
resource_close(&noise_res);
|
|
}
|
|
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Shader compilation
|
|
* ========================== */
|
|
|
|
#if RESOURCE_RELOADING
|
|
|
|
struct shader_compile_desc {
|
|
String src;
|
|
String friendly_name;
|
|
String entry;
|
|
String target;
|
|
};
|
|
|
|
struct shader_compile_result {
|
|
i64 elapsed_ns;
|
|
String dxc;
|
|
String errors;
|
|
b32 success;
|
|
};
|
|
|
|
struct shader_compile_job_sig {
|
|
Arena *arena;
|
|
struct shader_compile_desc *descs;
|
|
struct shader_compile_result *results;
|
|
};
|
|
|
|
internal P_JobDef(shader_compile_job, job)
|
|
{
|
|
__prof;
|
|
struct shader_compile_job_sig *sig = job.sig;
|
|
Arena *arena = sig->arena;
|
|
struct shader_compile_desc *desc = &sig->descs[job.id];
|
|
struct shader_compile_result *result = &sig->results[job.id];
|
|
|
|
TempArena scratch = BeginScratch(arena);
|
|
{
|
|
i64 start_ns = P_TimeNs();
|
|
DXC_Result dxc_result = ZI;
|
|
{
|
|
__profn("Compile shader");
|
|
P_LogInfoF("Compiling shader \"%F:%F\"", FmtString(desc->friendly_name), FmtString(desc->entry));
|
|
/* NOTE: `DXC_ARGS` is supplied by build system at compile time */
|
|
char *dxc_args_cstr = Stringize(DXC_ARGS);
|
|
String dxc_args_str = StringFromCstrNoLimit(dxc_args_cstr);
|
|
StringArray dxc_args_array = SplitString(scratch.arena, dxc_args_str, Lit(" "));
|
|
String shader_args[] = {
|
|
desc->friendly_name,
|
|
Lit("-E"), desc->entry,
|
|
Lit("-T"), desc->target,
|
|
};
|
|
u32 num_args = countof(shader_args) + dxc_args_array.count;
|
|
String *args = PushStructs(scratch.arena, String, num_args);
|
|
for (u32 i = 0; i < countof(shader_args); ++i) {
|
|
args[i] = shader_args[i];
|
|
}
|
|
for (u32 i = 0; i < dxc_args_array.count; ++i) {
|
|
args[i + countof(shader_args)] = dxc_args_array.strings[i];
|
|
}
|
|
dxc_result = DXC_Compile(arena, desc->src, num_args, args);
|
|
}
|
|
result->success = dxc_result.success;
|
|
result->dxc = dxc_result.dxc;
|
|
result->errors = dxc_result.errors;
|
|
result->elapsed_ns = P_TimeNs() - start_ns;
|
|
|
|
}
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Pipeline
|
|
* ========================== */
|
|
|
|
internal P_JobDef(pipeline_alloc_job, job)
|
|
{
|
|
__prof;
|
|
struct pipeline_alloc_job_sig *sig = job.sig;
|
|
struct pipeline_desc *desc = &sig->descs_in[job.id];
|
|
struct pipeline **pipelines_out = sig->pipelines_out;
|
|
|
|
struct pipeline *pipeline = 0;
|
|
{
|
|
P_Lock lock = P_LockE(&G.pipelines_mutex);
|
|
if (G.first_free_pipeline) {
|
|
pipeline = G.first_free_pipeline;
|
|
G.first_free_pipeline = pipeline->next;
|
|
} else {
|
|
pipeline = PushStructNoZero(G.pipelines_arena, struct pipeline);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
ZeroStruct(pipeline);
|
|
pipelines_out[job.id] = pipeline;
|
|
pipeline->desc = *desc;
|
|
pipeline->name = desc->name;
|
|
pipeline->hash = HashFnv64(Fnv64Basis, pipeline->name);
|
|
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
{
|
|
i64 start_ns = P_TimeNs();
|
|
String pipeline_name = pipeline->name;
|
|
P_LogInfoF("Loading pipeline \"%F\"", FmtString(pipeline_name));
|
|
b32 success = 1;
|
|
HRESULT hr = 0;
|
|
|
|
String error_str = ZI;
|
|
|
|
String vs_dxc = desc->vs_dxc.len > 0 ? desc->vs_dxc : tar_get(&G.dxc_archive, CatString(scratch.arena, pipeline_name, Lit(".vs")))->data;
|
|
String ps_dxc = desc->ps_dxc.len > 0 ? desc->ps_dxc : tar_get(&G.dxc_archive, CatString(scratch.arena, pipeline_name, Lit(".ps")))->data;
|
|
String cs_dxc = desc->cs_dxc.len > 0 ? desc->cs_dxc : tar_get(&G.dxc_archive, CatString(scratch.arena, pipeline_name, Lit(".cs")))->data;
|
|
if (success && vs_dxc.len > 0 && ps_dxc.len <= 0) {
|
|
error_str = Lit("Pipeline has vertex shader without pixel shader");
|
|
success = 0;
|
|
}
|
|
if (success && vs_dxc.len <= 0 && ps_dxc.len > 0) {
|
|
error_str = Lit("Pipeline has pixel shader without vertex shader");
|
|
success = 0;
|
|
}
|
|
if (success && cs_dxc.len > 0 && (vs_dxc.len > 0 || ps_dxc.len > 0)) {
|
|
error_str = Lit("Pipeline has a compute shader with a vertex/pixel shader");
|
|
success = 0;
|
|
}
|
|
if (success && cs_dxc.len <= 0 && vs_dxc.len <= 0 && ps_dxc.len <= 0) {
|
|
error_str = Lit("Pipeline has no shaders");
|
|
success = 0;
|
|
}
|
|
|
|
ID3D10Blob *vs_blob = 0;
|
|
ID3D10Blob *ps_blob = 0;
|
|
ID3D10Blob *cs_blob = 0;
|
|
if (success && vs_dxc.len > 0) {
|
|
hr = D3DCreateBlob(vs_dxc.len, &vs_blob);
|
|
if (SUCCEEDED(hr)) {
|
|
CopyBytes(ID3D10Blob_GetBufferPointer(vs_blob), vs_dxc.text, vs_dxc.len);
|
|
} else {
|
|
error_str = Lit("Failed to create vertex shader blob");
|
|
success = 0;
|
|
}
|
|
}
|
|
if (success && ps_dxc.len > 0) {
|
|
hr = D3DCreateBlob(ps_dxc.len, &ps_blob);
|
|
if (SUCCEEDED(hr)) {
|
|
CopyBytes(ID3D10Blob_GetBufferPointer(ps_blob), ps_dxc.text, ps_dxc.len);
|
|
} else {
|
|
error_str = Lit("Failed to create pixel shader blob");
|
|
success = 0;
|
|
}
|
|
}
|
|
if (success && cs_dxc.len > 0) {
|
|
hr = D3DCreateBlob(cs_dxc.len, &cs_blob);
|
|
if (SUCCEEDED(hr)) {
|
|
CopyBytes(ID3D10Blob_GetBufferPointer(cs_blob), cs_dxc.text, cs_dxc.len);
|
|
} else {
|
|
error_str = Lit("Failed to create compute shader blob");
|
|
success = 0;
|
|
}
|
|
}
|
|
|
|
/* Get root signature blob
|
|
* NOTE: This isn't necessary for creating the root signature (since it
|
|
* could reuse the shader blob), however we'd like to verify that the
|
|
* root signature exists and matches between vs & ps shaders. */
|
|
ID3D10Blob *rootsig_blob = 0;
|
|
if (success) {
|
|
__profn("Validate root signatures");
|
|
if (cs_dxc.len > 0) {
|
|
u32 cs_rootsig_data_len = 0;
|
|
ID3D10Blob *cs_rootsig_blob = 0;
|
|
D3DGetBlobPart(ID3D10Blob_GetBufferPointer(cs_blob), ID3D10Blob_GetBufferSize(cs_blob), D3D_BLOB_ROOT_SIGNATURE, 0, &cs_rootsig_blob);
|
|
if (cs_rootsig_blob) {
|
|
cs_rootsig_data_len = ID3D10Blob_GetBufferSize(cs_rootsig_blob);
|
|
}
|
|
if (cs_rootsig_data_len == 0) {
|
|
success = 0;
|
|
error_str = Lit("Compute shader is missing root signature");
|
|
} else {
|
|
rootsig_blob = cs_rootsig_blob;
|
|
}
|
|
} else {
|
|
char *vs_rootsig_data = 0;
|
|
char *ps_rootsig_data = 0;
|
|
u32 vs_rootsig_data_len = 0;
|
|
u32 ps_rootsig_data_len = 0;
|
|
ID3D10Blob *vs_rootsig_blob = 0;
|
|
ID3D10Blob *ps_rootsig_blob = 0;
|
|
D3DGetBlobPart(ID3D10Blob_GetBufferPointer(vs_blob), ID3D10Blob_GetBufferSize(vs_blob), D3D_BLOB_ROOT_SIGNATURE, 0, &vs_rootsig_blob);
|
|
D3DGetBlobPart(ID3D10Blob_GetBufferPointer(ps_blob), ID3D10Blob_GetBufferSize(ps_blob), D3D_BLOB_ROOT_SIGNATURE, 0, &ps_rootsig_blob);
|
|
if (vs_rootsig_blob) {
|
|
vs_rootsig_data = ID3D10Blob_GetBufferPointer(vs_rootsig_blob);
|
|
vs_rootsig_data_len = ID3D10Blob_GetBufferSize(vs_rootsig_blob);
|
|
}
|
|
if (ps_rootsig_blob) {
|
|
ps_rootsig_data = ID3D10Blob_GetBufferPointer(ps_rootsig_blob);
|
|
ps_rootsig_data_len = ID3D10Blob_GetBufferSize(ps_rootsig_blob);
|
|
}
|
|
if (vs_rootsig_data_len == 0) {
|
|
success = 0;
|
|
error_str = Lit("Vertex shader is missing root signature");
|
|
} else if (ps_rootsig_data_len == 0) {
|
|
success = 0;
|
|
error_str = Lit("Pixel shader is missing root signature");
|
|
} else if (vs_rootsig_data_len != ps_rootsig_data_len || !EqBytes(vs_rootsig_data, ps_rootsig_data, vs_rootsig_data_len)) {
|
|
success = 0;
|
|
error_str = Lit("Root signature mismatch between vertex and pixel shader");
|
|
} else {
|
|
rootsig_blob = vs_rootsig_blob;
|
|
}
|
|
if (ps_rootsig_blob) {
|
|
ID3D10Blob_Release(ps_rootsig_blob);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Create root signature */
|
|
ID3D12RootSignature *rootsig = 0;
|
|
if (success) {
|
|
__profn("Create root signature");
|
|
hr = ID3D12Device_CreateRootSignature(G.device, 0, ID3D10Blob_GetBufferPointer(rootsig_blob), ID3D10Blob_GetBufferSize(rootsig_blob), &IID_ID3D12RootSignature, (void **)&rootsig);
|
|
if (FAILED(hr)) {
|
|
error_str = Lit("Failed to create root signature");
|
|
success = 0;
|
|
}
|
|
}
|
|
|
|
/* Create PSO */
|
|
ID3D12PipelineState *pso = 0;
|
|
if (success) {
|
|
if (cs_dxc.len > 0) {
|
|
__profn("Create compute PSO");
|
|
D3D12_COMPUTE_PIPELINE_STATE_DESC pso_desc = { 0 };
|
|
pso_desc.pRootSignature = rootsig;
|
|
pso_desc.CS.pShaderBytecode = ID3D10Blob_GetBufferPointer(cs_blob);
|
|
pso_desc.CS.BytecodeLength = ID3D10Blob_GetBufferSize(cs_blob);
|
|
hr = ID3D12Device_CreateComputePipelineState(G.device, &pso_desc, &IID_ID3D12PipelineState, (void **)&pso);
|
|
} else {
|
|
__profn("Create graphics PSO");
|
|
|
|
/* Default rasterizer state */
|
|
D3D12_RASTERIZER_DESC raster_desc = {
|
|
.FillMode = D3D12_FILL_MODE_SOLID,
|
|
.CullMode = D3D12_CULL_MODE_NONE,
|
|
.FrontCounterClockwise = 0,
|
|
.DepthBias = D3D12_DEFAULT_DEPTH_BIAS,
|
|
.DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP,
|
|
.SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS,
|
|
.DepthClipEnable = 1,
|
|
.MultisampleEnable = 0,
|
|
.AntialiasedLineEnable = 0,
|
|
.ForcedSampleCount = 0,
|
|
.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF
|
|
};
|
|
|
|
/* Empty input layout */
|
|
D3D12_INPUT_LAYOUT_DESC input_layout_desc = ZI;
|
|
|
|
/* Blend state */
|
|
D3D12_BLEND_DESC blend_desc = {
|
|
.AlphaToCoverageEnable = 0,
|
|
.IndependentBlendEnable = 1
|
|
};
|
|
for (i32 i = 0; i < (i32)countof(desc->rtvs); ++i) {
|
|
StaticAssert(countof(blend_desc.RenderTarget) <= countof(desc->rtvs));
|
|
if (desc->rtvs[i].format != DXGI_FORMAT_UNKNOWN) {
|
|
b32 blending_enabled = desc->rtvs[i].blending;
|
|
blend_desc.RenderTarget[i].BlendEnable = blending_enabled;
|
|
blend_desc.RenderTarget[i].SrcBlend = D3D12_BLEND_SRC_ALPHA;
|
|
blend_desc.RenderTarget[i].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
|
|
blend_desc.RenderTarget[i].BlendOp = D3D12_BLEND_OP_ADD;
|
|
blend_desc.RenderTarget[i].SrcBlendAlpha = D3D12_BLEND_ONE;
|
|
blend_desc.RenderTarget[i].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
|
|
blend_desc.RenderTarget[i].BlendOpAlpha = D3D12_BLEND_OP_ADD;
|
|
blend_desc.RenderTarget[i].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Disable depth stencil */
|
|
D3D12_DEPTH_STENCIL_DESC depth_stencil_desc = {
|
|
.DepthEnable = 0,
|
|
.StencilEnable = 0
|
|
};
|
|
|
|
/* PSO */
|
|
D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc = { 0 };
|
|
pso_desc.pRootSignature = rootsig;
|
|
pso_desc.VS.pShaderBytecode = ID3D10Blob_GetBufferPointer(vs_blob);
|
|
pso_desc.VS.BytecodeLength = ID3D10Blob_GetBufferSize(vs_blob);
|
|
pso_desc.PS.pShaderBytecode = ID3D10Blob_GetBufferPointer(ps_blob);
|
|
pso_desc.PS.BytecodeLength = ID3D10Blob_GetBufferSize(ps_blob);
|
|
pso_desc.BlendState = blend_desc;
|
|
pso_desc.SampleMask = UINT_MAX;
|
|
pso_desc.RasterizerState = raster_desc;
|
|
pso_desc.DepthStencilState = depth_stencil_desc;
|
|
pso_desc.InputLayout = input_layout_desc;
|
|
pso_desc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
|
|
for (i32 i = 0; i < (i32)countof(desc->rtvs); ++i) {
|
|
StaticAssert(countof(pso_desc.RTVFormats) <= countof(desc->rtvs));
|
|
DXGI_FORMAT format = desc->rtvs[i].format;
|
|
if (format != DXGI_FORMAT_UNKNOWN) {
|
|
pso_desc.RTVFormats[pso_desc.NumRenderTargets++] = format;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
pso_desc.SampleDesc.Count = 1;
|
|
pso_desc.SampleDesc.Quality = 0;
|
|
hr = ID3D12Device_CreateGraphicsPipelineState(G.device, &pso_desc, &IID_ID3D12PipelineState, (void **)&pso);
|
|
}
|
|
if (FAILED(hr)) {
|
|
error_str = Lit("Failed to create pipeline state object");
|
|
success = 0;
|
|
}
|
|
}
|
|
|
|
/* Parse errors */
|
|
if (!success && error_str.len <= 0) {
|
|
error_str = Lit("Unknown error");
|
|
}
|
|
|
|
pipeline->pso = pso;
|
|
pipeline->rootsig = rootsig;
|
|
pipeline->compilation_time_ns = P_TimeNs() - start_ns;
|
|
pipeline->success = success;
|
|
pipeline->is_gfx = cs_dxc.len == 0;
|
|
pipeline->error = error_str;
|
|
|
|
if (rootsig_blob) {
|
|
ID3D10Blob_Release(rootsig_blob);
|
|
}
|
|
if (vs_blob) {
|
|
ID3D10Blob_Release(vs_blob);
|
|
}
|
|
if (ps_blob) {
|
|
ID3D10Blob_Release(ps_blob);
|
|
}
|
|
if (cs_blob) {
|
|
ID3D10Blob_Release(cs_blob);
|
|
}
|
|
}
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
internal void pipeline_release_now(struct pipeline *pipeline)
|
|
{
|
|
__prof;
|
|
if (pipeline->pso) {
|
|
ID3D12PipelineState_Release(pipeline->pso);
|
|
}
|
|
P_Lock lock = P_LockE(&G.pipelines_mutex);
|
|
{
|
|
pipeline->next = G.first_free_pipeline;
|
|
G.first_free_pipeline = pipeline;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Pipeline cache
|
|
* ========================== */
|
|
|
|
internal struct pipeline_scope *pipeline_scope_begin(void)
|
|
{
|
|
__prof;
|
|
struct pipeline_scope *scope = 0;
|
|
{
|
|
P_Lock lock = P_LockE(&G.pipelines_mutex);
|
|
if (G.first_free_pipeline_scope) {
|
|
scope = G.first_free_pipeline_scope;
|
|
G.first_free_pipeline_scope = scope->next_free;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
Arena *arena = 0;
|
|
if (scope) {
|
|
arena = scope->arena;
|
|
} else {
|
|
arena = AllocArena(Mebi(64));
|
|
}
|
|
ResetArena(arena);
|
|
scope = PushStruct(arena, struct pipeline_scope);
|
|
scope->arena = arena;
|
|
scope->refs = InitDict(scope->arena, 64);
|
|
return scope;
|
|
}
|
|
|
|
internal void pipeline_scope_end(struct pipeline_scope *scope)
|
|
{
|
|
__prof;
|
|
P_Lock lock = P_LockE(&G.pipelines_mutex);
|
|
{
|
|
for (DictEntry *entry = scope->refs->first; entry; entry = entry->next) {
|
|
struct pipeline *pipeline = (struct pipeline *)entry->value;
|
|
if (--pipeline->refcount <= 0) {
|
|
fenced_release(pipeline, FENCED_RELEASE_KIND_PIPELINE);
|
|
}
|
|
}
|
|
scope->next_free = G.first_free_pipeline_scope;
|
|
G.first_free_pipeline_scope = scope;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
internal Readonly struct pipeline g_nil_pipeline = ZI;
|
|
internal struct pipeline *pipeline_from_name(struct pipeline_scope *scope, String name)
|
|
{
|
|
__prof;
|
|
struct pipeline *result = &g_nil_pipeline;
|
|
u64 hash = HashFnv64(Fnv64Basis, name);
|
|
|
|
struct pipeline *tmp = (struct pipeline *)DictValueFromHash(scope->refs, hash);
|
|
if (tmp) {
|
|
result = tmp;
|
|
} else {
|
|
{
|
|
P_Lock lock = P_LockE(&G.pipelines_mutex);
|
|
tmp = (struct pipeline *)DictValueFromHash(G.top_successful_pipelines, hash);
|
|
if (tmp) {
|
|
++tmp->refcount;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
if (tmp) {
|
|
SetDictValue(scope->arena, scope->refs, hash, (u64)tmp);
|
|
result = tmp;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
internal void pipeline_register(u64 num_pipelines, struct pipeline **pipelines)
|
|
{
|
|
__prof;
|
|
P_Lock lock = P_LockE(&G.pipelines_mutex);
|
|
{
|
|
for (u64 i = 0; i < num_pipelines; ++i) {
|
|
struct pipeline *pipeline = pipelines[i];
|
|
u64 hash = pipeline->hash;
|
|
/* Insert into top dict */
|
|
{
|
|
struct pipeline *old_pipeline = (struct pipeline *)DictValueFromHash(G.top_pipelines, hash);
|
|
if (old_pipeline && --old_pipeline->refcount <= 0) {
|
|
fenced_release(old_pipeline, FENCED_RELEASE_KIND_PIPELINE);
|
|
}
|
|
SetDictValue(G.pipelines_arena, G.top_pipelines, hash, (u64)pipeline);
|
|
++pipeline->refcount;
|
|
}
|
|
/* Insert into success dict */
|
|
if (pipeline->success) {
|
|
struct pipeline *old_pipeline = (struct pipeline *)DictValueFromHash(G.top_successful_pipelines, hash);
|
|
if (old_pipeline && --old_pipeline->refcount <= 0) {
|
|
fenced_release(old_pipeline, FENCED_RELEASE_KIND_PIPELINE);
|
|
}
|
|
SetDictValue(G.pipelines_arena, G.top_successful_pipelines, hash, (u64)pipeline);
|
|
++pipeline->refcount;
|
|
}
|
|
}
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
#if RESOURCE_RELOADING
|
|
internal WATCH_CALLBACK_FUNC_DEF(pipeline_watch_callback, name)
|
|
{
|
|
__prof;
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
|
|
String rst_extension = Lit(".rst");
|
|
String knl_extension = Lit(".knl");
|
|
|
|
b32 is_src = StringStartsWith(name, Lit("src/"));
|
|
b32 is_rs = is_src && StringEndsWith(name, rst_extension);
|
|
b32 is_cs = is_src && !is_rs && StringEndsWith(name, knl_extension);
|
|
b32 success = 0;
|
|
|
|
/* Recompile shaders */
|
|
String pipeline_name = ZI;
|
|
String friendly_name = ZI;
|
|
i32 num_shaders = 0;
|
|
struct shader_compile_desc *shader_descs = 0;
|
|
struct shader_compile_result *shader_results = 0;
|
|
if (is_rs || is_cs) {
|
|
P_LogDebugF("Change detected in shader source file \"%F\", recompiling...", FmtString(name));
|
|
success = 1;
|
|
P_File file = P_OpenFileReadWait(name);
|
|
String data = P_ReadFile(scratch.arena, file);
|
|
{
|
|
friendly_name = name;
|
|
StringArray split = SplitString(scratch.arena, friendly_name, Lit("src/"));
|
|
friendly_name = split.count > 0 ? CatString(scratch.arena, Lit("src/"), split.strings[split.count - 1]) : friendly_name;
|
|
}
|
|
{
|
|
pipeline_name = name;
|
|
StringArray split = SplitString(scratch.arena, pipeline_name, Lit("/"));
|
|
pipeline_name = split.count > 0 ? split.strings[split.count - 1] : pipeline_name;
|
|
split = SplitString(scratch.arena, pipeline_name, Lit("."));
|
|
pipeline_name = split.count > 1 ? split.strings[split.count - 2] : pipeline_name;
|
|
}
|
|
{
|
|
struct shader_compile_job_sig sig = ZI;
|
|
sig.arena = scratch.arena;
|
|
if (is_rs) {
|
|
num_shaders = 2;
|
|
shader_descs = PushStructs(scratch.arena, struct shader_compile_desc, num_shaders);
|
|
shader_results = PushStructs(scratch.arena, struct shader_compile_result, num_shaders);
|
|
sig.descs = shader_descs;
|
|
sig.results = shader_results;
|
|
sig.descs[0].src = data;
|
|
sig.descs[0].friendly_name = friendly_name;
|
|
sig.descs[0].entry = Lit("vs");
|
|
sig.descs[0].target = Lit("vs_6_6");
|
|
sig.descs[1].src = data;
|
|
sig.descs[1].friendly_name = friendly_name;
|
|
sig.descs[1].entry = Lit("ps");
|
|
sig.descs[1].target = Lit("ps_6_6");
|
|
} else if (is_cs) {
|
|
num_shaders = 1;
|
|
shader_descs = PushStructs(scratch.arena, struct shader_compile_desc, num_shaders);
|
|
shader_results = PushStructs(scratch.arena, struct shader_compile_result, num_shaders);
|
|
sig.descs = shader_descs;
|
|
sig.results = shader_results;
|
|
sig.descs[0].src = data;
|
|
sig.descs[0].friendly_name = friendly_name;
|
|
sig.descs[0].entry = Lit("cs");
|
|
sig.descs[0].target = Lit("cs_6_6");
|
|
}
|
|
{
|
|
P_Counter counter = ZI;
|
|
P_Run(num_shaders, shader_compile_job, &sig, P_Pool_Inherit, P_Priority_Inherit, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
}
|
|
P_CloseFIle(file);
|
|
}
|
|
|
|
|
|
for (i32 i = 0; i < num_shaders; ++i) {
|
|
struct shader_compile_desc *desc = &shader_descs[i];
|
|
struct shader_compile_result *result = &shader_results[i];
|
|
if (result->success) {
|
|
P_LogSuccessF("Finished compiling shader \"%F:%F\" in %F seconds", FmtString(desc->friendly_name), FmtString(desc->entry), FmtFloat(SecondsFromNs(result->elapsed_ns)));
|
|
if (result->errors.len > 0) {
|
|
String msg = result->errors;
|
|
P_LogWarning(msg);
|
|
}
|
|
} else {
|
|
String msg = result->errors;
|
|
P_LogError(msg);
|
|
success = 0;
|
|
}
|
|
}
|
|
|
|
if (success) {
|
|
/* Create pipeline descs */
|
|
u32 num_pipelines = 0;
|
|
struct pipeline_desc *pipeline_descs = PushDry(scratch.arena, struct pipeline_desc);
|
|
for (DictEntry *entry = G.pipeline_descs->first; entry; entry = entry->next) {
|
|
struct pipeline_desc *pipeline_desc = (struct pipeline_desc *)entry->value;
|
|
struct pipeline_desc new_pipeline_desc = *pipeline_desc;
|
|
if (EqString(pipeline_desc->name, pipeline_name)) {
|
|
if (is_rs) {
|
|
new_pipeline_desc.vs_dxc = shader_results[0].dxc;
|
|
new_pipeline_desc.ps_dxc = shader_results[1].dxc;
|
|
} else if (is_cs) {
|
|
new_pipeline_desc.cs_dxc = shader_results[0].dxc;
|
|
}
|
|
*PushStructNoZero(scratch.arena, struct pipeline_desc) = new_pipeline_desc;
|
|
++num_pipelines;
|
|
}
|
|
}
|
|
|
|
/* Recompile dirty pipelines */
|
|
if (num_pipelines > 0) {
|
|
__profn("Compile dirty pipelines");
|
|
struct pipeline **pipelines = PushStructs(scratch.arena, struct pipeline *, num_pipelines);
|
|
{
|
|
struct pipeline_alloc_job_sig sig = ZI;
|
|
sig.descs_in = pipeline_descs;
|
|
sig.pipelines_out = pipelines;
|
|
P_Counter counter = ZI;
|
|
P_Run(num_pipelines, pipeline_alloc_job, &sig, P_Pool_Inherit, P_Priority_Inherit, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
{
|
|
P_Lock lock = P_LockS(&G.pipelines_mutex);
|
|
for (u32 i = 0; i < num_pipelines; ++i) {
|
|
struct pipeline *pipeline = pipelines[i];
|
|
if (pipeline->success) {
|
|
P_LogSuccessF("Successfully compiled pipeline \"%F\" in %F seconds", FmtString(pipeline->name), FmtFloat(SecondsFromNs(pipeline->compilation_time_ns)));
|
|
if (pipeline->error.len > 0) {
|
|
String msg = StringFormat(scratch.arena, Lit("Warning while compiling pipeline \"%F\":\n%F"), FmtString(pipeline->name), FmtString(pipeline->error));
|
|
P_LogWarning(msg);
|
|
}
|
|
} else {
|
|
{
|
|
String error = pipeline->error.len > 0 ? pipeline->error : Lit("Unknown error");
|
|
String msg = StringFormat(scratch.arena, Lit("Error compiling pipeline \"%F\":\n%F"), FmtString(pipeline->name), FmtString(error));
|
|
P_LogError(msg);
|
|
}
|
|
struct pipeline *old_pipeline = (struct pipeline *)DictValueFromHash(G.top_successful_pipelines, pipeline->hash);
|
|
if (!old_pipeline) {
|
|
/* If no previously successful pipeline exists, then show a message box rather than logging since logs may not be visible to user */
|
|
String error = pipeline->error.len > 0 ? pipeline->error : Lit("Unknown error");
|
|
String msg = StringFormat(scratch.arena, Lit("Error compiling pipeline \"%F\":\n\n%F"), FmtString(pipeline->name), FmtString(error));
|
|
P_MessageBox(P_MessageBoxKind_Warning, msg);
|
|
}
|
|
|
|
}
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
pipeline_register(num_pipelines, pipelines);
|
|
}
|
|
}
|
|
|
|
EndScratch(scratch);
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Descriptor
|
|
* ========================== */
|
|
|
|
internal struct descriptor *descriptor_alloc(struct cpu_descriptor_heap *dh)
|
|
{
|
|
__prof;
|
|
struct descriptor *d = 0;
|
|
u32 index = 0;
|
|
D3D12_CPU_DESCRIPTOR_HANDLE handle = ZI;
|
|
{
|
|
P_Lock lock = P_LockE(&dh->mutex);
|
|
if (dh->first_free_descriptor) {
|
|
d = dh->first_free_descriptor;
|
|
dh->first_free_descriptor = d->next_free;
|
|
handle = d->handle;
|
|
index = d->index;
|
|
} else {
|
|
if (dh->num_descriptors_reserved >= dh->num_descriptors_capacity) {
|
|
P_Panic(Lit("Max descriptors reached in heap"));
|
|
}
|
|
d = PushStructNoZero(dh->arena, struct descriptor);
|
|
index = dh->num_descriptors_reserved++;
|
|
handle.ptr = dh->handle.ptr + (index * dh->descriptor_size);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
ZeroStruct(d);
|
|
d->heap = dh;
|
|
d->handle = handle;
|
|
d->index = index;
|
|
return d;
|
|
}
|
|
|
|
internal void descriptor_release(struct descriptor *descriptor)
|
|
{
|
|
struct cpu_descriptor_heap *dh = descriptor->heap;
|
|
P_Lock lock = P_LockE(&dh->mutex);
|
|
{
|
|
descriptor->next_free = dh->first_free_descriptor;
|
|
dh->first_free_descriptor = descriptor;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* ========================== *
|
|
* CPU descriptor heap
|
|
* ========================== */
|
|
|
|
internal struct cpu_descriptor_heap *cpu_descriptor_heap_alloc(enum D3D12_DESCRIPTOR_HEAP_TYPE type)
|
|
{
|
|
__prof;
|
|
struct cpu_descriptor_heap *dh = 0;
|
|
{
|
|
Arena *arena = AllocArena(Mebi(64));
|
|
dh = PushStruct(arena, struct cpu_descriptor_heap);
|
|
dh->arena = arena;
|
|
}
|
|
|
|
u32 num_descriptors = 0;
|
|
u32 descriptor_size = 0;
|
|
if (type < (i32)countof(G.desc_counts) && type < (i32)countof(G.desc_sizes)) {
|
|
num_descriptors = G.desc_counts[type];
|
|
descriptor_size = G.desc_sizes[type];
|
|
}
|
|
if (num_descriptors == 0 || descriptor_size == 0) {
|
|
P_Panic(Lit("Unsupported CPU descriptor type"));
|
|
}
|
|
dh->num_descriptors_capacity = num_descriptors;
|
|
dh->descriptor_size = descriptor_size;
|
|
|
|
D3D12_DESCRIPTOR_HEAP_DESC desc = ZI;
|
|
desc.Type = type;
|
|
desc.NumDescriptors = num_descriptors;
|
|
HRESULT hr = ID3D12Device_CreateDescriptorHeap(G.device, &desc, &IID_ID3D12DescriptorHeap, (void **)&dh->heap);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create CPU descriptor heap"));
|
|
}
|
|
ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(dh->heap, &dh->handle);
|
|
|
|
return dh;
|
|
}
|
|
|
|
#if 0
|
|
internal void cpu_descriptor_heap_release(struct cpu_descriptor_heap *dh)
|
|
{
|
|
/* TODO */
|
|
(UNUSED)dh;
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Fenced release
|
|
* ========================== */
|
|
|
|
internal void fenced_release(void *data, enum fenced_release_kind kind)
|
|
{
|
|
struct fenced_release_data fr = ZI;
|
|
fr.kind = kind;
|
|
fr.ptr = data;
|
|
|
|
u64 fr_targets[countof(G.fenced_release_targets)] = ZI;
|
|
|
|
/* Read current fence target values from command queues */
|
|
for (u32 i = 0; i < countof(G.command_queues); ++i) {
|
|
struct command_queue *cq = G.command_queues[i];
|
|
P_Lock lock = P_LockS(&cq->submit_fence_mutex);
|
|
{
|
|
fr_targets[i] = cq->submit_fence_target;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* PushStruct data to release queue */
|
|
{
|
|
P_Lock lock = P_LockE(&G.fenced_releases_mutex);
|
|
{
|
|
*PushStruct(G.fenced_releases_arena, struct fenced_release_data) = fr;
|
|
CopyBytes(G.fenced_release_targets, fr_targets, sizeof(fr_targets));
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* Wake evictor */
|
|
{
|
|
P_Lock lock = P_LockE(&G.evictor_wake_mutex);
|
|
{
|
|
++G.evictor_wake_gen;
|
|
P_SignalCv(&G.evictor_wake_cv, I32Max);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Resource
|
|
* ========================== */
|
|
|
|
internal struct dx12_resource *dx12_resource_alloc(D3D12_HEAP_PROPERTIES heap_props, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_DESC desc, D3D12_RESOURCE_STATES initial_state)
|
|
{
|
|
__prof;
|
|
struct dx12_resource *r = 0;
|
|
{
|
|
P_Lock lock = P_LockE(&G.resources_mutex);
|
|
if (G.first_free_resource) {
|
|
r = G.first_free_resource;
|
|
G.first_free_resource = r->next_free;
|
|
} else {
|
|
r = PushStructNoZero(G.resources_arena, struct dx12_resource);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
ZeroStruct(r);
|
|
|
|
D3D12_CLEAR_VALUE clear_value = { .Format = desc.Format, .Color = { 0 } };
|
|
D3D12_CLEAR_VALUE *clear_value_ptr = desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET ? &clear_value : 0;
|
|
HRESULT hr = ID3D12Device_CreateCommittedResource(G.device, &heap_props, heap_flags, &desc, initial_state, clear_value_ptr, &IID_ID3D12Resource, (void **)&r->resource);
|
|
if (FAILED(hr)) {
|
|
/* TODO: Don't panic */
|
|
P_Panic(Lit("Failed to create resource"));
|
|
}
|
|
|
|
r->state = initial_state;
|
|
|
|
if (desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) {
|
|
r->gpu_address = ID3D12Resource_GetGPUVirtualAddress(r->resource);
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
internal void dx12_resource_release_now(struct dx12_resource *t)
|
|
{
|
|
__prof;
|
|
|
|
/* Release descriptors */
|
|
/* TODO: Batch lock heaps */
|
|
if (t->cbv_descriptor) {
|
|
descriptor_release(t->cbv_descriptor);
|
|
}
|
|
if (t->srv_descriptor) {
|
|
descriptor_release(t->srv_descriptor);
|
|
}
|
|
if (t->uav_descriptor) {
|
|
descriptor_release(t->uav_descriptor);
|
|
}
|
|
if (t->rtv_descriptor) {
|
|
descriptor_release(t->rtv_descriptor);
|
|
}
|
|
|
|
/* Release resource */
|
|
ID3D12Resource_Release(t->resource);
|
|
|
|
/* Add to free list */
|
|
P_Lock lock = P_LockE(&G.resources_mutex);
|
|
t->next_free = G.first_free_resource;
|
|
G.first_free_resource = t;
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
void gp_resource_release(G_Resource *resource)
|
|
{
|
|
struct dx12_resource *r = (struct dx12_resource *)resource;
|
|
fenced_release(r, FENCED_RELEASE_KIND_RESOURCE);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Resource barrier
|
|
* ========================== */
|
|
|
|
struct dx12_resource_barrier_desc {
|
|
enum D3D12_RESOURCE_BARRIER_TYPE type;
|
|
struct dx12_resource *resource;
|
|
enum D3D12_RESOURCE_STATES new_state; /* 0 if type != D3D12_RESOURCE_BARRIER_TYPE_TRANSITION */
|
|
};
|
|
|
|
internal void dx12_resource_barriers(ID3D12GraphicsCommandList *cl, i32 num_descs, struct dx12_resource_barrier_desc *descs)
|
|
{
|
|
__prof;
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
|
|
i32 num_rbs = 0;
|
|
struct D3D12_RESOURCE_BARRIER *rbs = PushStructsNoZero(scratch.arena, struct D3D12_RESOURCE_BARRIER, num_descs);
|
|
for (i32 i = 0; i < num_descs; ++i) {
|
|
struct dx12_resource_barrier_desc *desc = &descs[i];
|
|
struct dx12_resource *resource = desc->resource;
|
|
enum D3D12_RESOURCE_BARRIER_TYPE type = desc->type;
|
|
if (type == D3D12_RESOURCE_BARRIER_TYPE_TRANSITION) {
|
|
enum D3D12_RESOURCE_STATES old_state = resource->state;
|
|
enum D3D12_RESOURCE_STATES new_state = desc->new_state;
|
|
if (new_state != old_state) {
|
|
struct D3D12_RESOURCE_BARRIER *rb = &rbs[num_rbs++];
|
|
ZeroStruct(rb);
|
|
rb->Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
|
rb->Flags = 0;
|
|
rb->Transition.pResource = resource->resource;
|
|
rb->Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
|
|
rb->Transition.StateBefore = old_state;
|
|
rb->Transition.StateAfter = new_state;
|
|
resource->state = new_state;
|
|
}
|
|
} else if (type == D3D12_RESOURCE_BARRIER_TYPE_UAV) {
|
|
struct D3D12_RESOURCE_BARRIER *rb = &rbs[num_rbs++];
|
|
ZeroStruct(rb);
|
|
rb->Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
|
|
rb->Flags = 0;
|
|
rb->UAV.pResource = resource->resource;
|
|
} else {
|
|
/* Unknown barrier type */
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
if (num_rbs > 0) {
|
|
ID3D12GraphicsCommandList_ResourceBarrier(cl, num_rbs, rbs);
|
|
}
|
|
|
|
EndScratch(scratch);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Command queue
|
|
* ========================== */
|
|
|
|
internal struct command_list_pool *command_list_pool_alloc(struct command_queue *cq);
|
|
|
|
internal P_JobDef(command_queue_alloc_job, job)
|
|
{
|
|
__prof;
|
|
struct command_queue_alloc_job_sig *sig = job.sig;
|
|
struct command_queue_desc *desc = &sig->descs_in[job.id];
|
|
{
|
|
struct command_queue *cq = 0;
|
|
{
|
|
Arena *arena = AllocArena(Gibi(64));
|
|
cq = PushStruct(arena, struct command_queue);
|
|
cq->arena = arena;
|
|
}
|
|
cq->desc = *desc;
|
|
|
|
D3D12_COMMAND_QUEUE_DESC dx12_desc = ZI;
|
|
dx12_desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
|
|
dx12_desc.Type = desc->type;
|
|
dx12_desc.Priority = desc->priority;
|
|
HRESULT hr = ID3D12Device_CreateCommandQueue(G.device, &dx12_desc, &IID_ID3D12CommandQueue, (void **)&cq->cq);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create command queue"));
|
|
}
|
|
|
|
hr = ID3D12Device_CreateFence(G.device, 0, 0, &IID_ID3D12Fence, (void **)&cq->submit_fence);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create command queue fence"));
|
|
}
|
|
|
|
cq->cl_pool = command_list_pool_alloc(cq);
|
|
|
|
sig->cqs_out[job.id] = cq;
|
|
}
|
|
}
|
|
|
|
internal void command_queue_release(struct command_queue *cq)
|
|
{
|
|
__prof;
|
|
/* TODO */
|
|
(UNUSED)cq;
|
|
//ID3D12CommandQueue_Release(cq->cq);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Command list
|
|
* ========================== */
|
|
|
|
internal struct command_list_pool *command_list_pool_alloc(struct command_queue *cq)
|
|
{
|
|
struct command_list_pool *pool = 0;
|
|
{
|
|
Arena *arena = AllocArena(Gibi(64));
|
|
pool = PushStruct(arena, struct command_list_pool);
|
|
pool->arena = arena;
|
|
}
|
|
pool->cq = cq;
|
|
return pool;
|
|
}
|
|
|
|
internal struct command_list *command_list_open(struct command_list_pool *pool)
|
|
{
|
|
__prof;
|
|
struct command_queue *cq = pool->cq;
|
|
u64 completed_fence_value = ID3D12Fence_GetCompletedValue(cq->submit_fence);
|
|
|
|
struct command_list *cl = 0;
|
|
struct ID3D12GraphicsCommandList *old_cl = 0;
|
|
struct ID3D12CommandAllocator *old_ca = 0;
|
|
{
|
|
P_Lock lock = P_LockE(&pool->mutex);
|
|
/* Find first command list ready for reuse */
|
|
for (struct command_list *tmp = pool->first_submitted_command_list; tmp; tmp = tmp->next_submitted) {
|
|
if (completed_fence_value >= tmp->submitted_fence_target) {
|
|
cl = tmp;
|
|
break;
|
|
}
|
|
}
|
|
if (cl) {
|
|
/* Remove from submitted list */
|
|
old_cl = cl->cl;
|
|
old_ca = cl->ca;
|
|
struct command_list *prev = cl->prev_submitted;
|
|
struct command_list *next = cl->next_submitted;
|
|
if (prev) {
|
|
prev->next_submitted = next;
|
|
} else {
|
|
pool->first_submitted_command_list = next;
|
|
}
|
|
if (next) {
|
|
next->prev_submitted = prev;
|
|
} else {
|
|
pool->last_submitted_command_list = prev;
|
|
}
|
|
} else {
|
|
cl = PushStructNoZero(pool->arena, struct command_list);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
ZeroStruct(cl);
|
|
cl->cq = cq;
|
|
cl->pool = pool;
|
|
cl->global_record_lock = P_LockS(&G.global_command_list_record_mutex);
|
|
|
|
HRESULT hr = 0;
|
|
if (old_cl) {
|
|
cl->cl = old_cl;
|
|
cl->ca = old_ca;
|
|
} else {
|
|
hr = ID3D12Device_CreateCommandAllocator(G.device, cq->desc.type, &IID_ID3D12CommandAllocator, (void **)&cl->ca);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create command allocator"));
|
|
}
|
|
|
|
hr = ID3D12Device_CreateCommandList(G.device, 0, cq->desc.type, cl->ca, 0, &IID_ID3D12GraphicsCommandList, (void **)&cl->cl);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create command list"));
|
|
}
|
|
|
|
hr = ID3D12GraphicsCommandList_Close(cl->cl);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to close command list during initialization"));
|
|
}
|
|
}
|
|
|
|
/* Reset */
|
|
hr = ID3D12CommandAllocator_Reset(cl->ca);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to reset command allocator"));
|
|
}
|
|
|
|
hr = ID3D12GraphicsCommandList_Reset(cl->cl, cl->ca, 0);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to reset command list"));
|
|
}
|
|
|
|
return cl;
|
|
}
|
|
|
|
/* TODO: Allow multiple command list submissions */
|
|
internal u64 command_list_close(struct command_list *cl)
|
|
{
|
|
__prof;
|
|
struct command_queue *cq = cl->cq;
|
|
struct command_list_pool *pool = cl->pool;
|
|
|
|
/* Close */
|
|
{
|
|
__profn("Close DX12 command list");
|
|
HRESULT hr = ID3D12GraphicsCommandList_Close(cl->cl);
|
|
if (FAILED(hr)) {
|
|
/* TODO: Don't panic */
|
|
P_Panic(Lit("Failed to close command list before execution"));
|
|
}
|
|
}
|
|
|
|
/* Submit */
|
|
u64 submit_fence_target = 0;
|
|
{
|
|
__profn("Execute");
|
|
P_Lock submit_lock = P_LockS(&G.global_submit_mutex);
|
|
P_Lock fence_lock = P_LockE(&cq->submit_fence_mutex);
|
|
{
|
|
submit_fence_target = ++cq->submit_fence_target;
|
|
ID3D12CommandQueue_ExecuteCommandLists(cq->cq, 1, (ID3D12CommandList **)&cl->cl);
|
|
ID3D12CommandQueue_Signal(cq->cq, cq->submit_fence, submit_fence_target);
|
|
}
|
|
P_Unlock(&fence_lock);
|
|
P_Unlock(&submit_lock);
|
|
}
|
|
|
|
/* Add descriptor heaps to submitted list */
|
|
{
|
|
P_Lock lock = P_LockE(&G.command_descriptor_heaps_mutex);
|
|
for (struct command_descriptor_heap *cdh = cl->first_command_descriptor_heap; cdh; cdh = cdh->next_in_command_list) {
|
|
cdh->submitted_cq = cq;
|
|
cdh->submitted_fence_target = submit_fence_target;
|
|
if (G.last_submitted_command_descriptor_heap) {
|
|
G.last_submitted_command_descriptor_heap->next_submitted = cdh;
|
|
} else {
|
|
G.first_submitted_command_descriptor_heap = cdh;
|
|
}
|
|
G.last_submitted_command_descriptor_heap = cdh;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* Add command buffers to submitted list */
|
|
{
|
|
P_Lock lock = P_LockE(&G.command_buffers_mutex);
|
|
for (struct command_buffer *cb = cl->first_command_buffer; cb; cb = cb->next_in_command_list) {
|
|
struct command_buffer_group *group = cb->group;
|
|
cb->submitted_cq = cq;
|
|
cb->submitted_fence_target = submit_fence_target;
|
|
if (group->last_submitted) {
|
|
group->last_submitted->next_submitted = cb;
|
|
} else {
|
|
group->first_submitted = cb;
|
|
}
|
|
group->last_submitted = cb;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* Add command list to pool submitted list */
|
|
P_Unlock(&cl->global_record_lock);
|
|
cl->submitted_fence_target = submit_fence_target;
|
|
{
|
|
P_Lock lock = P_LockE(&pool->mutex);
|
|
if (pool->last_submitted_command_list) {
|
|
pool->last_submitted_command_list->next_submitted = cl;
|
|
} else {
|
|
pool->first_submitted_command_list = cl;
|
|
}
|
|
pool->last_submitted_command_list = cl;
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
return submit_fence_target;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Command descriptor heap (GPU / shader visible descriptor heap)
|
|
* ========================== */
|
|
|
|
internal struct command_descriptor_heap *command_list_push_descriptor_heap(struct command_list *cl, struct cpu_descriptor_heap *dh_cpu)
|
|
{
|
|
__prof;
|
|
Assert(dh_cpu->type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); /* Src heap must have expected type */
|
|
|
|
/* Allocate GPU heap */
|
|
struct command_descriptor_heap *cdh = 0;
|
|
ID3D12DescriptorHeap *old_heap = 0;
|
|
D3D12_CPU_DESCRIPTOR_HANDLE old_start_cpu_handle = ZI;
|
|
D3D12_GPU_DESCRIPTOR_HANDLE old_start_gpu_handle = ZI;
|
|
{
|
|
P_Lock lock = P_LockE(&G.command_descriptor_heaps_mutex);
|
|
/* Find first heap ready for reuse */
|
|
for (struct command_descriptor_heap *tmp = G.first_submitted_command_descriptor_heap; tmp; tmp = tmp->next_submitted) {
|
|
/* TODO: Cache completed fence values */
|
|
u64 completed_fence_value = ID3D12Fence_GetCompletedValue(tmp->submitted_cq->submit_fence);
|
|
if (completed_fence_value >= tmp->submitted_fence_target) {
|
|
cdh = tmp;
|
|
break;
|
|
}
|
|
}
|
|
if (cdh) {
|
|
/* Remove from submitted list */
|
|
old_heap = cdh->heap;
|
|
old_start_cpu_handle = cdh->start_cpu_handle;
|
|
old_start_gpu_handle = cdh->start_gpu_handle;
|
|
struct command_descriptor_heap *prev = cdh->prev_submitted;
|
|
struct command_descriptor_heap *next = cdh->next_submitted;
|
|
if (prev) {
|
|
prev->next_submitted = next;
|
|
} else {
|
|
G.first_submitted_command_descriptor_heap = next;
|
|
}
|
|
if (next) {
|
|
next->prev_submitted = prev;
|
|
} else {
|
|
G.last_submitted_command_descriptor_heap = prev;
|
|
}
|
|
} else {
|
|
/* No available heap available for reuse, allocate new */
|
|
cdh = PushStructNoZero(G.command_descriptor_heaps_arena, struct command_descriptor_heap);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
ZeroStruct(cdh);
|
|
|
|
if (old_heap) {
|
|
cdh->heap = old_heap;
|
|
cdh->start_cpu_handle = old_start_cpu_handle;
|
|
cdh->start_gpu_handle = old_start_gpu_handle;
|
|
} else {
|
|
D3D12_DESCRIPTOR_HEAP_DESC desc = ZI;
|
|
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
|
|
desc.NumDescriptors = DX12_NUM_CBV_SRV_UAV_DESCRIPTORS;
|
|
desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
|
|
HRESULT hr = ID3D12Device_CreateDescriptorHeap(G.device, &desc, &IID_ID3D12DescriptorHeap, (void **)&cdh->heap);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create GPU descriptor heap"));
|
|
}
|
|
ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cdh->heap, &cdh->start_cpu_handle);
|
|
ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(cdh->heap, &cdh->start_gpu_handle);
|
|
}
|
|
|
|
/* CopyCPU heap */
|
|
{
|
|
P_Lock lock = P_LockS(&dh_cpu->mutex);
|
|
ID3D12Device_CopyDescriptorsSimple(G.device, dh_cpu->num_descriptors_reserved, cdh->start_cpu_handle, dh_cpu->handle, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* Insert into command list */
|
|
cdh->next_in_command_list = cl->first_command_descriptor_heap;
|
|
cl->first_command_descriptor_heap = cdh;
|
|
|
|
return cdh;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Command buffer
|
|
* ========================== */
|
|
|
|
internal u64 command_buffer_hash_from_size(u64 size)
|
|
{
|
|
u64 hash = RandU64FromSeed(size);
|
|
return hash;
|
|
}
|
|
|
|
internal u64 align_up_pow2(u64 v)
|
|
{
|
|
u64 result = 0;
|
|
if (v > 0) {
|
|
result = v - 1;
|
|
result |= result >> 1;
|
|
result |= result >> 2;
|
|
result |= result >> 4;
|
|
result |= result >> 8;
|
|
result |= result >> 16;
|
|
result |= result >> 32;
|
|
++result;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#define command_list_push_buffer(cl, count, elems) _command_list_push_buffer((cl), count * ((elems) ? sizeof(*(elems)) : 0), (elems), (elems) ? sizeof(*(elems)) : 1)
|
|
internal struct command_buffer *_command_list_push_buffer(struct command_list *cl, u64 data_len, void *data, u64 data_stride)
|
|
{
|
|
__prof;
|
|
|
|
/* Data length should be a multiple of stride */
|
|
Assert(data_len % data_stride == 0);
|
|
|
|
/* Determine size */
|
|
u64 size = MaxU64(DX12_COMMAND_BUFFER_MIN_SIZE, align_up_pow2(data_len));
|
|
|
|
/* Allocate buffer */
|
|
struct command_buffer_group *cb_group = 0;
|
|
struct command_buffer *cb = 0;
|
|
struct dx12_resource *r = 0;
|
|
{
|
|
P_Lock lock = P_LockE(&G.command_buffers_mutex);
|
|
|
|
{
|
|
u64 group_hash = command_buffer_hash_from_size(size);
|
|
DictEntry *cb_group_entry = EnsureDictEntry(G.command_buffers_arena, G.command_buffers_dict, group_hash);
|
|
cb_group = (struct command_buffer_group *)cb_group_entry->value;
|
|
if (!cb_group) {
|
|
/* Create group */
|
|
cb_group = PushStruct(G.command_buffers_arena, struct command_buffer_group);
|
|
cb_group_entry->value = (u64)cb_group;
|
|
}
|
|
}
|
|
/* Find first command buffer ready for reuse */
|
|
for (struct command_buffer *tmp = cb_group->first_submitted; tmp; tmp = tmp->next_submitted) {
|
|
/* TODO: Cache completed fence values */
|
|
u64 completed_fence_value = ID3D12Fence_GetCompletedValue(tmp->submitted_cq->submit_fence);
|
|
if (completed_fence_value >= tmp->submitted_fence_target) {
|
|
cb = tmp;
|
|
break;
|
|
}
|
|
}
|
|
if (cb) {
|
|
/* Remove from submitted list */
|
|
r = cb->resource;
|
|
struct command_buffer *prev = cb->prev_submitted;
|
|
struct command_buffer *next = cb->next_submitted;
|
|
if (prev) {
|
|
prev->next_submitted = next;
|
|
} else {
|
|
cb_group->first_submitted = next;
|
|
}
|
|
if (next) {
|
|
next->prev_submitted = prev;
|
|
} else {
|
|
cb_group->last_submitted = prev;
|
|
}
|
|
} else {
|
|
/* Allocate new */
|
|
cb = PushStructNoZero(G.command_buffers_arena, struct command_buffer);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
ZeroStruct(cb);
|
|
cb->group = cb_group;
|
|
cb->size = data_len;
|
|
|
|
/* Create upload heap */
|
|
if (!r) {
|
|
D3D12_HEAP_PROPERTIES heap_props = { .Type = D3D12_HEAP_TYPE_UPLOAD };
|
|
heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
|
|
D3D12_HEAP_FLAGS heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
|
|
|
|
D3D12_RESOURCE_DESC desc = ZI;
|
|
desc.Flags = 0;
|
|
desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
|
|
desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
|
|
desc.Format = DXGI_FORMAT_UNKNOWN;
|
|
desc.Alignment = 0;
|
|
desc.Width = size;
|
|
desc.Height = 1;
|
|
desc.DepthOrArraySize = 1;
|
|
desc.MipLevels = 1;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.SampleDesc.Quality = 0;
|
|
D3D12_RESOURCE_STATES initial_state = D3D12_RESOURCE_STATE_GENERIC_READ;
|
|
|
|
r = dx12_resource_alloc(heap_props, heap_flags, desc, initial_state);
|
|
r->srv_descriptor = descriptor_alloc(G.cbv_srv_uav_heap);
|
|
}
|
|
cb->resource = r;
|
|
|
|
{
|
|
struct D3D12_SHADER_RESOURCE_VIEW_DESC desc = ZI;
|
|
desc.Format = DXGI_FORMAT_UNKNOWN;
|
|
desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
|
|
desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
|
|
desc.Buffer.FirstElement = 0;
|
|
desc.Buffer.NumElements = MaxU32(data_len / data_stride, 1);
|
|
desc.Buffer.StructureByteStride = data_stride;
|
|
desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_NONE;
|
|
ID3D12Device_CreateShaderResourceView(G.device, r->resource, &desc, r->srv_descriptor->handle);
|
|
}
|
|
|
|
/* Write data to resource */
|
|
{
|
|
D3D12_RANGE read_range = ZI;
|
|
void *dst = 0;
|
|
HRESULT hr = ID3D12Resource_Map(cb->resource->resource, 0, &read_range, &dst);
|
|
if (FAILED(hr) || !dst) {
|
|
/* TODO: Don't panic */
|
|
P_Panic(Lit("Failed to map command buffer resource"));
|
|
}
|
|
CopyBytes(dst, data, data_len);
|
|
ID3D12Resource_Unmap(cb->resource->resource, 0, 0);
|
|
}
|
|
|
|
/* Insert into command list */
|
|
cb->next_in_command_list = cl->first_command_buffer;
|
|
cl->first_command_buffer = cb;
|
|
|
|
return cb;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Wait job
|
|
* ========================== */
|
|
|
|
struct dx12_wait_fence_job_sig {
|
|
ID3D12Fence *fence;
|
|
u64 target;
|
|
};
|
|
|
|
internal P_JobDef(dx12_wait_fence_job, job)
|
|
{
|
|
__prof;
|
|
struct dx12_wait_fence_job_sig *sig = job.sig;
|
|
ID3D12Fence *fence = sig->fence;
|
|
u64 target = sig->target;
|
|
if (ID3D12Fence_GetCompletedValue(fence) < target) {
|
|
/* TODO: Pool events */
|
|
HANDLE event = CreateEvent(0, 0, 0, 0);
|
|
ID3D12Fence_SetEventOnCompletion(sig->fence, sig->target, event);
|
|
WaitForSingleObject(event, INFINITE);
|
|
CloseHandle(event);
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Texture
|
|
* ========================== */
|
|
|
|
G_Resource *gp_texture_alloc(G_TextureFormat format, u32 flags, Vec2I32 size, void *initial_data)
|
|
{
|
|
__prof;
|
|
if (size.x <= 0 || size.y <= 0) {
|
|
P_Panic(Lit("Tried to create texture with dimension <= 0"));
|
|
}
|
|
LocalPersist const DXGI_FORMAT formats[] = {
|
|
[GP_TEXTURE_FORMAT_R8_UNORM] = DXGI_FORMAT_R8_UNORM,
|
|
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM] = DXGI_FORMAT_R8G8B8A8_UNORM,
|
|
[GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
|
|
[GP_TEXTURE_FORMAT_R16G16B16A16_FLOAT] = DXGI_FORMAT_R16G16B16A16_FLOAT
|
|
};
|
|
|
|
DXGI_FORMAT dxgi_format = ZI;
|
|
if (format >= 0 && format < (i32)countof(formats)) {
|
|
dxgi_format = formats[format];
|
|
}
|
|
if (format == 0) {
|
|
P_Panic(Lit("Tried to create texture with unknown format"));
|
|
}
|
|
|
|
D3D12_HEAP_PROPERTIES heap_props = { .Type = D3D12_HEAP_TYPE_DEFAULT };
|
|
heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
|
|
D3D12_HEAP_FLAGS heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
|
|
|
|
D3D12_RESOURCE_DESC desc = ZI;
|
|
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
|
|
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
|
|
desc.Format = dxgi_format;
|
|
desc.Alignment = 0;
|
|
desc.Width = size.x;
|
|
desc.Height = size.y;
|
|
desc.DepthOrArraySize = 1;
|
|
desc.MipLevels = 1;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.SampleDesc.Quality = 0;
|
|
|
|
D3D12_RESOURCE_STATES initial_state = D3D12_RESOURCE_STATE_COPY_DEST;
|
|
|
|
struct dx12_resource *r = dx12_resource_alloc(heap_props, heap_flags, desc, initial_state);
|
|
r->texture_size = size;
|
|
r->srv_descriptor = descriptor_alloc(G.cbv_srv_uav_heap);
|
|
ID3D12Device_CreateShaderResourceView(G.device, r->resource, 0, r->srv_descriptor->handle);
|
|
if (flags & GP_TEXTURE_FLAG_TARGETABLE) {
|
|
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
|
|
r->uav_descriptor = descriptor_alloc(G.cbv_srv_uav_heap);
|
|
r->rtv_descriptor = descriptor_alloc(G.rtv_heap);
|
|
ID3D12Device_CreateUnorderedAccessView(G.device, r->resource, 0, 0, r->uav_descriptor->handle);
|
|
ID3D12Device_CreateRenderTargetView(G.device, r->resource, 0, r->rtv_descriptor->handle);
|
|
}
|
|
|
|
/* Upload texture */
|
|
if (initial_data) {
|
|
/* TODO: Make wait optional */
|
|
P_Counter counter = ZI;
|
|
struct dx12_upload_job_sig sig = ZI;
|
|
sig.resource = r;
|
|
sig.data = initial_data;
|
|
P_Run(1, dx12_upload_job, &sig, P_Pool_Inherit, P_Priority_Inherit, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
|
|
return (G_Resource *)r;
|
|
}
|
|
|
|
Vec2I32 gp_texture_get_size(G_Resource *resource)
|
|
{
|
|
struct dx12_resource *r = (struct dx12_resource *)resource;
|
|
return r->texture_size;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Upload
|
|
* ========================== */
|
|
|
|
internal P_JobDef(dx12_upload_job, job)
|
|
{
|
|
struct dx12_upload_job_sig *sig = job.sig;
|
|
struct dx12_resource *r = sig->resource;
|
|
void *data = sig->data;
|
|
|
|
Assert(r->state == D3D12_RESOURCE_STATE_COPY_DEST);
|
|
|
|
D3D12_RESOURCE_DESC desc = ZI;
|
|
ID3D12Resource_GetDesc(r->resource, &desc);
|
|
|
|
{
|
|
u64 upload_size = 0;
|
|
u64 upload_row_size = 0;
|
|
u32 upload_num_rows = 0;
|
|
D3D12_PLACED_SUBRESOURCE_FOOTPRINT placed_footprint = ZI;
|
|
ID3D12Device_GetCopyableFootprints(G.device, &desc, 0, 1, 0, &placed_footprint, &upload_num_rows, &upload_row_size, &upload_size);
|
|
D3D12_SUBRESOURCE_FOOTPRINT footprint = placed_footprint.Footprint;
|
|
|
|
/* Create upload heap */
|
|
struct dx12_resource *upload = 0;
|
|
{
|
|
D3D12_HEAP_PROPERTIES upload_heap_props = { .Type = D3D12_HEAP_TYPE_UPLOAD };
|
|
upload_heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
upload_heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
|
|
D3D12_HEAP_FLAGS upload_heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
|
|
|
|
D3D12_RESOURCE_DESC upload_desc = ZI;
|
|
upload_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
|
|
upload_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
|
|
upload_desc.Format = DXGI_FORMAT_UNKNOWN;
|
|
upload_desc.Alignment = 0;
|
|
upload_desc.Width = upload_size;
|
|
upload_desc.Height = 1;
|
|
upload_desc.DepthOrArraySize = 1;
|
|
upload_desc.MipLevels = 1;
|
|
upload_desc.SampleDesc.Count = 1;
|
|
upload_desc.SampleDesc.Quality = 0;
|
|
D3D12_RESOURCE_STATES upload_initial_state = D3D12_RESOURCE_STATE_GENERIC_READ;
|
|
|
|
upload = dx12_resource_alloc(upload_heap_props, upload_heap_flags, upload_desc, upload_initial_state);
|
|
}
|
|
|
|
struct command_queue *cq = G.command_queues[DX12_QUEUE_COPY_BACKGROUND];
|
|
struct command_list *cl = command_list_open(cq->cl_pool);
|
|
{
|
|
/* Copyto upload heap */
|
|
{
|
|
D3D12_RANGE read_range = ZI;
|
|
void *mapped = 0;
|
|
HRESULT hr = ID3D12Resource_Map(upload->resource, 0, &read_range, &mapped);
|
|
if (FAILED(hr) || !mapped) {
|
|
/* TODO: Don't panic */
|
|
P_Panic(Lit("Failed to map texture upload resource"));
|
|
}
|
|
u8 *dst = (u8 *)mapped + placed_footprint.Offset;
|
|
u8 *src = data;
|
|
|
|
u32 z_size = upload_row_size * upload_num_rows;
|
|
|
|
for (u32 z = 0; z < desc.DepthOrArraySize; ++z) {
|
|
u32 z_offset = z * z_size;
|
|
for (u32 y = 0; y < upload_num_rows; ++y) {
|
|
CopyBytes(dst + y * footprint.RowPitch + z_offset, src + y * upload_row_size + z_offset, upload_row_size);
|
|
}
|
|
}
|
|
ID3D12Resource_Unmap(upload->resource, 0, 0);
|
|
}
|
|
|
|
/* Copyfrom upload heap to texture */
|
|
{
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Upload texture", Rgb32F(0.2, 0.5, 0.2));
|
|
D3D12_TEXTURE_COPY_LOCATION dst_loc = {
|
|
.pResource = r->resource,
|
|
.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
|
|
.SubresourceIndex = 0,
|
|
};
|
|
|
|
D3D12_TEXTURE_COPY_LOCATION src_loc = {
|
|
.pResource = upload->resource,
|
|
.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
|
|
.PlacedFootprint = placed_footprint,
|
|
};
|
|
|
|
ID3D12GraphicsCommandList_CopyTextureRegion(cl->cl, &dst_loc, 0, 0, 0, &src_loc, 0);
|
|
}
|
|
} u64 fence_target = command_list_close(cl);
|
|
|
|
/* Wait on fence so we know it's safe to release upload heap */
|
|
if (ID3D12Fence_GetCompletedValue(cq->submit_fence) < fence_target) {
|
|
struct dx12_wait_fence_job_sig wait_sig = ZI;
|
|
wait_sig.fence = cq->submit_fence;
|
|
wait_sig.target = fence_target;
|
|
P_Counter counter = ZI;
|
|
P_Run(1, dx12_wait_fence_job, &wait_sig, P_Pool_Floating, P_Priority_Low, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
|
|
/* Release upload heap now */
|
|
dx12_resource_release_now(upload);
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Run utils
|
|
* ========================== */
|
|
|
|
internal void command_list_set_pipeline(struct command_list *cl, struct pipeline *pipeline)
|
|
{
|
|
ID3D12GraphicsCommandList_SetPipelineState(cl->cl, pipeline->pso);
|
|
if (pipeline->is_gfx) {
|
|
ID3D12GraphicsCommandList_SetGraphicsRootSignature(cl->cl, pipeline->rootsig);
|
|
} else {
|
|
ID3D12GraphicsCommandList_SetComputeRootSignature(cl->cl, pipeline->rootsig);
|
|
}
|
|
cl->cur_pipeline = pipeline;
|
|
}
|
|
|
|
internal void command_list_set_sig(struct command_list *cl, void *src, u32 size)
|
|
{
|
|
__prof;
|
|
Assert(size % 16 == 0); /* Root constant structs must pad to 16 bytes */
|
|
Assert(size <= 256); /* Only 64 32-bit root constants allowed in signature */
|
|
u32 num32bit = size / 4;
|
|
b32 is_gfx = cl->cur_pipeline->is_gfx;
|
|
for (u32 i = 0; i < num32bit; ++i) {
|
|
u32 val = 0;
|
|
CopyBytes(&val, (((u32 *)src) + i), 4);
|
|
if (is_gfx) {
|
|
ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstant(cl->cl, 0, val, i);
|
|
} else {
|
|
ID3D12GraphicsCommandList_SetComputeRoot32BitConstant(cl->cl, 0, val, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal struct D3D12_VIEWPORT viewport_from_rect(Rect r)
|
|
{
|
|
struct D3D12_VIEWPORT viewport = ZI;
|
|
viewport.TopLeftX = r.x;
|
|
viewport.TopLeftY = r.y;
|
|
viewport.Width = r.width;
|
|
viewport.Height = r.height;
|
|
viewport.MinDepth = 0.0f;
|
|
viewport.MaxDepth = 1.0f;
|
|
return viewport;
|
|
}
|
|
|
|
internal D3D12_RECT scissor_from_rect(Rect r)
|
|
{
|
|
D3D12_RECT scissor = ZI;
|
|
scissor.left = r.x;
|
|
scissor.top = r.y;
|
|
scissor.right = r.x + r.width;
|
|
scissor.bottom = r.y + r.height;
|
|
return scissor;
|
|
}
|
|
|
|
internal D3D12_VERTEX_BUFFER_VIEW vbv_from_command_buffer(struct command_buffer *cb, u32 vertex_size)
|
|
{
|
|
D3D12_VERTEX_BUFFER_VIEW vbv = ZI;
|
|
vbv.BufferLocation = cb->resource->gpu_address;
|
|
vbv.SizeInBytes = cb->size;
|
|
vbv.StrideInBytes = vertex_size;
|
|
return vbv;
|
|
}
|
|
|
|
internal D3D12_INDEX_BUFFER_VIEW ibv_from_command_buffer(struct command_buffer *cb, DXGI_FORMAT format)
|
|
{
|
|
D3D12_INDEX_BUFFER_VIEW ibv = ZI;
|
|
ibv.BufferLocation = cb->resource->gpu_address;
|
|
ibv.Format = format;
|
|
ibv.SizeInBytes = cb->size;
|
|
return ibv;
|
|
}
|
|
|
|
internal struct dx12_resource *gbuff_alloc(DXGI_FORMAT format, Vec2I32 size, D3D12_RESOURCE_STATES initial_state)
|
|
{
|
|
__prof;
|
|
D3D12_HEAP_PROPERTIES heap_props = { .Type = D3D12_HEAP_TYPE_DEFAULT };
|
|
heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
|
|
D3D12_HEAP_FLAGS heap_flags = D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
|
|
|
|
D3D12_RESOURCE_DESC desc = ZI;
|
|
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
|
|
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
|
|
desc.Format = format;
|
|
desc.Alignment = 0;
|
|
desc.Width = size.x;
|
|
desc.Height = size.y;
|
|
desc.DepthOrArraySize = 1;
|
|
desc.MipLevels = 1;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.SampleDesc.Quality = 0;
|
|
desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
|
|
|
|
struct dx12_resource *r = dx12_resource_alloc(heap_props, heap_flags, desc, initial_state);
|
|
r->srv_descriptor = descriptor_alloc(G.cbv_srv_uav_heap);
|
|
r->uav_descriptor = descriptor_alloc(G.cbv_srv_uav_heap);
|
|
r->rtv_descriptor = descriptor_alloc(G.rtv_heap);
|
|
ID3D12Device_CreateShaderResourceView(G.device, r->resource, 0, r->srv_descriptor->handle);
|
|
ID3D12Device_CreateUnorderedAccessView(G.device, r->resource, 0, 0, r->uav_descriptor->handle);
|
|
ID3D12Device_CreateRenderTargetView(G.device, r->resource, 0, r->rtv_descriptor->handle);
|
|
|
|
r->texture_size = size;
|
|
return r;
|
|
}
|
|
|
|
/* Calculate the view projection matrix */
|
|
Inline Mat4x4 calculate_vp(Xform view, f32 viewport_width, f32 viewport_height)
|
|
{
|
|
Mat4x4 projection = Mat4x4FromOrtho(0.0, viewport_width, viewport_height, 0.0, -1.0, 1.0);
|
|
Mat4x4 view4x4 = Mat4x4FromXform(view);
|
|
return MulMat4x4(projection, view4x4);
|
|
}
|
|
|
|
internal D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle_from_descriptor(struct descriptor *descriptor, struct command_descriptor_heap *cdh)
|
|
{
|
|
struct D3D12_GPU_DESCRIPTOR_HANDLE result = ZI;
|
|
result.ptr = cdh->start_gpu_handle.ptr + descriptor->index * G.desc_sizes[descriptor->heap->type];
|
|
return result;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Render sig
|
|
* ========================== */
|
|
|
|
struct render_sig {
|
|
Arena *arena;
|
|
RandState rand;
|
|
u32 frame_index;
|
|
|
|
/* Material instances */
|
|
u32 num_material_instance_descs;
|
|
Arena *material_instance_descs_arena;
|
|
|
|
/* Ui instances */
|
|
u32 num_ui_rect_instance_descs;
|
|
Arena *ui_rect_instance_descs_arena;
|
|
|
|
/* UI shapes */
|
|
Arena *ui_shape_verts_arena;
|
|
Arena *ui_shape_indices_arena;
|
|
|
|
/* Grids */
|
|
u32 num_material_grid_descs;
|
|
Arena *material_grid_descs_arena;
|
|
|
|
/* Resources */
|
|
struct dx12_resource *albedo;
|
|
struct dx12_resource *emittance;
|
|
struct dx12_resource *emittance_flood_read;
|
|
struct dx12_resource *emittance_flood_target;
|
|
struct dx12_resource *shade_read;
|
|
struct dx12_resource *shade_target;
|
|
struct dx12_resource *ui_target;
|
|
};
|
|
|
|
struct material_instance_desc {
|
|
Xform xf;
|
|
u32 texture_id;
|
|
ClipRect clip;
|
|
u32 tint;
|
|
b32 is_light;
|
|
Vec3 light_emittance;
|
|
u32 grid_id;
|
|
};
|
|
|
|
struct ui_rect_instance_desc {
|
|
Xform xf;
|
|
u32 texture_id;
|
|
ClipRect clip;
|
|
u32 tint;
|
|
};
|
|
|
|
struct material_grid_desc {
|
|
f32 line_thickness;
|
|
f32 line_spacing;
|
|
Vec2 offset;
|
|
u32 bg0_color;
|
|
u32 bg1_color;
|
|
u32 line_color;
|
|
u32 x_color;
|
|
u32 y_color;
|
|
};
|
|
|
|
internal struct render_sig *render_sig_alloc(void)
|
|
{
|
|
__prof;
|
|
struct render_sig *sig = 0;
|
|
{
|
|
Arena *arena = AllocArena(Mebi(64));
|
|
sig = PushStruct(arena, struct render_sig);
|
|
sig->arena = arena;
|
|
}
|
|
|
|
sig->material_instance_descs_arena = AllocArena(Gibi(1));
|
|
sig->material_grid_descs_arena = AllocArena(Gibi(1));
|
|
sig->ui_rect_instance_descs_arena = AllocArena(Gibi(1));
|
|
sig->ui_shape_verts_arena = AllocArena(Gibi(1));
|
|
sig->ui_shape_indices_arena = AllocArena(Gibi(1));
|
|
|
|
return sig;
|
|
}
|
|
|
|
internal void render_sig_reset(struct render_sig *sig)
|
|
{
|
|
__prof;
|
|
|
|
/* Reset material instances */
|
|
sig->num_material_instance_descs = 0;
|
|
ResetArena(sig->material_instance_descs_arena);
|
|
|
|
/* Reset UI rect instances */
|
|
sig->num_ui_rect_instance_descs = 0;
|
|
ResetArena(sig->ui_rect_instance_descs_arena);
|
|
|
|
/* Reset shapes */
|
|
ResetArena(sig->ui_shape_verts_arena);
|
|
ResetArena(sig->ui_shape_indices_arena);
|
|
|
|
/* Reset grids */
|
|
sig->num_material_grid_descs = 0;
|
|
ResetArena(sig->material_grid_descs_arena);
|
|
}
|
|
|
|
G_RenderSig *gp_render_sig_alloc(void)
|
|
{
|
|
__prof;
|
|
struct render_sig *sig = render_sig_alloc();
|
|
return (G_RenderSig *)sig;
|
|
}
|
|
|
|
u32 gp_push_render_cmd(G_RenderSig *render_sig, G_RenderCmdDesc *cmd_desc)
|
|
{
|
|
u32 ret = 0;
|
|
struct render_sig *sig = (struct render_sig *)render_sig;
|
|
if (sig) {
|
|
switch (cmd_desc->kind) {
|
|
default: break;
|
|
|
|
case GP_RENDER_CMD_KIND_DRAW_MATERIAL:
|
|
{
|
|
struct dx12_resource *texture = (struct dx12_resource *)cmd_desc->material.texture;
|
|
struct material_instance_desc *instance_desc = PushStruct(sig->material_instance_descs_arena, struct material_instance_desc);
|
|
instance_desc->xf = cmd_desc->material.xf;
|
|
instance_desc->texture_id = texture ? texture->srv_descriptor->index : 0xFFFFFFFF;
|
|
instance_desc->clip = cmd_desc->material.clip;
|
|
instance_desc->tint = cmd_desc->material.tint;
|
|
instance_desc->is_light = cmd_desc->material.is_light;
|
|
instance_desc->light_emittance = cmd_desc->material.light_emittance;
|
|
instance_desc->grid_id = cmd_desc->material.grid_cmd_id - 1;
|
|
ret = ++sig->num_material_instance_descs;
|
|
} break;
|
|
|
|
case GP_RENDER_CMD_KIND_DRAW_UI_RECT:
|
|
{
|
|
struct dx12_resource *texture = (struct dx12_resource *)cmd_desc->ui_rect.texture;
|
|
struct ui_rect_instance_desc *instance_desc = PushStruct(sig->ui_rect_instance_descs_arena, struct ui_rect_instance_desc);
|
|
instance_desc->xf = cmd_desc->ui_rect.xf;
|
|
instance_desc->texture_id = texture ? texture->srv_descriptor->index : 0xFFFFFFFF;
|
|
instance_desc->clip = cmd_desc->ui_rect.clip;
|
|
instance_desc->tint = cmd_desc->ui_rect.tint;
|
|
ret = ++sig->num_ui_rect_instance_descs;
|
|
} break;
|
|
|
|
case GP_RENDER_CMD_KIND_DRAW_UI_SHAPE:
|
|
{
|
|
u32 color = cmd_desc->ui_shape.color;
|
|
struct k_shape_vert *verts = PushStructsNoZero(sig->ui_shape_verts_arena, struct k_shape_vert, cmd_desc->ui_shape.vertices.count);
|
|
u32 *indices = PushStructsNoZero(sig->ui_shape_indices_arena, u32, cmd_desc->ui_shape.indices.count);
|
|
for (u32 i = 0; i < cmd_desc->ui_shape.vertices.count; ++i) {
|
|
struct k_shape_vert *v = &verts[i];
|
|
v->pos = K_Float2FromV2(cmd_desc->ui_shape.vertices.points[i]);
|
|
v->color_srgb = K_UintFromU32(color);
|
|
}
|
|
u32 vert_offset = verts - (struct k_shape_vert *)ArenaBase(sig->ui_shape_verts_arena);
|
|
for (u32 i = 0; i < cmd_desc->ui_shape.indices.count; ++i) {
|
|
indices[i] = cmd_desc->ui_shape.indices.indices[i] + vert_offset;
|
|
}
|
|
} break;
|
|
|
|
case GP_RENDER_CMD_KIND_PUSH_GRID:
|
|
{
|
|
struct material_grid_desc *grid_desc = PushStruct(sig->material_grid_descs_arena, struct material_grid_desc);
|
|
grid_desc->line_thickness = cmd_desc->grid.line_thickness;
|
|
grid_desc->line_spacing = cmd_desc->grid.line_spacing;
|
|
grid_desc->offset = cmd_desc->grid.offset;
|
|
grid_desc->bg0_color = cmd_desc->grid.bg0_color;
|
|
grid_desc->bg1_color = cmd_desc->grid.bg1_color;
|
|
grid_desc->line_color = cmd_desc->grid.line_color;
|
|
grid_desc->x_color = cmd_desc->grid.x_color;
|
|
grid_desc->y_color = cmd_desc->grid.y_color;
|
|
ret = ++sig->num_material_grid_descs;
|
|
} break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Render
|
|
* ========================== */
|
|
|
|
G_Resource *gp_run_render(G_RenderSig *gp_render_sig, G_RenderParams params)
|
|
{
|
|
__prof;
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
struct render_sig *rsig = (struct render_sig *)gp_render_sig;
|
|
++rsig->frame_index;
|
|
|
|
Vec2I32 ui_size = VEC2I32(MaxI32(params.ui_size.x, 1), MaxI32(params.ui_size.y, 1));
|
|
Vec2I32 render_size = VEC2I32(MaxI32(params.render_size.x, 1), MaxI32(params.render_size.y, 1));
|
|
Xform world_to_render_xf = params.world_to_render_xf;
|
|
Xform render_to_ui_xf = params.render_to_ui_xf;
|
|
|
|
Rect ui_viewport = RectFromVec2(VEC2(0, 0), VEC2(ui_size.x, ui_size.y));
|
|
Rect render_viewport = RectFromVec2(VEC2(0, 0), VEC2(render_size.x, render_size.y));
|
|
|
|
|
|
/* Allocate render buffers */
|
|
if (rsig->shade_target && !EqVec2I32(render_size, rsig->shade_target->texture_size)) {
|
|
__profn("Release sig resources");
|
|
fenced_release(rsig->albedo, FENCED_RELEASE_KIND_RESOURCE);
|
|
fenced_release(rsig->emittance, FENCED_RELEASE_KIND_RESOURCE);
|
|
fenced_release(rsig->emittance_flood_read, FENCED_RELEASE_KIND_RESOURCE);
|
|
fenced_release(rsig->emittance_flood_target, FENCED_RELEASE_KIND_RESOURCE);
|
|
fenced_release(rsig->shade_read, FENCED_RELEASE_KIND_RESOURCE);
|
|
fenced_release(rsig->shade_target, FENCED_RELEASE_KIND_RESOURCE);
|
|
rsig->shade_target = 0;
|
|
}
|
|
if (!rsig->shade_target) {
|
|
__profn("Allocate sig resources");
|
|
rsig->albedo = gbuff_alloc(DXGI_FORMAT_R8G8B8A8_UNORM, render_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
|
|
rsig->emittance = gbuff_alloc(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
|
|
rsig->emittance_flood_read = gbuff_alloc(DXGI_FORMAT_R16G16_UINT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
|
|
rsig->emittance_flood_target = gbuff_alloc(DXGI_FORMAT_R16G16_UINT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
|
|
rsig->shade_read = gbuff_alloc(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
|
|
rsig->shade_target = gbuff_alloc(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
|
|
}
|
|
|
|
/* Allocate ui buffers */
|
|
if (rsig->ui_target && !EqVec2I32(ui_size, rsig->ui_target->texture_size)) {
|
|
fenced_release(rsig->ui_target, FENCED_RELEASE_KIND_RESOURCE);
|
|
rsig->ui_target = 0;
|
|
}
|
|
if (!rsig->ui_target) {
|
|
rsig->ui_target = gbuff_alloc(DXGI_FORMAT_R8G8B8A8_UNORM, ui_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
|
|
}
|
|
|
|
struct pipeline_scope *pipeline_scope = pipeline_scope_begin();
|
|
struct pipeline *material_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_material"));
|
|
struct pipeline *flood_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_flood"));
|
|
struct pipeline *shade_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_shade"));
|
|
struct pipeline *blit_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_blit"));
|
|
struct pipeline *ui_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_ui"));
|
|
struct pipeline *shape_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_shape"));
|
|
struct command_queue *cq = G.command_queues[DX12_QUEUE_DIRECT];
|
|
struct command_list *cl = command_list_open(cq->cl_pool);
|
|
{
|
|
__profn("Run render");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Run render", Rgb32F(0.5, 0.2, 0.2));
|
|
Mat4x4 world_to_render_vp_matrix = calculate_vp(world_to_render_xf, render_viewport.width, render_viewport.height);
|
|
Mat4x4 ui_vp_matrix = calculate_vp(XformIdentity, ui_viewport.width, ui_viewport.height);
|
|
Mat4x4 blit_vp_matrix = ZI;
|
|
{
|
|
Xform xf = render_to_ui_xf;
|
|
xf = ScaleXform(xf, VEC2(render_size.x, render_size.y));
|
|
xf = TranslateXform(xf, VEC2(0.5, 0.5));
|
|
blit_vp_matrix = calculate_vp(xf, ui_viewport.width, ui_viewport.height);
|
|
}
|
|
|
|
/* Upload dummmy vert & index buffer */
|
|
/* TODO: Make these static */
|
|
/* Dummy vertex buffer */
|
|
LocalPersist u16 quad_indices[6] = { 0, 1, 2, 0, 2, 3 };
|
|
struct command_buffer *dummy_vertex_buffer = command_list_push_buffer(cl, 0, (u8 *)0);
|
|
struct command_buffer *quad_index_buffer = command_list_push_buffer(cl, countof(quad_indices), quad_indices);
|
|
|
|
/* Process sig data into uploadable data */
|
|
struct k_material_instance *material_instances = PushStructsNoZero(scratch.arena, struct k_material_instance, rsig->num_material_instance_descs);
|
|
struct k_ui_instance *ui_rect_instances = PushStructsNoZero(scratch.arena, struct k_ui_instance, rsig->num_ui_rect_instance_descs);
|
|
struct k_material_grid *grids = PushStructsNoZero(scratch.arena, struct k_material_grid, rsig->num_material_grid_descs);
|
|
{
|
|
__profn("Process sig data");
|
|
|
|
/* Process material instances */
|
|
{
|
|
__profn("Process material instances");
|
|
for (u32 i = 0; i < rsig->num_material_instance_descs; ++i) {
|
|
struct material_instance_desc *desc = &((struct material_instance_desc *)ArenaBase(rsig->material_instance_descs_arena))[i];
|
|
struct k_material_instance *instance = &material_instances[i];
|
|
instance->tex_nurid = K_UintFromU32(desc->texture_id);
|
|
instance->grid_id = K_UintFromU32(desc->grid_id);
|
|
instance->xf = K_Float2x3FromXform(desc->xf);
|
|
instance->uv0 = K_Float2FromV2(desc->clip.p0);
|
|
instance->uv1 = K_Float2FromV2(desc->clip.p1);
|
|
instance->tint_srgb = K_UintFromU32(desc->tint);
|
|
instance->is_light = K_UintFromU32(desc->is_light);
|
|
instance->light_emittance_srgb = K_Float3FromV3(desc->light_emittance);
|
|
}
|
|
}
|
|
|
|
/* Process ui rect instances */
|
|
{
|
|
__profn("Process ui rect instances");
|
|
for (u32 i = 0; i < rsig->num_ui_rect_instance_descs; ++i) {
|
|
struct ui_rect_instance_desc *desc = &((struct ui_rect_instance_desc *)ArenaBase(rsig->ui_rect_instance_descs_arena))[i];
|
|
struct k_ui_instance *instance = &ui_rect_instances[i];
|
|
instance->tex_nurid = K_UintFromU32(desc->texture_id);
|
|
instance->xf = K_Float2x3FromXform(desc->xf);
|
|
instance->uv0 = K_Float2FromV2(desc->clip.p0);
|
|
instance->uv1 = K_Float2FromV2(desc->clip.p1);
|
|
instance->tint_srgb = K_UintFromU32(desc->tint);
|
|
}
|
|
}
|
|
|
|
/* Process grids */
|
|
{
|
|
__profn("Process grids");
|
|
for (u32 i = 0; i < rsig->num_material_grid_descs; ++i) {
|
|
struct material_grid_desc *desc = &((struct material_grid_desc *)ArenaBase(rsig->material_grid_descs_arena))[i];
|
|
struct k_material_grid *grid = &grids[i];
|
|
grid->line_thickness = K_FloatFromF32(desc->line_thickness);
|
|
grid->line_spacing = K_FloatFromF32(desc->line_spacing);
|
|
grid->offset = K_Float2FromV2(desc->offset);
|
|
grid->bg0_srgb = K_UintFromU32(desc->bg0_color);
|
|
grid->bg1_srgb = K_UintFromU32(desc->bg1_color);
|
|
grid->line_srgb = K_UintFromU32(desc->line_color);
|
|
grid->x_srgb = K_UintFromU32(desc->x_color);
|
|
grid->y_srgb = K_UintFromU32(desc->y_color);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Upload buffers */
|
|
u64 num_ui_shape_verts = rsig->ui_shape_verts_arena->pos / sizeof(struct k_shape_vert);
|
|
u64 num_ui_shape_indices = rsig->ui_shape_indices_arena->pos / sizeof(u32);
|
|
struct command_buffer *material_instance_buffer = command_list_push_buffer(cl, rsig->num_material_instance_descs, material_instances);
|
|
struct command_buffer *ui_rect_instance_buffer = command_list_push_buffer(cl, rsig->num_ui_rect_instance_descs, ui_rect_instances);
|
|
struct command_buffer *ui_shape_verts_buffer = command_list_push_buffer(cl, num_ui_shape_verts, (struct k_shape_vert *)ArenaBase(rsig->ui_shape_verts_arena));
|
|
struct command_buffer *ui_shape_indices_buffer = command_list_push_buffer(cl, num_ui_shape_indices, (u32 *)ArenaBase(rsig->ui_shape_indices_arena));
|
|
struct command_buffer *grid_buffer = command_list_push_buffer(cl, rsig->num_material_grid_descs, grids);
|
|
|
|
/* Upload descriptor heap */
|
|
struct command_descriptor_heap *descriptor_heap = command_list_push_descriptor_heap(cl, G.cbv_srv_uav_heap);
|
|
ID3D12DescriptorHeap *heaps[] = { descriptor_heap->heap };
|
|
ID3D12GraphicsCommandList_SetDescriptorHeaps(cl->cl, countof(heaps), heaps);
|
|
|
|
/* Prep for material pass */
|
|
{
|
|
/* Barrier */
|
|
{
|
|
struct dx12_resource_barrier_desc barriers[] = {
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->albedo, D3D12_RESOURCE_STATE_RENDER_TARGET },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->emittance, D3D12_RESOURCE_STATE_RENDER_TARGET }
|
|
};
|
|
D3D12_CPU_DESCRIPTOR_HANDLE rtvs[] = {
|
|
rsig->albedo->rtv_descriptor->handle,
|
|
rsig->emittance->rtv_descriptor->handle,
|
|
};
|
|
dx12_resource_barriers(cl->cl, countof(barriers), barriers);
|
|
ID3D12GraphicsCommandList_OMSetRenderTargets(cl->cl, countof(rtvs), rtvs, 0, 0);
|
|
}
|
|
/* Clear */
|
|
{
|
|
__profn("Clear gbuffers");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Clear gbuffers", Rgb32F(0.5, 0.2, 0.2));
|
|
f32 clear_color[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
|
ID3D12GraphicsCommandList_ClearRenderTargetView(cl->cl, rsig->albedo->rtv_descriptor->handle, clear_color, 0, 0);
|
|
ID3D12GraphicsCommandList_ClearRenderTargetView(cl->cl, rsig->emittance->rtv_descriptor->handle, clear_color, 0, 0);
|
|
}
|
|
}
|
|
|
|
/* Material pass */
|
|
if (material_pipeline->success) {
|
|
__profn("Material pass");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Material pass", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, material_pipeline);
|
|
|
|
/* Set Rasterizer State */
|
|
D3D12_VIEWPORT viewport = viewport_from_rect(render_viewport);
|
|
D3D12_RECT scissor = scissor_from_rect(render_viewport);
|
|
ID3D12GraphicsCommandList_RSSetViewports(cl->cl, 1, &viewport);
|
|
ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor);
|
|
|
|
/* Set sig */
|
|
struct k_material_sig sig = ZI;
|
|
sig.projection = K_Float4x4FromMat4x4(world_to_render_vp_matrix);
|
|
sig.instances_urid = K_UintFromU32(material_instance_buffer->resource->srv_descriptor->index);
|
|
sig.grids_urid = K_UintFromU32(grid_buffer->resource->srv_descriptor->index);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Draw */
|
|
u32 instance_count = material_instance_buffer->size / sizeof(struct k_material_instance);
|
|
D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0);
|
|
D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(quad_index_buffer, DXGI_FORMAT_R16_UINT);
|
|
ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D12GraphicsCommandList_IASetVertexBuffers(cl->cl, 0, 1, &vbv);
|
|
ID3D12GraphicsCommandList_IASetIndexBuffer(cl->cl, &ibv);
|
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(cl->cl, 6, instance_count, 0, 0, 0);
|
|
}
|
|
|
|
/* Prep for flood pass */
|
|
{
|
|
/* Barrier */
|
|
{
|
|
struct dx12_resource_barrier_desc barriers[] = {
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->emittance, D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE },
|
|
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->emittance_flood_read, D3D12_RESOURCE_STATE_UNORDERED_ACCESS },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_UAV, rsig->emittance_flood_read, 0 },
|
|
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->emittance_flood_target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS }
|
|
};
|
|
dx12_resource_barriers(cl->cl, countof(barriers), barriers);
|
|
}
|
|
}
|
|
|
|
/* Flood pass */
|
|
if (flood_pipeline->success && !params.effects_disabled) {
|
|
__profn("Flood pass");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Flood pass", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, flood_pipeline);
|
|
|
|
i32 step_length = -1;
|
|
|
|
/* TODO: Remove this */
|
|
u64 max_steps = GetGstat(GSTAT_DEBUG_STEPS);
|
|
u64 step = 0;
|
|
while (step_length != 0 && step < max_steps) {
|
|
__profn("Flood step");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Flood step", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* UAV barrier */
|
|
{
|
|
struct dx12_resource_barrier_desc barriers[] = {
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_UAV, rsig->emittance_flood_read, 0 }
|
|
};
|
|
dx12_resource_barriers(cl->cl, countof(barriers), barriers);
|
|
}
|
|
|
|
/* Set sig */
|
|
struct k_flood_sig sig = ZI;
|
|
sig.step_len = K_IntFromI32(step_length);
|
|
sig.emittance_tex_urid = K_UintFromU32(rsig->emittance->srv_descriptor->index);
|
|
sig.read_flood_tex_urid = K_UintFromU32(rsig->emittance_flood_read->uav_descriptor->index);
|
|
sig.target_flood_tex_urid = K_UintFromU32(rsig->emittance_flood_target->uav_descriptor->index);
|
|
sig.tex_width = K_UintFromU32(render_size.x);
|
|
sig.tex_height = K_UintFromU32(render_size.y);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Dispatch */
|
|
ID3D12GraphicsCommandList_Dispatch(cl->cl, (render_size.x + 7) / 8, (render_size.y + 7) / 8, 1);
|
|
|
|
/* Swap buffers */
|
|
struct dx12_resource *swp = rsig->emittance_flood_read;
|
|
rsig->emittance_flood_read = rsig->emittance_flood_target;
|
|
rsig->emittance_flood_target = swp;
|
|
|
|
/* Update step */
|
|
if (step_length == -1) {
|
|
step_length = MaxI32(render_size.x, render_size.y) / 2;
|
|
} else {
|
|
step_length /= 2;
|
|
}
|
|
++step;
|
|
}
|
|
}
|
|
|
|
/* Prep for shade pass */
|
|
{
|
|
/* Barrier */
|
|
{
|
|
struct dx12_resource_barrier_desc barriers[] = {
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->albedo, D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->emittance, D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE },
|
|
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->emittance_flood_read, D3D12_RESOURCE_STATE_UNORDERED_ACCESS },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_UAV, rsig->emittance_flood_read, 0 },
|
|
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->shade_read, D3D12_RESOURCE_STATE_UNORDERED_ACCESS },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_UAV, rsig->shade_read, 0 },
|
|
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->shade_target, D3D12_RESOURCE_STATE_UNORDERED_ACCESS }
|
|
};
|
|
dx12_resource_barriers(cl->cl, countof(barriers), barriers);
|
|
}
|
|
/* Clear */
|
|
{
|
|
__profn("Clear shade target");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Clear shade target", Rgb32F(0.5, 0.2, 0.2));
|
|
f32 clear_color[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
|
ID3D12GraphicsCommandList_ClearUnorderedAccessViewFloat(cl->cl, gpu_handle_from_descriptor(rsig->shade_target->uav_descriptor, descriptor_heap), rsig->shade_target->uav_descriptor->handle, rsig->shade_target->resource, clear_color, 0, 0);
|
|
}
|
|
}
|
|
|
|
/* Shade pass */
|
|
if (shade_pipeline->success) {
|
|
__profn("Shade pass");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Shade pass", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, shade_pipeline);
|
|
|
|
u32 shade_flags = K_SHADE_FLAG_NONE;
|
|
if (params.effects_disabled) {
|
|
shade_flags |= K_SHADE_FLAG_DISABLE_EFFECTS;
|
|
}
|
|
|
|
/* Set sig */
|
|
struct k_shade_sig sig = ZI;
|
|
sig.flags = K_UintFromU32(shade_flags);
|
|
sig.tex_width = K_UintFromU32(render_size.x);
|
|
sig.tex_height = K_UintFromU32(render_size.y);
|
|
sig.frame_seed = K_Uint4FromU32((u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF),
|
|
(u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF),
|
|
(u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF),
|
|
(u32)(RandU64FromState(&rsig->rand) & 0xFFFFFFFF));
|
|
sig.frame_index = K_UintFromU32(rsig->frame_index);
|
|
sig.camera_offset = K_Float2FromV2(world_to_render_xf.og);
|
|
sig.albedo_tex_urid = K_UintFromU32(rsig->albedo->srv_descriptor->index);
|
|
sig.emittance_tex_urid = K_UintFromU32(rsig->emittance->srv_descriptor->index);
|
|
sig.emittance_flood_tex_urid = K_UintFromU32(rsig->emittance_flood_read->srv_descriptor->index);
|
|
sig.read_tex_urid = K_UintFromU32(rsig->shade_read->uav_descriptor->index);
|
|
sig.target_tex_urid = K_UintFromU32(rsig->shade_target->uav_descriptor->index);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Dispatch */
|
|
ID3D12GraphicsCommandList_Dispatch(cl->cl, (render_size.x + 7) / 8, (render_size.y + 7) / 8, 1);
|
|
|
|
/* Swap */
|
|
struct dx12_resource *swp = rsig->shade_read;
|
|
rsig->shade_read = rsig->shade_target;
|
|
rsig->shade_target = swp;
|
|
}
|
|
|
|
/* Prep for UI pass */
|
|
{
|
|
/* Barrier */
|
|
{
|
|
struct dx12_resource_barrier_desc barriers[] = {
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->shade_read, D3D12_RESOURCE_STATE_UNORDERED_ACCESS },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_UAV, rsig->shade_read, 0 },
|
|
{ D3D12_RESOURCE_BARRIER_TYPE_TRANSITION, rsig->ui_target, D3D12_RESOURCE_STATE_RENDER_TARGET }
|
|
};
|
|
dx12_resource_barriers(cl->cl, countof(barriers), barriers);
|
|
ID3D12GraphicsCommandList_OMSetRenderTargets(cl->cl, 1, &rsig->ui_target->rtv_descriptor->handle, 0, 0);
|
|
}
|
|
/* Clear */
|
|
{
|
|
__profn("Clear ui target");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Clear ui target", Rgb32F(0.5, 0.2, 0.2));
|
|
f32 clear_color[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
|
ID3D12GraphicsCommandList_ClearRenderTargetView(cl->cl, rsig->ui_target->rtv_descriptor->handle, clear_color, 0, 0);
|
|
}
|
|
}
|
|
|
|
/* UI blit pass */
|
|
if (blit_pipeline->success) {
|
|
__profn("UI blit pass");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "UI blit pass", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, blit_pipeline);
|
|
|
|
/* Set Rasterizer State */
|
|
D3D12_VIEWPORT viewport = viewport_from_rect(ui_viewport);
|
|
D3D12_RECT scissor = scissor_from_rect(ui_viewport);
|
|
ID3D12GraphicsCommandList_RSSetViewports(cl->cl, 1, &viewport);
|
|
ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor);
|
|
|
|
/* Set sig */
|
|
struct k_blit_sig sig = ZI;
|
|
sig.projection = K_Float4x4FromMat4x4(blit_vp_matrix);
|
|
sig.flags = K_UintFromU32(K_BLIT_FLAG_TONE_MAP | K_BLIT_FLAG_GAMMA_CORRECT);
|
|
sig.exposure = K_FloatFromF32(2.0);
|
|
sig.gamma = K_FloatFromF32((f32)2.2);
|
|
sig.tex_urid = K_UintFromU32(rsig->shade_read->uav_descriptor->index);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Draw */
|
|
D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0);
|
|
D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(quad_index_buffer, DXGI_FORMAT_R16_UINT);
|
|
ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D12GraphicsCommandList_IASetVertexBuffers(cl->cl, 0, 1, &vbv);
|
|
ID3D12GraphicsCommandList_IASetIndexBuffer(cl->cl, &ibv);
|
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(cl->cl, 6, 1, 0, 0, 0);
|
|
}
|
|
|
|
/* UI rect pass */
|
|
if (ui_pipeline->success) {
|
|
__profn("UI rect pass");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "UI rect pass", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, ui_pipeline);
|
|
|
|
/* Set Rasterizer State */
|
|
D3D12_VIEWPORT viewport = viewport_from_rect(ui_viewport);
|
|
D3D12_RECT scissor = scissor_from_rect(ui_viewport);
|
|
ID3D12GraphicsCommandList_RSSetViewports(cl->cl, 1, &viewport);
|
|
ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor);
|
|
|
|
/* Set sig */
|
|
struct k_ui_sig sig = ZI;
|
|
sig.projection = K_Float4x4FromMat4x4(ui_vp_matrix);
|
|
sig.instances_urid = K_UintFromU32(ui_rect_instance_buffer->resource->srv_descriptor->index);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Draw */
|
|
u32 instance_count = ui_rect_instance_buffer->size / sizeof(struct k_ui_instance);
|
|
D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0);
|
|
D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(quad_index_buffer, DXGI_FORMAT_R16_UINT);
|
|
ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D12GraphicsCommandList_IASetVertexBuffers(cl->cl, 0, 1, &vbv);
|
|
ID3D12GraphicsCommandList_IASetIndexBuffer(cl->cl, &ibv);
|
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(cl->cl, 6, instance_count, 0, 0, 0);
|
|
}
|
|
|
|
/* UI shape pass */
|
|
if (shape_pipeline->success) {
|
|
__profn("UI shape pass");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "UI shape pass", Rgb32F(0.5, 0.2, 0.2));
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, shape_pipeline);
|
|
|
|
/* Set Rasterizer State */
|
|
D3D12_VIEWPORT viewport = viewport_from_rect(ui_viewport);
|
|
D3D12_RECT scissor = scissor_from_rect(ui_viewport);
|
|
ID3D12GraphicsCommandList_RSSetViewports(cl->cl, 1, &viewport);
|
|
ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor);
|
|
|
|
/* Set sig */
|
|
struct k_shape_sig sig = ZI;
|
|
sig.projection = K_Float4x4FromMat4x4(ui_vp_matrix);
|
|
sig.verts_urid = K_UintFromU32(ui_shape_verts_buffer->resource->srv_descriptor->index);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Draw */
|
|
u32 index_count = ui_shape_indices_buffer->size / sizeof(u32);
|
|
D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0);
|
|
D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(ui_shape_indices_buffer, DXGI_FORMAT_R32_UINT);
|
|
ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D12GraphicsCommandList_IASetVertexBuffers(cl->cl, 0, 1, &vbv);
|
|
ID3D12GraphicsCommandList_IASetIndexBuffer(cl->cl, &ibv);
|
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(cl->cl, index_count, 1, 0, 0, 0);
|
|
}
|
|
}
|
|
command_list_close(cl);
|
|
pipeline_scope_end(pipeline_scope);
|
|
|
|
render_sig_reset(rsig);
|
|
EndScratch(scratch);
|
|
|
|
return (G_Resource *)rsig->ui_target;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Memory info
|
|
* ========================== */
|
|
|
|
G_MemoryInfo gp_query_memory_info(void)
|
|
{
|
|
G_MemoryInfo result = ZI;
|
|
|
|
HRESULT hr = 0;
|
|
IDXGIAdapter3 *dxgiAdapter3 = 0;
|
|
if (SUCCEEDED(hr)) {
|
|
hr = IDXGIAdapter_QueryInterface(G.adapter, &IID_IDXGIAdapter3, (void **)&dxgiAdapter3);
|
|
}
|
|
if (SUCCEEDED(hr)) {
|
|
struct DXGI_QUERY_VIDEO_MEMORY_INFO info = ZI;
|
|
IDXGIAdapter3_QueryVideoMemoryInfo(dxgiAdapter3, 0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &info);
|
|
result.local_used = info.CurrentUsage;
|
|
result.local_budget = info.Budget;
|
|
}
|
|
if (SUCCEEDED(hr)) {
|
|
struct DXGI_QUERY_VIDEO_MEMORY_INFO info = ZI;
|
|
IDXGIAdapter3_QueryVideoMemoryInfo(dxgiAdapter3, 0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &info);
|
|
result.non_local_used = info.CurrentUsage;
|
|
result.non_local_budget = info.Budget;
|
|
}
|
|
if (dxgiAdapter3) {
|
|
IDXGIAdapter_Release(dxgiAdapter3);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Swapchain
|
|
* ========================== */
|
|
|
|
internal void swapchain_init_resources(struct swapchain *swapchain)
|
|
{
|
|
for (u32 i = 0; i < countof(swapchain->buffers); ++i) {
|
|
ID3D12Resource *resource = 0;
|
|
HRESULT hr = IDXGISwapChain3_GetBuffer(swapchain->swapchain, i, &IID_ID3D12Resource, (void **)&resource);
|
|
if (FAILED(hr)) {
|
|
/* TODO: Don't panic */
|
|
P_Panic(Lit("Failed to get swapchain buffer"));
|
|
}
|
|
struct swapchain_buffer *sb = &swapchain->buffers[i];
|
|
ZeroStruct(sb);
|
|
sb->swapchain = swapchain;
|
|
sb->resource = resource;
|
|
sb->rtv_descriptor = descriptor_alloc(G.rtv_heap);
|
|
sb->state = D3D12_RESOURCE_STATE_COMMON;
|
|
ID3D12Device_CreateRenderTargetView(G.device, sb->resource, 0, sb->rtv_descriptor->handle);
|
|
}
|
|
}
|
|
|
|
G_Swapchain *gp_swapchain_alloc(P_Window *window, Vec2I32 resolution)
|
|
{
|
|
HRESULT hr = 0;
|
|
HWND hwnd = (HWND)P_GetInternalWindowHandle(window);
|
|
struct command_queue *cq = G.command_queues[DX12_QUEUE_DIRECT];
|
|
|
|
struct swapchain *swapchain = 0;
|
|
{
|
|
P_Lock lock = P_LockE(&G.swapchains_mutex);
|
|
if (G.first_free_swapchain) {
|
|
swapchain = G.first_free_swapchain;
|
|
G.first_free_swapchain = swapchain->next_free;
|
|
} else {
|
|
swapchain = PushStruct(G.swapchains_arena, struct swapchain);
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* Create swapchain1 */
|
|
IDXGISwapChain1 *swapchain1 = 0;
|
|
{
|
|
DXGI_SWAP_CHAIN_DESC1 desc = ZI;
|
|
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
|
desc.Width = resolution.x;
|
|
desc.Height = resolution.y;
|
|
desc.SampleDesc.Count = 1;
|
|
desc.SampleDesc.Quality = 0;
|
|
desc.BufferUsage = DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_RENDER_TARGET_OUTPUT;
|
|
desc.BufferCount = DX12_SWAPCHAIN_BUFFER_COUNT;
|
|
desc.Scaling = DXGI_SCALING_NONE;
|
|
desc.Flags = DX12_SWAPCHAIN_FLAGS;
|
|
desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
|
|
desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
|
|
hr = IDXGIFactory2_CreateSwapChainForHwnd(G.factory, (IUnknown *)cq->cq, hwnd, &desc, 0, 0, &swapchain1);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create IDXGISwapChain1"));
|
|
}
|
|
}
|
|
|
|
/* Upgrade to swapchain3 */
|
|
hr = IDXGISwapChain1_QueryInterface(swapchain1, &IID_IDXGISwapChain3, (void **)&swapchain->swapchain);
|
|
if (FAILED(hr)) {
|
|
P_Panic(Lit("Failed to create IDXGISwapChain3"));
|
|
}
|
|
|
|
/* Create waitable object */
|
|
#if DX12_WAIT_FRAME_LATENCY > 0
|
|
IDXGISwapChain3_SetMaximumFrameLatency(swapchain->swapchain, DX12_WAIT_FRAME_LATENCY);
|
|
swapchain->waitable = IDXGISwapChain2_GetFrameLatencyWaitableObject(swapchain->swapchain);
|
|
Assert(swapchain->waitable);
|
|
#endif
|
|
|
|
/* Disable Alt+Enter changing monitor resolution to match window size */
|
|
IDXGIFactory_MakeWindowAssociation(G.factory, hwnd, DXGI_MWA_NO_ALT_ENTER);
|
|
|
|
IDXGISwapChain1_Release(swapchain1);
|
|
swapchain->hwnd = hwnd;
|
|
|
|
swapchain_init_resources(swapchain);
|
|
|
|
return (G_Swapchain *)swapchain;
|
|
}
|
|
|
|
void gp_swapchain_release(G_Swapchain *gp_swapchain)
|
|
{
|
|
/* TODO */
|
|
(UNUSED)gp_swapchain;
|
|
}
|
|
|
|
void gp_swapchain_wait(G_Swapchain *gp_swapchain)
|
|
{
|
|
#if DX12_WAIT_FRAME_LATENCY > 0
|
|
struct swapchain *swapchain = (struct swapchain *)gp_swapchain;
|
|
if (swapchain->waitable) {
|
|
WaitForSingleObjectEx(swapchain->waitable, 1000, 1);
|
|
}
|
|
#else
|
|
(UNUSED)gp_swapchain;
|
|
#endif
|
|
}
|
|
|
|
internal struct swapchain_buffer *update_swapchain(struct swapchain *swapchain, Vec2I32 resolution)
|
|
{
|
|
__prof;
|
|
resolution.x = MaxI32(resolution.x, 1);
|
|
resolution.y = MaxI32(resolution.y, 1);
|
|
b32 should_rebuild = !EqVec2I32(swapchain->resolution, resolution);
|
|
if (should_rebuild) {
|
|
HRESULT hr = 0;
|
|
struct command_queue *cq = G.command_queues[DX12_QUEUE_DIRECT];
|
|
/* Lock direct queue submissions (in case any write to backbuffer) */
|
|
/* TODO: Less overkill approach - Only flush present_blit since we know it's the only operation targeting backbuffer */
|
|
P_Lock lock = P_LockE(&cq->submit_fence_mutex);
|
|
//DEBUGBREAKABLE;
|
|
//P_Lock lock = P_LockE(&G.global_command_list_record_mutex);
|
|
{
|
|
/* Flush direct queue */
|
|
//ID3D12CommandQueue_Signal(cq->cq, cq->submit_fence, ++cq->submit_fence_target);
|
|
{
|
|
HANDLE event = CreateEvent(0, 0, 0, 0);
|
|
ID3D12Fence_SetEventOnCompletion(cq->submit_fence, cq->submit_fence_target, event);
|
|
WaitForSingleObject(event, INFINITE);
|
|
CloseHandle(event);
|
|
}
|
|
|
|
/* Release buffers */
|
|
for (u32 i = 0; i < countof(swapchain->buffers); ++i) {
|
|
struct swapchain_buffer *sb = &swapchain->buffers[i];
|
|
descriptor_release(sb->rtv_descriptor);
|
|
ID3D12Resource_Release(sb->resource);
|
|
}
|
|
|
|
/* Resize buffers */
|
|
hr = IDXGISwapChain_ResizeBuffers(swapchain->swapchain, 0, resolution.x, resolution.y, DXGI_FORMAT_UNKNOWN, DX12_SWAPCHAIN_FLAGS);
|
|
if (FAILED(hr)) {
|
|
/* TODO: Don't panic */
|
|
P_Panic(Lit("Failed to resize swapchain"));
|
|
}
|
|
}
|
|
P_Unlock(&lock);
|
|
|
|
swapchain_init_resources(swapchain);
|
|
|
|
swapchain->resolution = resolution;
|
|
}
|
|
|
|
u32 backbuffer_index = IDXGISwapChain3_GetCurrentBackBufferIndex(swapchain->swapchain);
|
|
return &swapchain->buffers[backbuffer_index];
|
|
}
|
|
|
|
/* ========================== *
|
|
* Present
|
|
* ========================== */
|
|
|
|
internal void present_blit(struct swapchain_buffer *dst, struct dx12_resource *src, Xform src_xf)
|
|
{
|
|
__prof;
|
|
struct pipeline_scope *pipeline_scope = pipeline_scope_begin();
|
|
struct pipeline *blit_pipeline = pipeline_from_name(pipeline_scope, Lit("kernel_blit"));
|
|
if (blit_pipeline->success) {
|
|
struct command_queue *cq = G.command_queues[DX12_QUEUE_DIRECT];
|
|
struct command_list *cl = command_list_open(cq->cl_pool);
|
|
{
|
|
__profn("Present blit");
|
|
__profnc_dx12(cl->cq->prof, cl->cl, "Present blit", Rgb32F(0.5, 0.2, 0.2));
|
|
struct swapchain *swapchain = dst->swapchain;
|
|
|
|
/* Upload dummmy vert & index buffer */
|
|
/* TODO: Make these static */
|
|
/* Dummy vertex buffer */
|
|
LocalPersist u16 quad_indices[6] = { 0, 1, 2, 0, 2, 3 };
|
|
struct command_buffer *dummy_vertex_buffer = command_list_push_buffer(cl, 0, (u8 *)0);
|
|
struct command_buffer *quad_index_buffer = command_list_push_buffer(cl, countof(quad_indices), quad_indices);
|
|
|
|
/* Upload descriptor heap */
|
|
struct command_descriptor_heap *descriptor_heap = command_list_push_descriptor_heap(cl, G.cbv_srv_uav_heap);
|
|
ID3D12DescriptorHeap *heaps[] = { descriptor_heap->heap };
|
|
ID3D12GraphicsCommandList_SetDescriptorHeaps(cl->cl, countof(heaps), heaps);
|
|
|
|
Rect viewport_rect = RectFromVec2(VEC2(0, 0), VEC2(swapchain->resolution.x, swapchain->resolution.y));
|
|
D3D12_VIEWPORT viewport = viewport_from_rect(viewport_rect);
|
|
D3D12_RECT scissor = scissor_from_rect(viewport_rect);
|
|
|
|
Mat4x4 vp_matrix = ZI;
|
|
{
|
|
Xform xf = src_xf;
|
|
xf = ScaleXform(xf, VEC2(src->texture_size.x, src->texture_size.y));
|
|
xf = TranslateXform(xf, VEC2(0.5, 0.5));
|
|
vp_matrix = calculate_vp(xf, viewport.Width, viewport.Height);
|
|
}
|
|
|
|
/* Transition dst to render target */
|
|
{
|
|
struct D3D12_RESOURCE_TRANSITION_BARRIER rtb = ZI;
|
|
rtb.pResource = dst->resource;
|
|
rtb.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
|
|
rtb.StateBefore = dst->state;
|
|
rtb.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
|
|
struct D3D12_RESOURCE_BARRIER rb = ZI;
|
|
rb.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
|
rb.Flags = 0;
|
|
rb.Transition = rtb;
|
|
ID3D12GraphicsCommandList_ResourceBarrier(cl->cl, 1, &rb);
|
|
dst->state = rtb.StateAfter;
|
|
}
|
|
ID3D12GraphicsCommandList_OMSetRenderTargets(cl->cl, 1, &dst->rtv_descriptor->handle, 0, 0);
|
|
|
|
/* Clear */
|
|
f32 clear_color[] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
|
ID3D12GraphicsCommandList_ClearRenderTargetView(cl->cl, dst->rtv_descriptor->handle, clear_color, 0, 0);
|
|
|
|
/* Bind pipeline */
|
|
command_list_set_pipeline(cl, blit_pipeline);
|
|
|
|
/* Set Rasterizer State */
|
|
ID3D12GraphicsCommandList_RSSetViewports(cl->cl, 1, &viewport);
|
|
ID3D12GraphicsCommandList_RSSetScissorRects(cl->cl, 1, &scissor);
|
|
|
|
/* Set sig */
|
|
struct k_blit_sig sig = ZI;
|
|
sig.projection = K_Float4x4FromMat4x4(vp_matrix);
|
|
sig.flags = K_UintFromU32(K_BLIT_FLAG_NONE);
|
|
sig.tex_urid = K_UintFromU32(src->srv_descriptor->index);
|
|
command_list_set_sig(cl, &sig, sizeof(sig));
|
|
|
|
/* Draw */
|
|
D3D12_VERTEX_BUFFER_VIEW vbv = vbv_from_command_buffer(dummy_vertex_buffer, 0);
|
|
D3D12_INDEX_BUFFER_VIEW ibv = ibv_from_command_buffer(quad_index_buffer, DXGI_FORMAT_R16_UINT);
|
|
ID3D12GraphicsCommandList_IASetPrimitiveTopology(cl->cl, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
ID3D12GraphicsCommandList_IASetVertexBuffers(cl->cl, 0, 1, &vbv);
|
|
ID3D12GraphicsCommandList_IASetIndexBuffer(cl->cl, &ibv);
|
|
ID3D12GraphicsCommandList_DrawIndexedInstanced(cl->cl, 6, 1, 0, 0, 0);
|
|
|
|
/* Transition dst to presentable */
|
|
{
|
|
struct D3D12_RESOURCE_TRANSITION_BARRIER rtb = ZI;
|
|
rtb.pResource = dst->resource;
|
|
rtb.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
|
|
rtb.StateBefore = dst->state;
|
|
rtb.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
|
|
struct D3D12_RESOURCE_BARRIER rb = ZI;
|
|
rb.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
|
rb.Flags = 0;
|
|
rb.Transition = rtb;
|
|
ID3D12GraphicsCommandList_ResourceBarrier(cl->cl, 1, &rb);
|
|
dst->state = rtb.StateAfter;
|
|
}
|
|
}
|
|
command_list_close(cl);
|
|
}
|
|
pipeline_scope_end(pipeline_scope);
|
|
}
|
|
|
|
void gp_present(G_Swapchain *gp_swapchain, Vec2I32 backbuffer_resolution, G_Resource *texture, Xform texture_xf, i32 vsync)
|
|
{
|
|
__prof;
|
|
struct swapchain *swapchain = (struct swapchain *)gp_swapchain;
|
|
struct swapchain_buffer *swapchain_buffer = update_swapchain(swapchain, backbuffer_resolution);
|
|
struct dx12_resource *texture_resource = (struct dx12_resource *)texture;
|
|
|
|
/* Blit */
|
|
present_blit(swapchain_buffer, texture_resource, texture_xf);
|
|
|
|
u32 present_flags = 0;
|
|
if (vsync == 0) {
|
|
present_flags |= (DXGI_PRESENT_ALLOW_TEARING * DX12_ALLOW_TEARING);
|
|
}
|
|
|
|
/* Present */
|
|
{
|
|
__profn("Present");
|
|
HRESULT hr = IDXGISwapChain3_Present(swapchain->swapchain, vsync, present_flags);
|
|
if (!SUCCEEDED(hr)) {
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
#if ProfilingIsEnabled_GPU
|
|
{
|
|
__profframe(0);
|
|
|
|
__profn("Mark queue frames");
|
|
/* Lock because frame marks shouldn't occur while command lists are recording */
|
|
P_Lock lock = P_LockE(&G.global_command_list_record_mutex);
|
|
for (u32 i = 0; i < countof(G.command_queues); ++i) {
|
|
{
|
|
struct command_queue *cq = G.command_queues[i];
|
|
__prof_dx12_new_frame(cq->prof);
|
|
}
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
{
|
|
__profn("Collect queues");
|
|
for (u32 i = 0; i < countof(G.command_queues); ++i) {
|
|
struct command_queue *cq = G.command_queues[i];
|
|
__prof_dx12_collect(cq->prof);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* ========================== *
|
|
* Evictor thread
|
|
* ========================== */
|
|
|
|
internal P_JobDef(dx12_evictor_job, _)
|
|
{
|
|
(UNUSED)_;
|
|
|
|
u64 completed_targets[DX12_NUM_QUEUES] = ZI;
|
|
|
|
b32 shutdown = 0;
|
|
while (!shutdown) {
|
|
{
|
|
__profn("Dx12 evictor run");
|
|
TempArena scratch = BeginScratchNoConflict();
|
|
u64 targets[countof(completed_targets)] = ZI;
|
|
|
|
/* Copyqueued data */
|
|
u32 num_fenced_releases = 0;
|
|
struct fenced_release_data *fenced_releases = 0;
|
|
{
|
|
__profn("Copyqueued releases");
|
|
P_Lock lock = P_LockE(&G.fenced_releases_mutex);
|
|
num_fenced_releases = G.fenced_releases_arena->pos / sizeof(struct fenced_release_data);
|
|
fenced_releases = PushStructsNoZero(scratch.arena, struct fenced_release_data, num_fenced_releases);
|
|
CopyBytes(fenced_releases, ArenaBase(G.fenced_releases_arena), G.fenced_releases_arena->pos);
|
|
ResetArena(G.fenced_releases_arena);
|
|
CopyBytes(targets, G.fenced_release_targets, sizeof(targets));
|
|
P_Unlock(&lock);
|
|
}
|
|
|
|
/* Wait until fences reach target */
|
|
{
|
|
__profn("Check fences");
|
|
for (u32 i = 0; i < countof(targets); ++i) {
|
|
while (completed_targets[i] < targets[i]) {
|
|
struct command_queue *cq = G.command_queues[i];
|
|
completed_targets[i] = ID3D12Fence_GetCompletedValue(cq->submit_fence);
|
|
if (completed_targets[i] < targets[i]) {
|
|
__profn("Wait on fence");
|
|
{
|
|
struct dx12_wait_fence_job_sig sig = ZI;
|
|
sig.fence = cq->submit_fence;
|
|
sig.target = targets[i];
|
|
{
|
|
P_Counter counter = ZI;
|
|
P_Run(1, dx12_wait_fence_job, &sig, P_Pool_Floating, P_Priority_Low, &counter);
|
|
P_WaitOnCounter(&counter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Process releases */
|
|
for (u32 i = 0; i < num_fenced_releases; ++i) {
|
|
struct fenced_release_data *fr = &fenced_releases[i];
|
|
switch (fr->kind) {
|
|
default:
|
|
{
|
|
/* Unknown handle type */
|
|
Assert(0);
|
|
} break;
|
|
|
|
case FENCED_RELEASE_KIND_RESOURCE:
|
|
{
|
|
struct dx12_resource *resource = (struct dx12_resource *)fr->ptr;
|
|
dx12_resource_release_now(resource);
|
|
} break;
|
|
|
|
case FENCED_RELEASE_KIND_PIPELINE:
|
|
{
|
|
struct pipeline *pipeline = (struct pipeline *)fr->ptr;
|
|
pipeline_release_now(pipeline);
|
|
} break;
|
|
}
|
|
}
|
|
EndScratch(scratch);
|
|
}
|
|
P_Lock lock = P_LockE(&G.evictor_wake_mutex);
|
|
{
|
|
while (!G.evictor_shutdown && G.evictor_wake_gen == 0) {
|
|
P_WaitOnCv(&G.evictor_wake_cv, &lock);
|
|
}
|
|
shutdown = G.evictor_shutdown;
|
|
G.evictor_wake_gen = 0;
|
|
}
|
|
P_Unlock(&lock);
|
|
}
|
|
}
|