#include "Native.h"
#include "Dds.h"
#include <windows.h>
#include <d3d11_4.h>
#include <d3d12.h>
#include <dxgi1_6.h>
#include <wrl/client.h>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <mutex>
#include <stdexcept>
#include <chrono>
#include <algorithm>
#include <cstring>
#include <cmath>
#include "PackShader.h"
#include "CompositeShader.h"
#include "FullscreenShader.h"
#include "RaysShader.h"
#include "DenoiseShader.h"
#include "CopyScreenShader.h"
#include "CopyEnvironmentShader.h"
#include "EnvironmentRowsShader.h"
#include "EnvironmentTotalShader.h"
#include "TemporalShader.h"
#include "DenoiseGlassShader.h"
using Microsoft::WRL::ComPtr;
struct Failure : std::runtime_error { HRESULT code; Failure(HRESULT c, const char* s) : runtime_error(s), code(c) {} };
static void Check(HRESULT result, const char* operation) { if (FAILED(result)) throw Failure(result, operation); }
static uint64_t Align(uint64_t n, uint64_t a = 256) { return (n + a - 1) & ~(a - 1); }
struct Mesh {
std::vector<float> vertices; std::vector<uint32_t> indices;
ComPtr<ID3D12Resource> acceleration;
uint64_t bytes = 0; uint32_t triangles = 0;
uint32_t triangleOffset = 0, vertexOffset = 0, vertexCount = 0;
};
struct Vertex { float position[3],uv[2],tint[3]; };
struct Triangle { uint32_t v[3],material; };
struct InstanceMaterial { uint32_t triangleOffset; float tint[3]; float previousTransform[12]; uint32_t previousValid, reserved[3]; };
static_assert(sizeof(RtSurfaceMaterial)==32,"Surface material shader layout");
static_assert(sizeof(RtParameters)==448 && sizeof(RtInstance)==72 && sizeof(InstanceMaterial)==80 && sizeof(Vertex)==32 && sizeof(RtGlassMaterial)==32,"Managed/native/shader ABI mismatch");
struct SharedTexture {
ComPtr<ID3D12Resource> resource;
ComPtr<ID3D11Texture2D> texture;
ComPtr<ID3D11ShaderResourceView> srv;
ComPtr<ID3D11UnorderedAccessView> uav;
};
struct DynamicTexture { SharedTexture shared; ComPtr<ID3D11ShaderResourceView> source; UINT width=0,height=0; };
class Context {
public:
std::mutex mutex;
RtStatus status{};
ComPtr<ID3D11Device5> device11;
ComPtr<ID3D11DeviceContext4> context11;
ComPtr<ID3DDeviceContextState> isolatedState;
ComPtr<ID3D11ComputeShader> pack,copyScreen,copyEnvironment;
ComPtr<ID3D11SamplerState> environmentSampler;
ComPtr<ID3D11ShaderResourceView> environmentSource;
RtParameters lastParameters{};
bool opaqueReady=false;
ComPtr<ID3D11PixelShader> composite;
ComPtr<ID3D11VertexShader> fullscreen;
ComPtr<ID3D11Buffer> constants11;
ComPtr<ID3D11RasterizerState> rasterizer;
ComPtr<ID3D12Device5> device;
ComPtr<ID3D12CommandQueue> queue;
ComPtr<ID3D12CommandAllocator> allocator;
ComPtr<ID3D12GraphicsCommandList4> list;
ComPtr<ID3D12Fence> fence;
ComPtr<ID3D11Fence> fence11;
ComPtr<ID3D12RootSignature> root;
ComPtr<ID3D12PipelineState> pipeline,denoisePipeline,environmentRowsPipeline,environmentTotalPipeline,temporalPipeline,glassDenoisePipeline;
ComPtr<ID3D12DescriptorHeap> descriptors;
ComPtr<ID3D12Resource> tlas, scratch, instances, constants;
SharedTexture positions, normals, result, reflection, indirect,glassReflection,glassData,filtered,glassRefraction,moments,filteredReflection;
SharedTexture environmentMap,surfaceGuide,glassSharp,glassGuide,glassRaw,glassNormal,glassFactor;
ComPtr<ID3D12Resource> environmentCdf;
ComPtr<ID3D12Resource> glassBuffer,lightBuffer;
ComPtr<ID3D12Resource> surfaceBuffer;
std::vector<RtSurfaceMaterial> surfaces;
std::unordered_map<uint32_t,DynamicTexture> dynamicTextures;
uint64_t dynamicPixels=0;
std::vector<RtLight> lights;
ComPtr<ID3D12QueryHeap> timer;
ComPtr<ID3D12Resource> timerReadback;
UINT64 timerFrequency=0;bool timerReady=false;
std::vector<RtGlassMaterial> glassMaterials;
std::unordered_map<uint32_t, Mesh> meshes;
std::unordered_map<uint32_t,Material> materials;
std::vector<Vertex> vertexData;
std::vector<Triangle> triangleData;
std::vector<D3D12_RAYTRACING_INSTANCE_DESC> instanceData;
std::vector<RtInstance> lastScene;
std::unordered_map<uint64_t,uint32_t> previousByKey;
std::vector<InstanceMaterial> instanceMaterials;
std::vector<ComPtr<ID3D12Resource>> textureResources;
ComPtr<ID3D12Resource> vertexBuffer,triangleBuffer,instanceMaterialBuffer;
ComPtr<ID3D12Resource> historyTextures[10];
bool historyValid=false;
bool geometryDirty=true;
size_t uploadedVertices=0,uploadedTriangles=0;
uint64_t materialBytes=0;
std::vector<ComPtr<ID3D12Resource>> transient;
uint64_t submitted = 0, accelerationBytes = 0, triangles = 0;
uint32_t width = 0, height = 0;
HANDLE completed = nullptr;
bool ready = false;
~Context() {
if (fence && submitted && completed && fence->GetCompletedValue() < submitted) {
if (SUCCEEDED(fence->SetEventOnCompletion(submitted, completed))) WaitForSingleObject(completed, 2000);
}
if (completed) CloseHandle(completed);
}
void Fail(const Failure& e) {
ready = false; status.lastHresult = e.code;
strncpy_s(status.message, e.what(), _TRUNCATE);
}
void Initialize(void* pointer) {
status.version = 2;
if (!pointer) throw Failure(E_INVALIDARG, "Missing D3D11 device");
Check(((IUnknown*)pointer)->QueryInterface(IID_PPV_ARGS(&device11)), "D3D11.4 device required");
ComPtr<ID3D11DeviceContext> immediate;
device11->GetImmediateContext(&immediate);
Check(immediate.As(&context11), "D3D11.4 context required");
ComPtr<IDXGIDevice> dxgi; Check(device11.As(&dxgi), "DXGI device");
ComPtr<IDXGIAdapter> adapter; Check(dxgi->GetAdapter(&adapter), "Game adapter");
Check(D3D12CreateDevice(adapter.Get(), D3D_FEATURE_LEVEL_12_0, IID_PPV_ARGS(&device)), "D3D12 device on game adapter");
D3D12_FEATURE_DATA_D3D12_OPTIONS5 options{};
Check(device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &options, sizeof(options)), "Ray tracing feature query");
status.tier = (uint32_t)options.RaytracingTier;
if (options.RaytracingTier < D3D12_RAYTRACING_TIER_1_1) throw Failure(DXGI_ERROR_UNSUPPORTED, "DXR 1.1 required; no software fallback");
D3D12_COMMAND_QUEUE_DESC q{}; q.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
Check(device->CreateCommandQueue(&q, IID_PPV_ARGS(&queue)), "Ray tracing queue");
Check(queue->GetTimestampFrequency(&timerFrequency),"GPU timestamp frequency");
D3D12_QUERY_HEAP_DESC timerDesc{};timerDesc.Type=D3D12_QUERY_HEAP_TYPE_TIMESTAMP;timerDesc.Count=2;
Check(device->CreateQueryHeap(&timerDesc,IID_PPV_ARGS(&timer)),"GPU timestamp queries");
timerReadback=Buffer(16,D3D12_HEAP_TYPE_READBACK,D3D12_RESOURCE_STATE_COPY_DEST);
Check(device->CreateCommandAllocator(q.Type, IID_PPV_ARGS(&allocator)), "Command allocator");
Check(device->CreateCommandList(0, q.Type, allocator.Get(), nullptr, IID_PPV_ARGS(&list)), "Command list");
Check(list->Close(), "Close initial command list");
Check(device->CreateFence(0, D3D12_FENCE_FLAG_SHARED, IID_PPV_ARGS(&fence)), "Shared fence");
HANDLE shared = nullptr;
Check(device->CreateSharedHandle(fence.Get(), nullptr, GENERIC_ALL, nullptr, &shared), "Fence handle");
HRESULT open = device11->OpenSharedFence(shared, IID_PPV_ARGS(&fence11)); CloseHandle(shared);
Check(open, "Open D3D12 fence in D3D11");
completed = CreateEvent(nullptr, FALSE, FALSE, nullptr);
if (!completed) throw Failure(HRESULT_FROM_WIN32(GetLastError()), "Fence event");
Check(device11->CreateComputeShader(PackBytes, sizeof(PackBytes), nullptr, &pack), "Pack shader");
Check(device11->CreatePixelShader(CompositeBytes, sizeof(CompositeBytes), nullptr, &composite), "Composite shader");
Check(device11->CreateVertexShader(FullscreenBytes, sizeof(FullscreenBytes), nullptr, &fullscreen), "Fullscreen shader");
D3D11_BUFFER_DESC cb{}; cb.ByteWidth = sizeof(RtParameters); cb.Usage = D3D11_USAGE_DEFAULT; cb.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Check(device11->CreateBuffer(&cb, nullptr, &constants11), "D3D11 constants");
D3D11_RASTERIZER_DESC raster{}; raster.FillMode=D3D11_FILL_SOLID; raster.CullMode=D3D11_CULL_NONE; raster.DepthClipEnable=TRUE;
Check(device11->CreateRasterizerState(&raster,&rasterizer),"Fullscreen rasterizer");
auto feature = device11->GetFeatureLevel();
Check(device11->CreateDeviceContextState(0, &feature, 1, D3D11_SDK_VERSION, __uuidof(ID3D11Device), nullptr, &isolatedState), "Isolated D3D11 state");
D3D12_DESCRIPTOR_RANGE ranges[7]{};
ranges[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[0].NumDescriptors = 2; ranges[0].BaseShaderRegister = 1;
ranges[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV; ranges[1].NumDescriptors = 9;
ranges[2].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[2].NumDescriptors = 1024; ranges[2].BaseShaderRegister=10;
ranges[3].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[3].NumDescriptors = 4; ranges[3].BaseShaderRegister=6;
ranges[4].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[4].NumDescriptors = 3; ranges[4].BaseShaderRegister=1036;
ranges[5].RangeType=D3D12_DESCRIPTOR_RANGE_TYPE_SRV;ranges[5].NumDescriptors=5;ranges[5].BaseShaderRegister=1040;
ranges[6].RangeType=D3D12_DESCRIPTOR_RANGE_TYPE_UAV;ranges[6].NumDescriptors=5;ranges[6].BaseShaderRegister=10;
D3D12_ROOT_PARAMETER parameters[17]{};
parameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
parameters[1].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
for (int i = 2; i < 4; ++i) { parameters[i].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[i].DescriptorTable.NumDescriptorRanges = 1; parameters[i].DescriptorTable.pDescriptorRanges = &ranges[i-2]; }
for(int i=4;i<7;i++) { parameters[i].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV; parameters[i].Descriptor.ShaderRegister=i-1; }
parameters[7].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[7].DescriptorTable.NumDescriptorRanges=1; parameters[7].DescriptorTable.pDescriptorRanges=&ranges[2];
parameters[8].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[8].DescriptorTable.NumDescriptorRanges=1; parameters[8].DescriptorTable.pDescriptorRanges=&ranges[3];
parameters[9].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV; parameters[9].Descriptor.ShaderRegister=1034;
parameters[10].ParameterType=D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; parameters[10].Constants.ShaderRegister=1; parameters[10].Constants.Num32BitValues=1;
parameters[11].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV;parameters[11].Descriptor.ShaderRegister=1035;
parameters[12].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[12].DescriptorTable.NumDescriptorRanges=1; parameters[12].DescriptorTable.pDescriptorRanges=&ranges[4];
parameters[13].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV;parameters[13].Descriptor.ShaderRegister=1039;
parameters[14].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;parameters[14].DescriptorTable.NumDescriptorRanges=1;parameters[14].DescriptorTable.pDescriptorRanges=&ranges[5];
parameters[15].ParameterType=D3D12_ROOT_PARAMETER_TYPE_UAV;parameters[15].Descriptor.ShaderRegister=9;
parameters[16].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;parameters[16].DescriptorTable.NumDescriptorRanges=1;parameters[16].DescriptorTable.pDescriptorRanges=&ranges[6];
D3D12_STATIC_SAMPLER_DESC sampler{}; sampler.Filter=D3D12_FILTER_MIN_MAG_MIP_LINEAR; sampler.AddressU=sampler.AddressV=sampler.AddressW=D3D12_TEXTURE_ADDRESS_MODE_WRAP; sampler.MaxLOD=D3D12_FLOAT32_MAX;
D3D12_ROOT_SIGNATURE_DESC signature{}; signature.NumParameters = 17; signature.pParameters = parameters; signature.NumStaticSamplers=1; signature.pStaticSamplers=&sampler;
ComPtr<ID3DBlob> blob, errors;
Check(D3D12SerializeRootSignature(&signature, D3D_ROOT_SIGNATURE_VERSION_1, &blob, &errors), "Serialize root signature");
Check(device->CreateRootSignature(0, blob->GetBufferPointer(), blob->GetBufferSize(), IID_PPV_ARGS(&root)), "Root signature");
D3D12_COMPUTE_PIPELINE_STATE_DESC ps{}; ps.pRootSignature = root.Get(); ps.CS = { RaysBytes, sizeof(RaysBytes) };
Check(device->CreateComputePipelineState(&ps, IID_PPV_ARGS(&pipeline)), "DXR inline ray query pipeline");
ps.CS={DenoiseBytes,sizeof(DenoiseBytes)}; Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&denoisePipeline)),"Edge-aware atrous denoiser");
ps.CS={DenoiseGlassBytes,sizeof(DenoiseGlassBytes)}; Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&glassDenoisePipeline)),"Reflected-surface illumination denoiser");
D3D12_DESCRIPTOR_HEAP_DESC heap{}; heap.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; heap.NumDescriptors = 1052; heap.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
Check(device->CreateDescriptorHeap(&heap, IID_PPV_ARGS(&descriptors)), "Descriptors");
constants = Buffer(Align(sizeof(RtParameters)), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
glassBuffer=Buffer(1024*sizeof(RtGlassMaterial),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
RtGlassMaterial clearGlass{{1,1,1,.04f},{1.52f,.01f,0,0}}; Upload(glassBuffer.Get(),&clearGlass,sizeof(clearGlass));
lightBuffer=Buffer(64*sizeof(RtLight),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
materials.emplace(0,Material{});
Check(device11->CreateComputeShader(CopyScreenBytes,sizeof(CopyScreenBytes),nullptr,©Screen),"Screen texture copier");
surfaceBuffer=Buffer(1024*sizeof(RtSurfaceMaterial),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
surfaces.resize(1024);for(auto& s:surfaces) for(float& v:s.colorEmission)v=1;
Upload(surfaceBuffer.Get(),surfaces.data(),surfaces.size()*sizeof(RtSurfaceMaterial));
Check(device11->CreateComputeShader(CopyEnvironmentBytes,sizeof(CopyEnvironmentBytes),nullptr,©Environment),"Environment copier");
D3D11_SAMPLER_DESC sampler11{};sampler11.Filter=D3D11_FILTER_MIN_MAG_MIP_LINEAR;sampler11.AddressU=sampler11.AddressV=sampler11.AddressW=D3D11_TEXTURE_ADDRESS_CLAMP;sampler11.MaxLOD=D3D11_FLOAT32_MAX;
Check(device11->CreateSamplerState(&sampler11,&environmentSampler),"Environment sampler");
environmentMap=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT,256,128);
environmentCdf=Buffer((256*128+129)*sizeof(float),D3D12_HEAP_TYPE_DEFAULT,D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
ps.CS={EnvironmentRowsBytes,sizeof(EnvironmentRowsBytes)};Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&environmentRowsPipeline)),"Environment row distribution");
ps.CS={EnvironmentTotalBytes,sizeof(EnvironmentTotalBytes)};Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&environmentTotalPipeline)),"Environment marginal distribution");
ps.CS={TemporalBytes,sizeof(TemporalBytes)};Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&temporalPipeline)),"Responsive temporal lighting");
ready = true; strcpy_s(status.message, "DXR 1.1 ready; waiting for scene geometry");
}
ComPtr<ID3D12Resource> Buffer(uint64_t bytes, D3D12_HEAP_TYPE heap, D3D12_RESOURCE_STATES state, D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE) {
D3D12_HEAP_PROPERTIES props{}; props.Type = heap;
D3D12_RESOURCE_DESC desc{}; desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; desc.Width = std::max<uint64_t>(256, Align(bytes)); desc.Height = 1; desc.DepthOrArraySize = 1; desc.MipLevels = 1; desc.SampleDesc.Count = 1; desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; desc.Flags = flags;
ComPtr<ID3D12Resource> resource;
Check(device->CreateCommittedResource(&props, D3D12_HEAP_FLAG_NONE, &desc, state, nullptr, IID_PPV_ARGS(&resource)), "Allocate ray tracing buffer");
return resource;
}
void Upload(ID3D12Resource* resource, const void* data, size_t bytes) {
void* mapped = nullptr; D3D12_RANGE read{0,0}; Check(resource->Map(0, &read, &mapped), "Map upload buffer");
memcpy(mapped, data, bytes); D3D12_RANGE written{0,bytes}; resource->Unmap(0, &written);
}
void Barrier(ID3D12Resource* resource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after) {
D3D12_RESOURCE_BARRIER barrier{}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Transition = {resource, D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, before, after}; list->ResourceBarrier(1, &barrier);
}
void UavBarrier(ID3D12Resource* resource) {
D3D12_RESOURCE_BARRIER barrier{}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; barrier.UAV.pResource = resource; list->ResourceBarrier(1, &barrier);
}
void WaitPrevious() {
if (!submitted || fence->GetCompletedValue() >= submitted) return;
Check(fence->SetEventOnCompletion(submitted, completed), "Fence completion");
if (WaitForSingleObject(completed, 2000) != WAIT_OBJECT_0) throw Failure(DXGI_ERROR_DEVICE_HUNG, "Ray tracing GPU timeout; effect disabled");
}
SharedTexture Texture(DXGI_FORMAT format,UINT textureWidth=0,UINT textureHeight=0,bool shared=true) {
SharedTexture texture;
D3D12_HEAP_PROPERTIES props{}; props.Type = D3D12_HEAP_TYPE_DEFAULT;
D3D12_RESOURCE_DESC desc{}; desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; desc.Width = textureWidth?textureWidth:width; desc.Height = textureHeight?textureHeight:height; desc.DepthOrArraySize = 1; desc.MipLevels = 1; desc.Format = format; desc.SampleDesc.Count = 1; desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS | D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS;
Check(device->CreateCommittedResource(&props, shared?D3D12_HEAP_FLAG_SHARED:D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_COMMON, nullptr, IID_PPV_ARGS(&texture.resource)), "Ray tracing texture");
if(!shared)return texture; // FP32 guides stay on DX12; DX11 sharing has a restricted format set.
HANDLE handle = nullptr; Check(device->CreateSharedHandle(texture.resource.Get(), nullptr, GENERIC_ALL, nullptr, &handle), "Texture handle");
HRESULT hr = device11->OpenSharedResource1(handle, IID_PPV_ARGS(&texture.texture)); CloseHandle(handle); Check(hr, "Open D3D12 texture in D3D11");
Check(device11->CreateShaderResourceView(texture.texture.Get(), nullptr, &texture.srv), "Texture SRV");
Check(device11->CreateUnorderedAccessView(texture.texture.Get(), nullptr, &texture.uav), "Texture UAV");
return texture;
}
void Resize(uint32_t w, uint32_t h) {
if (w == width && h == height) return;
if (!w || !h || w > 4096 || h > 4096) throw Failure(E_INVALIDARG, "Unsupported trace resolution");
width = w; height = h;
positions = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
surfaceGuide=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassSharp=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);glassGuide=Texture(DXGI_FORMAT_R32G32B32A32_FLOAT,0,0,false);
glassRaw=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassNormal=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);glassFactor=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
normals = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
result = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
reflection = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
indirect = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassReflection=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT); glassData=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT); filtered=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassRefraction=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
moments=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
filteredReflection=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
auto handle = descriptors->GetCPUDescriptorHandleForHeapStart();
auto step = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
D3D12_SHADER_RESOURCE_VIEW_DESC srv{}; srv.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; srv.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; srv.Texture2D.MipLevels = 1;
srv.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; device->CreateShaderResourceView(positions.resource.Get(), &srv, handle); handle.ptr += step;
srv.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; device->CreateShaderResourceView(normals.resource.Get(), &srv, handle); handle.ptr += step;
D3D12_UNORDERED_ACCESS_VIEW_DESC uav{}; uav.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D; uav.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
device->CreateUnorderedAccessView(result.resource.Get(), nullptr, &uav, handle);
handle.ptr+=step; device->CreateUnorderedAccessView(reflection.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(indirect.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(glassReflection.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(glassData.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(filtered.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(glassRefraction.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(moments.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(filteredReflection.resource.Get(),nullptr,&uav,handle);
historyValid=false;
for(int i=0;i<7;i++) {
historyTextures[i].Reset(); D3D12_HEAP_PROPERTIES props{}; props.Type=D3D12_HEAP_TYPE_DEFAULT;
auto desc=(i==0?positions.resource:normals.resource)->GetDesc(); desc.Flags=D3D12_RESOURCE_FLAG_NONE;srv.Format=desc.Format;
Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[i])),"Radiance history texture");
handle.ptr+=step; device->CreateShaderResourceView(historyTextures[i].Get(),&srv,handle);
}
D3D12_HEAP_PROPERTIES props{};props.Type=D3D12_HEAP_TYPE_DEFAULT;auto desc=surfaceGuide.resource->GetDesc();desc.Flags=D3D12_RESOURCE_FLAG_NONE;
historyTextures[7].Reset();Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[7])),"Material history");
handle=descriptors->GetCPUDescriptorHandleForHeapStart();handle.ptr+=1042*step;srv.Format=DXGI_FORMAT_R16G16B16A16_FLOAT;
device->CreateShaderResourceView(environmentMap.resource.Get(),&srv,handle);handle.ptr+=step;
device->CreateShaderResourceView(surfaceGuide.resource.Get(),&srv,handle);handle.ptr+=step;
device->CreateShaderResourceView(historyTextures[7].Get(),&srv,handle);handle.ptr+=step;
desc=glassGuide.resource->GetDesc();desc.Flags=D3D12_RESOURCE_FLAG_NONE;srv.Format=desc.Format;
historyTextures[8].Reset();Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[8])),"Virtual glass hit history");
device->CreateShaderResourceView(historyTextures[8].Get(),&srv,handle);handle.ptr+=step;
desc=glassNormal.resource->GetDesc();desc.Flags=D3D12_RESOURCE_FLAG_NONE;srv.Format=desc.Format;
historyTextures[9].Reset();Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[9])),"Reflected surface normal history");
device->CreateShaderResourceView(historyTextures[9].Get(),&srv,handle);handle.ptr+=step;
device->CreateUnorderedAccessView(glassSharp.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
uav.Format=DXGI_FORMAT_R32G32B32A32_FLOAT;
device->CreateUnorderedAccessView(glassGuide.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
uav.Format=DXGI_FORMAT_R16G16B16A16_FLOAT;
device->CreateUnorderedAccessView(glassRaw.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
device->CreateUnorderedAccessView(glassNormal.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
device->CreateUnorderedAccessView(glassFactor.resource.Get(),nullptr,&uav,handle);
}
bool BuildMeshes() {
uint32_t built = 0;
for (auto& pair : meshes) {
Mesh& mesh = pair.second; if (mesh.acceleration) continue;
if (built++ >= 6) return false;
auto vertex = Buffer(mesh.vertices.size()*sizeof(float), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
auto index = Buffer(mesh.indices.size()*sizeof(uint32_t), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(vertex.Get(), mesh.vertices.data(), mesh.vertices.size()*sizeof(float)); Upload(index.Get(), mesh.indices.data(), mesh.indices.size()*sizeof(uint32_t));
D3D12_RAYTRACING_GEOMETRY_DESC geometry{}; geometry.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES; geometry.Flags = D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE;
geometry.Triangles.VertexBuffer = {vertex->GetGPUVirtualAddress(), 32}; geometry.Triangles.VertexCount = (UINT)mesh.vertices.size()/8; geometry.Triangles.VertexFormat = DXGI_FORMAT_R32G32B32_FLOAT;
geometry.Triangles.IndexBuffer = index->GetGPUVirtualAddress(); geometry.Triangles.IndexCount = (UINT)mesh.indices.size(); geometry.Triangles.IndexFormat = DXGI_FORMAT_R32_UINT;
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS input{}; input.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL; input.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY; input.NumDescs = 1; input.pGeometryDescs = &geometry; input.Flags = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE;
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO info{}; device->GetRaytracingAccelerationStructurePrebuildInfo(&input, &info);
if (!info.ResultDataMaxSizeInBytes || accelerationBytes + info.ResultDataMaxSizeInBytes > 1024ull*1024*1024) throw Failure(E_OUTOFMEMORY, "Ray tracing geometry exceeds 1 GiB budget");
mesh.acceleration = Buffer(info.ResultDataMaxSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
auto temporary = Buffer(info.ScratchDataSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC build{}; build.Inputs = input; build.DestAccelerationStructureData = mesh.acceleration->GetGPUVirtualAddress(); build.ScratchAccelerationStructureData = temporary->GetGPUVirtualAddress();
list->BuildRaytracingAccelerationStructure(&build, 0, nullptr); UavBarrier(mesh.acceleration.Get());
mesh.bytes=info.ResultDataMaxSizeInBytes;
accelerationBytes += mesh.bytes; triangles += mesh.triangles; ++status.meshes;
transient.push_back(vertex); transient.push_back(index); transient.push_back(temporary);
std::vector<float>().swap(mesh.vertices); std::vector<uint32_t>().swap(mesh.indices);
}
return true;
}
void AppendBuffer(ComPtr<ID3D12Resource>& gpu,const void* data,size_t count,size_t stride,size_t& uploadedCount) {
size_t bytes=count*stride;
if(!gpu || gpu->GetDesc().Width<bytes) {
uint64_t capacity=256; while(capacity<bytes) capacity*=2;
gpu=Buffer(capacity,D3D12_HEAP_TYPE_DEFAULT,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); uploadedCount=0;
}
if(count==uploadedCount) return;
size_t start=uploadedCount*stride,added=bytes-start;
auto upload=Buffer(added,D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(upload.Get(),(const uint8_t*)data+start,added);
Barrier(gpu.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyBufferRegion(gpu.Get(),start,upload.Get(),0,added);
Barrier(gpu.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
transient.push_back(upload); uploadedCount=count;
}
void Retain(const uint32_t* ids,uint32_t count) {
if(count>4096 || (count && !ids)) throw Failure(E_INVALIDARG,"Invalid retained mesh list");
WaitPrevious();
std::unordered_set<uint32_t> keep; for(uint32_t i=0;i<count;i++) keep.insert(ids[i]);
bool removed=false; size_t liveVertices=0,liveTriangles=0;
for(auto it=meshes.begin();it!=meshes.end();) {
if(!keep.count(it->first)) {
if(it->second.acceleration) { accelerationBytes-=it->second.bytes; triangles-=it->second.triangles; --status.meshes; }
it=meshes.erase(it); removed=true;
} else { liveVertices+=it->second.vertexCount; liveTriangles+=it->second.triangles; ++it; }
}
if(!removed) return;
status.triangles=triangles; lastScene.clear();
// Removed BLAS are freed immediately after the fence. Compact shading
// arrays only when accumulated holes are material; active BLAS stay valid.
bool compact=(vertexData.size()>liveVertices+100000 && vertexData.size()>liveVertices*3/2)
|| (triangleData.size()>liveTriangles+100000 && triangleData.size()>liveTriangles*3/2);
if(!compact) return;
std::vector<Vertex> nextVertices; nextVertices.reserve(liveVertices);
std::vector<Triangle> nextTriangles; nextTriangles.reserve(liveTriangles);
for(auto& item:meshes) {
auto& mesh=item.second; uint32_t start=(uint32_t)nextVertices.size(),triStart=(uint32_t)nextTriangles.size();
nextVertices.insert(nextVertices.end(),vertexData.begin()+mesh.vertexOffset,vertexData.begin()+mesh.vertexOffset+mesh.vertexCount);
for(uint32_t i=0;i<mesh.triangles;i++) {
auto tri=triangleData[mesh.triangleOffset+i]; for(auto& v:tri.v) v=v-mesh.vertexOffset+start;
nextTriangles.push_back(tri);
}
mesh.vertexOffset=start;mesh.triangleOffset=triStart;
}
vertexData.swap(nextVertices);triangleData.swap(nextTriangles);
uploadedVertices=uploadedTriangles=0;geometryDirty=true;
}
bool BuildMaterials() {
uint32_t built=0;
// Material zero initializes every descriptor so missing assets have a
// visible neutral fallback, never undefined descriptor accesses.
std::vector<uint32_t> pending; if(!materials[0].built) pending.push_back(0);
for(auto& pair:materials) if(pair.first && !pair.second.built) pending.push_back(pair.first);
for(auto id:pending) {
if(built++>=4) return false;
auto& m=materials[id];
if(materialBytes+m.data.size()>512ull*1024*1024) throw Failure(E_OUTOFMEMORY,"Secondary-ray textures exceed 512 MiB budget");
D3D12_RESOURCE_DESC d{}; d.Dimension=D3D12_RESOURCE_DIMENSION_TEXTURE2D; d.Width=m.width; d.Height=m.height; d.DepthOrArraySize=1; d.MipLevels=(UINT16)m.mips; d.Format=m.format; d.SampleDesc.Count=1;
D3D12_HEAP_PROPERTIES props{}; props.Type=D3D12_HEAP_TYPE_DEFAULT;
ComPtr<ID3D12Resource> texture;
Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&d,D3D12_RESOURCE_STATE_COPY_DEST,nullptr,IID_PPV_ARGS(&texture)),"Material texture");
std::vector<D3D12_PLACED_SUBRESOURCE_FOOTPRINT> footprints(m.mips); std::vector<UINT> rows(m.mips); std::vector<UINT64> rowBytes(m.mips); UINT64 total=0;
device->GetCopyableFootprints(&d,0,m.mips,0,footprints.data(),rows.data(),rowBytes.data(),&total);
auto upload=Buffer(total,D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ); void* mapped=nullptr; D3D12_RANGE noRead{0,0}; Check(upload->Map(0,&noRead,&mapped),"Material upload");
size_t offset=0;
for(UINT i=0;i<m.mips;i++) {
for(UINT row=0;row<rows[i];row++) { memcpy((uint8_t*)mapped+footprints[i].Offset+size_t(row)*footprints[i].Footprint.RowPitch,m.data.data()+offset,(size_t)rowBytes[i]); offset+=(size_t)rowBytes[i]; }
D3D12_TEXTURE_COPY_LOCATION dst{}; dst.pResource=texture.Get(); dst.Type=D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; dst.SubresourceIndex=i;
D3D12_TEXTURE_COPY_LOCATION src{}; src.pResource=upload.Get(); src.Type=D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; src.PlacedFootprint=footprints[i]; list->CopyTextureRegion(&dst,0,0,0,&src,nullptr);
}
upload->Unmap(0,nullptr); Barrier(texture.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
D3D12_SHADER_RESOURCE_VIEW_DESC view{}; view.Format=d.Format; view.ViewDimension=D3D12_SRV_DIMENSION_TEXTURE2D; view.Shader4ComponentMapping=D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; view.Texture2D.MipLevels=m.mips;
auto start=descriptors->GetCPUDescriptorHandleForHeapStart(); auto step=device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
start.ptr+=18*step; auto handle=start; handle.ptr+=id*step; device->CreateShaderResourceView(texture.Get(),&view,handle);
if(id==0) for(UINT i=1;i<1024;i++) { auto dst=start; dst.ptr+=i*step; device->CopyDescriptorsSimple(1,dst,start,D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); }
materialBytes+=m.data.size(); textureResources.push_back(texture); transient.push_back(upload); m.data.clear(); m.data.shrink_to_fit(); m.built=true;
}
return true;
}
void BuildInstances(const RtInstance* data, uint32_t count) {
if (!count || count > 120000) throw Failure(E_INVALIDARG, "Instance count must be 1..120000");
auto& native=instanceData; native.clear(); native.reserve(count); instanceMaterials.clear(); instanceMaterials.resize(count);
bool indexedPrevious=false;
for (uint32_t i = 0; i < count; ++i) {
for(float value:data[i].transform) if(!std::isfinite(value)) throw Failure(E_INVALIDARG,"Nonfinite instance transform");
auto found = meshes.find(data[i].mesh); if (found == meshes.end() || !found->second.acceleration) continue;
D3D12_RAYTRACING_INSTANCE_DESC desc{}; memcpy(desc.Transform, data[i].transform, sizeof(desc.Transform));
desc.InstanceMask = 0xff; desc.InstanceID = i; desc.Flags = D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE; desc.AccelerationStructure = found->second.acceleration->GetGPUVirtualAddress(); native.push_back(desc);
const RtInstance* previous=i<lastScene.size() && lastScene[i].mesh==data[i].mesh && lastScene[i].key==data[i].key?&lastScene[i]:nullptr;
// Camera range culling changes indices, not the identity of surviving
// surfaces. Lazily index the previous snapshot only on a mismatch.
if(!previous && data[i].key) {
if(!indexedPrevious) {
previousByKey.clear();previousByKey.reserve(lastScene.size());
for(uint32_t j=0;j<lastScene.size();j++)if(lastScene[j].key)previousByKey.emplace(lastScene[j].key,j);
indexedPrevious=true;
}
auto old=previousByKey.find(data[i].key);
if(old!=previousByKey.end() && lastScene[old->second].mesh==data[i].mesh)previous=&lastScene[old->second];
}
instanceMaterials[i].previousValid=previous?1:0;
memcpy(instanceMaterials[i].previousTransform,previous?previous->transform:data[i].transform,sizeof(data[i].transform));
instanceMaterials[i].triangleOffset=found->second.triangleOffset; memcpy(instanceMaterials[i].tint,data[i].tint,sizeof(data[i].tint));
}
if (native.empty()) throw Failure(E_INVALIDARG, "No ray tracing instances");
if(!instances || instances->GetDesc().Width<native.size()*sizeof(native[0])) instances = Buffer(native.size()*sizeof(native[0]), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(instances.Get(), native.data(), native.size()*sizeof(native[0]));
if(!instanceMaterialBuffer || instanceMaterialBuffer->GetDesc().Width<instanceMaterials.size()*sizeof(InstanceMaterial)) instanceMaterialBuffer=Buffer(instanceMaterials.size()*sizeof(InstanceMaterial),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(instanceMaterialBuffer.Get(),instanceMaterials.data(),instanceMaterials.size()*sizeof(InstanceMaterial));
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS input{}; input.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL; input.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY; input.NumDescs = (UINT)native.size(); input.InstanceDescs = instances->GetGPUVirtualAddress(); input.Flags = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD;
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO info{}; device->GetRaytracingAccelerationStructurePrebuildInfo(&input, &info);
if (!tlas || tlas->GetDesc().Width < info.ResultDataMaxSizeInBytes) tlas = Buffer(info.ResultDataMaxSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
if (!scratch || scratch->GetDesc().Width < info.ScratchDataSizeInBytes) scratch = Buffer(info.ScratchDataSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC build{}; build.Inputs = input; build.DestAccelerationStructureData = tlas->GetGPUVirtualAddress(); build.ScratchAccelerationStructureData = scratch->GetGPUVirtualAddress();
list->BuildRaytracingAccelerationStructure(&build, 0, nullptr); UavBarrier(tlas.Get()); status.instances = (uint32_t)native.size();
}
int Frame(ID3D11ShaderResourceView* depth, ID3D11ShaderResourceView* normal, ID3D11ShaderResourceView* light, ID3D11ShaderResourceView* material, ID3D11ShaderResourceView* albedo, ID3D11RenderTargetView* target, const RtInstance* scene, uint32_t count, const RtParameters& inputParams) {
RtParameters params=inputParams;opaqueReady=false;
params.environment[0]=environmentSource?1.0f:0.0f;
params.transport[3]=(float)lights.size();
if (!ready) return -1;
if (!depth || !normal || !light || !material || !albedo || !target || !scene) throw Failure(E_INVALIDARG, "Missing frame resources");
bool half=params.sizes[2]==(params.sizes[0]+1)/2 && params.sizes[3]==(params.sizes[1]+1)/2;
bool full=params.sizes[2]==params.sizes[0] && params.sizes[3]==params.sizes[1];
if(!params.sizes[0] || !params.sizes[1] || (!half && !full))
throw Failure(E_INVALIDARG,"Frame dimensions must match half or full resolution ray buffers");
WaitPrevious(); transient.clear(); Resize(params.sizes[2], params.sizes[3]);
if(timerReady) {
void* data=nullptr;D3D12_RANGE read{0,16};Check(timerReadback->Map(0,&read,&data),"Read GPU timestamps");
auto time=(uint64_t*)data;status.gpuMilliseconds=double(time[1]-time[0])*1000.0/double(timerFrequency);
D3D12_RANGE noWrite{0,0};timerReadback->Unmap(0,&noWrite);timerReady=false;
}
params.history[0]=historyValid ? params.history[0] : 0; params.history[1]=(float)status.frames;
Check(allocator->Reset(), "Reset allocator"); Check(list->Reset(allocator.Get(), pipeline.Get()), "Reset list");
bool allBuilt = BuildMeshes(); status.triangles = triangles;
allBuilt=BuildMaterials() && allBuilt;
if (!allBuilt || !count) {
Check(list->Close(), "Close geometry build"); ID3D12CommandList* commands[] = {list.Get()}; queue->ExecuteCommandLists(1, commands);
submitted += 2; Check(queue->Signal(fence.Get(), submitted), "Signal geometry build");
strcpy_s(status.message, "Building cached model acceleration structures"); return 0;
}
if(geometryDirty) {
AppendBuffer(vertexBuffer,vertexData.data(),vertexData.size(),sizeof(Vertex),uploadedVertices);
AppendBuffer(triangleBuffer,triangleData.data(),triangleData.size(),sizeof(Triangle),uploadedTriangles); geometryDirty=false;
}
// Snapshots arrive at 10 Hz. Reusing an identical TLAS avoids repeating
// 20k+ instance conversions and a GPU build on every intervening frame.
if(!tlas || lastScene.size()!=count || memcmp(lastScene.data(),scene,size_t(count)*sizeof(RtInstance))!=0) {
BuildInstances(scene,count);lastScene.assign(scene,scene+count);params.history[2]=1;
} else params.history[2]=0;
if(!historyValid)params.history[0]=0;
// A live engine frame must never replace lighting while its environment input is missing.
if(params.pathSettings[0]>0 && params.environment[3]>0 && !environmentSource) {
Check(list->Close(),"Close pending environment build");ID3D12CommandList* commands[]={list.Get()};queue->ExecuteCommandLists(1,commands);
submitted+=2;Check(queue->Signal(fence.Get(),submitted),"Signal pending environment build");return 0;
}
Upload(constants.Get(), ¶ms, sizeof(params));
// Preserve all engine bindings, including shader class instances and UAVs.
ComPtr<ID3DDeviceContextState> previous; context11->SwapDeviceContextState(isolatedState.Get(), &previous);
try {
context11->ClearState(); context11->UpdateSubresource(constants11.Get(), 0, nullptr, ¶ms, 0, 0);
for(auto& entry:dynamicTextures) {
auto& d=entry.second;if(!d.source || !d.shared.resource)continue;
// LCD content changes in-place without changing its SRV. Copy
// the current pixels on the render queue each frame; the 10 Hz
// binding discovery cadence must not become a display delay.
{
ID3D11ShaderResourceView* src=d.source.Get();ID3D11UnorderedAccessView* dst=d.shared.uav.Get();
context11->CSSetShaderResources(0,1,&src);context11->CSSetUnorderedAccessViews(0,1,&dst,nullptr);
context11->CSSetShader(copyScreen.Get(),nullptr,0);context11->Dispatch((d.width+7)/8,(d.height+7)/8,1);
context11->ClearState();
}
auto handle=descriptors->GetCPUDescriptorHandleForHeapStart();
handle.ptr+=(18+entry.first)*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
D3D12_SHADER_RESOURCE_VIEW_DESC view{};view.Format=DXGI_FORMAT_R16G16B16A16_FLOAT;view.ViewDimension=D3D12_SRV_DIMENSION_TEXTURE2D;
view.Shader4ComponentMapping=D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;view.Texture2D.MipLevels=1;
device->CreateShaderResourceView(d.shared.resource.Get(),&view,handle);
}
if(environmentSource) {
ID3D11ShaderResourceView* src=environmentSource.Get();ID3D11UnorderedAccessView* dst=environmentMap.uav.Get();ID3D11SamplerState* sampler=environmentSampler.Get();
context11->CSSetShaderResources(0,1,&src);context11->CSSetUnorderedAccessViews(0,1,&dst,nullptr);context11->CSSetSamplers(0,1,&sampler);
context11->CSSetShader(copyEnvironment.Get(),nullptr,0);context11->Dispatch(32,16,1);context11->ClearState();
}
ID3D11Buffer* cb = constants11.Get(); context11->CSSetConstantBuffers(0, 1, &cb);
ID3D11ShaderResourceView* packViews[] = {depth, normal, light, material}; context11->CSSetShaderResources(0, 4, packViews);context11->CSSetShaderResources(9,1,&albedo);
ID3D11UnorderedAccessView* writes[] = {positions.uav.Get(), normals.uav.Get(),surfaceGuide.uav.Get()}; context11->CSSetUnorderedAccessViews(0, 3, writes, nullptr);
context11->CSSetShader(pack.Get(), nullptr, 0); context11->Dispatch((width+7)/8, (height+7)/8, 1);
context11->ClearState();
Check(context11->Signal(fence11.Get(), submitted + 1), "Signal D3D11 input"); context11->Flush();
Check(queue->Wait(fence.Get(), submitted + 1), "Wait for D3D11 inputs");
for(auto& d:dynamicTextures) if(d.second.source && d.second.shared.resource)
Barrier(d.second.shared.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(environmentMap.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(positions.resource.Get(), D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(normals.resource.Get(), D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(result.resource.Get(), D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassData.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassRefraction.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
ID3D12DescriptorHeap* heaps[] = { descriptors.Get() }; list->SetDescriptorHeaps(1, heaps); list->SetComputeRootSignature(root.Get());
list->SetComputeRootShaderResourceView(0, tlas->GetGPUVirtualAddress()); list->SetComputeRootConstantBufferView(1, constants->GetGPUVirtualAddress());
auto gpu = descriptors->GetGPUDescriptorHandleForHeapStart(); list->SetComputeRootDescriptorTable(2, gpu);
gpu.ptr += 2*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(3, gpu);
list->SetComputeRootShaderResourceView(4,vertexBuffer->GetGPUVirtualAddress()); list->SetComputeRootShaderResourceView(5,triangleBuffer->GetGPUVirtualAddress()); list->SetComputeRootShaderResourceView(6,instanceMaterialBuffer->GetGPUVirtualAddress());
gpu.ptr+=9*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(8,gpu);
gpu.ptr+=4*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(12,gpu);
gpu.ptr+=3*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(7,gpu);
list->SetComputeRootShaderResourceView(9,glassBuffer->GetGPUVirtualAddress());
list->SetComputeRootShaderResourceView(11,lightBuffer->GetGPUVirtualAddress());
list->SetComputeRootShaderResourceView(13,surfaceBuffer->GetGPUVirtualAddress());
auto guides=descriptors->GetGPUDescriptorHandleForHeapStart();guides.ptr+=1042*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
list->SetComputeRootDescriptorTable(14,guides);list->SetComputeRootUnorderedAccessView(15,environmentCdf->GetGPUVirtualAddress());
guides.ptr+=5*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);list->SetComputeRootDescriptorTable(16,guides);
list->EndQuery(timer.Get(),D3D12_QUERY_TYPE_TIMESTAMP,0);
if(environmentSource) {
list->SetPipelineState(environmentRowsPipeline.Get());list->Dispatch(1,128,1);UavBarrier(environmentCdf.Get());
list->SetPipelineState(environmentTotalPipeline.Get());list->Dispatch(1,1,1);UavBarrier(environmentCdf.Get());list->SetPipelineState(pipeline.Get());
}
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassSharp.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassFactor.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
list->Dispatch((width+7)/8, (height+7)/8, 1);
UavBarrier(nullptr);list->SetPipelineState(temporalPipeline.Get());list->Dispatch((width+7)/8,(height+7)/8,1);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassSharp.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassFactor.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(result.resource.Get(), D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COMMON);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassData.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassRefraction.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(positions.resource.Get(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_COMMON);
Barrier(normals.resource.Get(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_COMMON);
ID3D12Resource* sources[]={positions.resource.Get(),normals.resource.Get(),reflection.resource.Get(),indirect.resource.Get(),glassData.resource.Get(),glassReflection.resource.Get(),moments.resource.Get(),surfaceGuide.resource.Get(),glassGuide.resource.Get(),glassNormal.resource.Get()};
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
const bool denoise=params.pathSettings[3]>0;
const bool pathTraced=params.pathSettings[0]>0;
for(int i=0;i<10;i++) {
// In these modes the first spatial pass supplies the history
// sample. Avoid copying the same 4K history texture twice.
if(denoise && ((i==3 && pathTraced) || (i==5 && params.transport[2]>0)))continue;
Barrier(sources[i],D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(historyTextures[i].Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(historyTextures[i].Get(),sources[i]);
Barrier(historyTextures[i].Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(sources[i],D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
}
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
if(params.pathSettings[3]>0 && params.transport[2]>0) {
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
list->SetPipelineState(glassDenoisePipeline.Get());
bool fromRaw=false;
for(UINT step=1;step<=16;step*=2) {
list->SetComputeRoot32BitConstant(10,step|(fromRaw?256:0),0);list->Dispatch((width+7)/8,(height+7)/8,1);
D3D12_RESOURCE_BARRIER sync{};sync.Type=D3D12_RESOURCE_BARRIER_TYPE_UAV;list->ResourceBarrier(1,&sync);
if(step==1) {
// SVGF feedback tap: a one-pixel guided pass removes
// isolated noise before accumulation, without feeding
// the broad final blur or sharp LCD/direct layer back.
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(historyTextures[5].Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(historyTextures[5].Get(),glassRaw.resource.Get());
Barrier(historyTextures[5].Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
fromRaw=!fromRaw;
}
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(glassReflection.resource.Get(),glassRaw.resource.Get());
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
}
// Feed back only the first, finest guided iteration. Broad spatial
// reconstruction must not accumulate and progressively lose detail.
if(params.pathSettings[3]>0 && (params.pathSettings[0]>0 || params.effects[0]>0 || params.effects[1]>0)) {
Barrier(result.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
list->SetPipelineState(denoisePipeline.Get());
Barrier(positions.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(normals.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
for(UINT step=1;step<=(params.pathSettings[0]>0?8u:4u);step*=2) {
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
if(!pathTraced) {
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
list->SetComputeRoot32BitConstant(10,step,0);
list->Dispatch((width+7)/8,(height+7)/8,1);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(indirect.resource.Get(),filtered.resource.Get());
if(step==1 && params.pathSettings[0]>0) {
Barrier(historyTextures[3].Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(historyTextures[3].Get(),filtered.resource.Get());
Barrier(historyTextures[3].Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
}
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_COMMON);
if(!pathTraced) {
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(reflection.resource.Get(),filteredReflection.resource.Get());
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_COMMON);
}
}
Barrier(positions.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(normals.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
}
if(params.pathSettings[3]>0 && (params.pathSettings[0]>0 || params.effects[0]>0 || params.effects[1]>0))
Barrier(result.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(environmentMap.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
list->EndQuery(timer.Get(),D3D12_QUERY_TYPE_TIMESTAMP,1);
for(auto& d:dynamicTextures) if(d.second.source && d.second.shared.resource)
Barrier(d.second.shared.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
list->ResolveQueryData(timer.Get(),D3D12_QUERY_TYPE_TIMESTAMP,0,2,timerReadback.Get(),0);timerReady=true;
historyValid=true;
Check(list->Close(), "Close ray dispatch"); ID3D12CommandList* commands[] = {list.Get()}; queue->ExecuteCommandLists(1, commands);
submitted += 2; Check(queue->Signal(fence.Get(), submitted), "Signal ray completion"); Check(context11->Wait(fence11.Get(), submitted), "D3D11 wait for rays");
Composite(depth,normal,light,material,albedo,target,params);
lastParameters=params;opaqueReady=params.pathSettings[2]==1;
} catch (...) { context11->SwapDeviceContextState(previous.Get(), nullptr); throw; }
context11->SwapDeviceContextState(previous.Get(), nullptr);
++status.frames; strcpy_s(status.message, "Hardware DXR local paths, thin dielectric transmission, voxel materials, temporal and atrous denoising"); return 1;
}
int FinishTransparency(ID3D11ShaderResourceView* depth,ID3D11ShaderResourceView* light,ID3D11RenderTargetView* target) {
if(!opaqueReady)return 0;opaqueReady=false;
// Frame already queued context11->Wait for the DX12 fence. This pass
// only appends DX11 commands on that same immediate context; it does
// not read back or overwrite DX12 resources. A second CPU fence wait
// here needlessly stalls engine render submission behind the ray pass.
// Keep WaitPrevious at allocator/upload reuse and resource destruction.
RtParameters params=lastParameters;params.pathSettings[2]=2;
ComPtr<ID3DDeviceContextState> previous;context11->SwapDeviceContextState(isolatedState.Get(),&previous);
try {context11->ClearState();Composite(depth,nullptr,light,nullptr,nullptr,target,params);context11->ClearState();}
catch(...){context11->SwapDeviceContextState(previous.Get(),nullptr);throw;}
context11->SwapDeviceContextState(previous.Get(),nullptr);return 1;
}
void Composite(ID3D11ShaderResourceView* depth,ID3D11ShaderResourceView* normal,ID3D11ShaderResourceView* light,ID3D11ShaderResourceView* material,ID3D11ShaderResourceView* albedo,ID3D11RenderTargetView* target,const RtParameters& params) {
context11->UpdateSubresource(constants11.Get(),0,nullptr,¶ms,0,0);ID3D11Buffer* cb=constants11.Get();
// The HDR source is also the render target: make an SRV copy before binding.
ComPtr<ID3D11Resource> lightResource; light->GetResource(&lightResource);
ComPtr<ID3D11Texture2D> lightTexture; Check(lightResource.As(&lightTexture), "HDR texture");
D3D11_TEXTURE2D_DESC hdr{}; lightTexture->GetDesc(&hdr); hdr.BindFlags = D3D11_BIND_SHADER_RESOURCE; hdr.MiscFlags = 0;
if (!hdrCopy || hdrWidth != hdr.Width || hdrHeight != hdr.Height || hdrFormat != hdr.Format) {
hdrCopy.Reset(); hdrSrv.Reset(); Check(device11->CreateTexture2D(&hdr, nullptr, &hdrCopy), "HDR copy texture");
Check(device11->CreateShaderResourceView(hdrCopy.Get(), nullptr, &hdrSrv), "HDR copy SRV"); hdrWidth = hdr.Width; hdrHeight = hdr.Height; hdrFormat = hdr.Format;
}
context11->CopyResource(hdrCopy.Get(), lightTexture.Get());
ID3D11ShaderResourceView* views[] = {depth, normal, hdrSrv.Get(), material, positions.srv.Get(), normals.srv.Get(), result.srv.Get(),reflection.srv.Get(),indirect.srv.Get(),albedo,glassReflection.srv.Get(),glassData.srv.Get(),glassRefraction.srv.Get(),glassSharp.srv.Get(),glassGuide.srv.Get(),glassFactor.srv.Get()};
context11->PSSetShaderResources(0, 16, views); context11->PSSetConstantBuffers(0, 1, &cb);
context11->VSSetShader(fullscreen.Get(), nullptr, 0); context11->PSSetShader(composite.Get(), nullptr, 0);
context11->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
D3D11_VIEWPORT viewport{0,0,(float)params.sizes[0],(float)params.sizes[1],0,1}; context11->RSSetViewports(1, &viewport);
context11->RSSetState(rasterizer.Get());
context11->OMSetRenderTargets(1, &target, nullptr); context11->Draw(3, 0); context11->ClearState();
}
private:
ComPtr<ID3D11Texture2D> hdrCopy; ComPtr<ID3D11ShaderResourceView> hdrSrv;
UINT hdrWidth = 0, hdrHeight = 0; DXGI_FORMAT hdrFormat = DXGI_FORMAT_UNKNOWN;
};
RT_API int RtCreate(void* device11, void** output) {
if (!output) return E_INVALIDARG;
auto c = new Context(); *output = c;
try { c->Initialize(device11); return 0; } catch (const Failure& e) { c->Fail(e); return e.code; } catch (...) { c->Fail(Failure(E_FAIL,"Native initialization exception")); return E_FAIL; }
}
RT_API int RtEnvironment(void* context,void* cubeSrv) {
if(!context)return E_INVALIDARG;auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
auto source=(ID3D11ShaderResourceView*)cubeSrv;
if(source){D3D11_SHADER_RESOURCE_VIEW_DESC desc{};source->GetDesc(&desc);if(desc.ViewDimension!=D3D11_SRV_DIMENSION_TEXTURECUBE)return E_INVALIDARG;}
c->environmentSource=source;return 0;
}
RT_API int RtFinishTransparency(void* context,void* depth,void* light,void* target) {
if(!context || !depth || !light || !target)return E_INVALIDARG;auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
try{return c->FinishTransparency((ID3D11ShaderResourceView*)depth,(ID3D11ShaderResourceView*)light,(ID3D11RenderTargetView*)target);}
catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtGlassMaterials(void* context,const RtGlassMaterial* materials,uint32_t count) {
if(!context || count>1024 || (count && !materials)) return E_INVALIDARG;
auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
for(uint32_t i=0;i<count;i++) {
const float* v=(const float*)&materials[i];
for(int j=0;j<8;j++) if(!std::isfinite(v[j])) return E_INVALIDARG;
if(materials[i].optics[0]<1 || materials[i].optics[0]>2.5f || materials[i].optics[1]<=0 || materials[i].optics[1]>.5f) return E_INVALIDARG;
for(int j=0;j<4;j++) if(v[j]<0 || v[j]>1) return E_INVALIDARG;
}
if(c->glassMaterials.size()==count && (!count || memcmp(c->glassMaterials.data(),materials,count*sizeof(RtGlassMaterial))==0)) return 0;
try {
c->WaitPrevious(); c->glassMaterials.clear();
if(count) { c->glassMaterials.assign(materials,materials+count);c->Upload(c->glassBuffer.Get(),materials,count*sizeof(RtGlassMaterial)); }
c->historyValid=false; return 0;
} catch(const Failure& e) { c->Fail(e);return e.code; } catch(...) { return E_FAIL; }
}
RT_API int RtLights(void* context,const RtLight* lights,uint32_t count) {
if(!context || count>64 || (count && !lights)) return E_INVALIDARG;
auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
for(uint32_t i=0;i<count;i++) {
for(int j=0;j<16;j++) if(!std::isfinite(((const float*)&lights[i])[j])) return E_INVALIDARG;
if(lights[i].positionRange[3]<=0 || lights[i].colorIntensity[3]<0 || lights[i].directionCone[3]<-1 || lights[i].directionCone[3]>1) return E_INVALIDARG;
}
if(c->lights.size()==count && (!count || memcmp(c->lights.data(),lights,count*sizeof(RtLight))==0)) return 0;
try { c->WaitPrevious();c->lights.clear();if(count){c->lights.assign(lights,lights+count);c->Upload(c->lightBuffer.Get(),lights,count*sizeof(RtLight));}return 0; }
catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtMesh(void* context, uint32_t id, const float* xyz, uint32_t vertices, const uint32_t* indices, uint32_t indexCount, const uint32_t* materials) {
if (!context) return E_INVALIDARG; auto c = (Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
if (c->meshes.count(id)) return 0;
if (!c->ready || !xyz || !indices || !vertices || vertices > 1000000 || !indexCount || indexCount > 6000000 || indexCount%3 || c->meshes.size() >= 4096) return E_INVALIDARG;
for (uint32_t i=0; i<indexCount; ++i) if(indices[i]>=vertices) return E_INVALIDARG;
for(size_t i=0;i<size_t(vertices)*8;i++) if(!std::isfinite(xyz[i])) return E_INVALIDARG;
if(c->vertexData.size()+vertices>8000000 || c->triangleData.size()+indexCount/3>8000000) return E_OUTOFMEMORY;
for(uint32_t i=0;materials && i<indexCount/3;i++) {
if((materials[i]&0xc0000000u)==0xc0000000u) return E_INVALIDARG;
if((materials[i]&0x40000000u) && ((materials[i]>>20)&1023)>=c->glassMaterials.size()) return E_INVALIDARG;
if(materials[i]&0x80000000u) for(int j=0;j<3;j++) {
auto v=xyz+indices[i*3+j]*8;
if(v[5]<0 || v[5]>1023 || v[6]<0 || v[6]>1023 || v[7]<=0) return E_INVALIDARG;
}
}
try {
Mesh mesh; mesh.vertices.assign(xyz, xyz + size_t(vertices)*8); mesh.indices.assign(indices, indices+indexCount); mesh.triangles = indexCount/3;
mesh.triangleOffset=(uint32_t)c->triangleData.size(); uint32_t vertexOffset=(uint32_t)c->vertexData.size();
mesh.vertexOffset=vertexOffset;mesh.vertexCount=vertices;
auto data=(const Vertex*)xyz; c->vertexData.insert(c->vertexData.end(),data,data+vertices);
for(uint32_t i=0;i<indexCount/3;i++) c->triangleData.push_back({{indices[i*3]+vertexOffset,indices[i*3+1]+vertexOffset,indices[i*3+2]+vertexOffset},materials?materials[i]:0});
c->geometryDirty=true; c->meshes.emplace(id, std::move(mesh)); return 0;
}
catch (...) { c->Fail(Failure(E_OUTOFMEMORY,"Model staging allocation")); return E_OUTOFMEMORY; }
}
RT_API int RtMaterial(void* context,uint32_t id,const uint8_t* dds,uint32_t bytes,uint32_t linear) {
if(!context || !id || id>=1024) return E_INVALIDARG; auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
if(c->materials.count(id)) return 0;
try {
Material material;
if(!ParseDds(dds,bytes,material,linear!=0)) {
Material fallback;
// A missing extension map has no emission or colorization. The
// gray color-texture fallback would otherwise invent glowing faces.
if(linear) {fallback.format=DXGI_FORMAT_R8G8B8A8_UNORM;fallback.data={0,0,0,0};}
c->materials.emplace(id,std::move(fallback));return 1;
}
c->materials.emplace(id,std::move(material));return 0;
} catch(...) {return E_OUTOFMEMORY;}
}
RT_API int RtSurfaceMaterials(void* context,const RtSurfaceMaterial* materials,uint32_t count) {
if(!context || !materials || !count || count>1024)return E_INVALIDARG;
auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
for(uint32_t i=0;i<count;i++) {
if(materials[i].texture>=1024 || (materials[i].flags&~15u))return E_INVALIDARG;
for(float v:materials[i].colorEmission)if(!std::isfinite(v)||v<0||v>32)return E_INVALIDARG;
}
if(memcmp(c->surfaces.data(),materials,count*sizeof(RtSurfaceMaterial))==0)return 0;
try {c->WaitPrevious();memcpy(c->surfaces.data(),materials,count*sizeof(RtSurfaceMaterial));
c->Upload(c->surfaceBuffer.Get(),c->surfaces.data(),c->surfaces.size()*sizeof(RtSurfaceMaterial));return 0;}
catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtDynamicMaterial(void* context,uint32_t id,void* textureSrv) {
if(!context || id<992 || id>=1024)return E_INVALIDARG;
auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
try {
c->WaitPrevious();auto& d=c->dynamicTextures[id];
if(!textureSrv){d.source.Reset();return 0;}
auto source=(ID3D11ShaderResourceView*)textureSrv;D3D11_SHADER_RESOURCE_VIEW_DESC srv{};source->GetDesc(&srv);
if(srv.ViewDimension!=D3D11_SRV_DIMENSION_TEXTURE2D || srv.Texture2D.MostDetailedMip!=0)return 1;
ComPtr<ID3D11Resource> resource;source->GetResource(&resource);ComPtr<ID3D11Texture2D> texture;
if(FAILED(resource.As(&texture)))return 1;
D3D11_TEXTURE2D_DESC desc{};texture->GetDesc(&desc);
if(!desc.Width || !desc.Height || desc.Width>2048 || desc.Height>2048 || desc.ArraySize!=1 || desc.SampleDesc.Count!=1)return 1;
if(desc.Width!=d.width || desc.Height!=d.height) {
uint64_t pixels=c->dynamicPixels-uint64_t(d.width)*d.height+uint64_t(desc.Width)*desc.Height;
if(pixels>16u*1024*1024)return 1;
auto shared=c->Texture(DXGI_FORMAT_R16G16B16A16_FLOAT,desc.Width,desc.Height);
d.shared=std::move(shared);d.width=desc.Width;d.height=desc.Height;c->dynamicPixels=pixels;
}
d.source=source;return 0;
}catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtRetainMeshes(void* context,const uint32_t* ids,uint32_t count) {
if(!context) return E_INVALIDARG; auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
try { c->Retain(ids,count); return 0; }
catch(const Failure& e) { c->Fail(e); return e.code; }
catch(...) { c->Fail(Failure(E_OUTOFMEMORY,"Scene retirement allocation")); return E_OUTOFMEMORY; }
}
RT_API int RtFrame(void* context, void* depth, void* normal, void* light, void* material, void* albedo, void* target, const RtInstance* instances, uint32_t count, const RtParameters* parameters) {
if (!context || !parameters) return E_INVALIDARG; auto c = (Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
auto start = std::chrono::steady_clock::now(); int result = 0;
try { result = c->Frame((ID3D11ShaderResourceView*)depth,(ID3D11ShaderResourceView*)normal,(ID3D11ShaderResourceView*)light,(ID3D11ShaderResourceView*)material,(ID3D11ShaderResourceView*)albedo,(ID3D11RenderTargetView*)target,instances,count,*parameters); }
catch (const Failure& e) { c->Fail(e); result = e.code; } catch (...) { c->Fail(Failure(E_FAIL,"Native frame exception")); result = E_FAIL; }
c->status.cpuMilliseconds = std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-start).count(); return result;
}
RT_API void RtGetStatus(void* context, RtStatus* status) { if(context && status) { auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex); *status=c->status; } }
RT_API void RtDestroy(void* context) { delete (Context*)context; }
#include "Native.h"
#include "Dds.h"
#include <windows.h>
#include <d3d11_4.h>
#include <d3d12.h>
#include <dxgi1_6.h>
#include <wrl/client.h>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <mutex>
#include <stdexcept>
#include <chrono>
#include <algorithm>
#include <cstring>
#include <cmath>
#include "PackShader.h"
#include "CompositeShader.h"
#include "FullscreenShader.h"
#include "RaysShader.h"
#include "DenoiseShader.h"
#include "CopyScreenShader.h"
#include "CopyEnvironmentShader.h"
#include "EnvironmentRowsShader.h"
#include "EnvironmentTotalShader.h"
#include "TemporalShader.h"
#include "DenoiseGlassShader.h"
using Microsoft::WRL::ComPtr;
struct Failure : std::runtime_error { HRESULT code; Failure(HRESULT c, const char* s) : runtime_error(s), code(c) {} };
static void Check(HRESULT result, const char* operation) { if (FAILED(result)) throw Failure(result, operation); }
static uint64_t Align(uint64_t n, uint64_t a = 256) { return (n + a - 1) & ~(a - 1); }
struct Mesh {
std::vector<float> vertices; std::vector<uint32_t> indices;
ComPtr<ID3D12Resource> acceleration;
uint64_t bytes = 0; uint32_t triangles = 0;
uint32_t triangleOffset = 0, vertexOffset = 0, vertexCount = 0;
};
struct Vertex { float position[3],uv[2],tint[3]; };
struct Triangle { uint32_t v[3],material; };
struct InstanceMaterial { uint32_t triangleOffset; float tint[3]; float previousTransform[12]; uint32_t previousValid, reserved[3]; };
static_assert(sizeof(RtSurfaceMaterial)==32,"Surface material shader layout");
static_assert(sizeof(RtParameters)==448 && sizeof(RtInstance)==72 && sizeof(InstanceMaterial)==80 && sizeof(Vertex)==32 && sizeof(RtGlassMaterial)==32,"Managed/native/shader ABI mismatch");
struct SharedTexture {
ComPtr<ID3D12Resource> resource;
ComPtr<ID3D11Texture2D> texture;
ComPtr<ID3D11ShaderResourceView> srv;
ComPtr<ID3D11UnorderedAccessView> uav;
};
struct DynamicTexture { SharedTexture shared; ComPtr<ID3D11ShaderResourceView> source; UINT width=0,height=0; };
class Context {
public:
std::mutex mutex;
RtStatus status{};
ComPtr<ID3D11Device5> device11;
ComPtr<ID3D11DeviceContext4> context11;
ComPtr<ID3DDeviceContextState> isolatedState;
ComPtr<ID3D11ComputeShader> pack,copyScreen,copyEnvironment;
ComPtr<ID3D11SamplerState> environmentSampler;
ComPtr<ID3D11ShaderResourceView> environmentSource;
RtParameters lastParameters{};
bool opaqueReady=false;
ComPtr<ID3D11PixelShader> composite;
ComPtr<ID3D11VertexShader> fullscreen;
ComPtr<ID3D11Buffer> constants11;
ComPtr<ID3D11RasterizerState> rasterizer;
ComPtr<ID3D12Device5> device;
ComPtr<ID3D12CommandQueue> queue;
ComPtr<ID3D12CommandAllocator> allocator;
ComPtr<ID3D12GraphicsCommandList4> list;
ComPtr<ID3D12Fence> fence;
ComPtr<ID3D11Fence> fence11;
ComPtr<ID3D12RootSignature> root;
ComPtr<ID3D12PipelineState> pipeline,denoisePipeline,environmentRowsPipeline,environmentTotalPipeline,temporalPipeline,glassDenoisePipeline;
ComPtr<ID3D12DescriptorHeap> descriptors;
ComPtr<ID3D12Resource> tlas, scratch, instances, constants;
SharedTexture positions, normals, result, reflection, indirect,glassReflection,glassData,filtered,glassRefraction,moments,filteredReflection;
SharedTexture environmentMap,surfaceGuide,glassSharp,glassGuide,glassRaw,glassNormal,glassFactor;
ComPtr<ID3D12Resource> environmentCdf;
ComPtr<ID3D12Resource> glassBuffer,lightBuffer;
ComPtr<ID3D12Resource> surfaceBuffer;
std::vector<RtSurfaceMaterial> surfaces;
std::unordered_map<uint32_t,DynamicTexture> dynamicTextures;
uint64_t dynamicPixels=0;
std::vector<RtLight> lights;
ComPtr<ID3D12QueryHeap> timer;
ComPtr<ID3D12Resource> timerReadback;
UINT64 timerFrequency=0;bool timerReady=false;
std::vector<RtGlassMaterial> glassMaterials;
std::unordered_map<uint32_t, Mesh> meshes;
std::unordered_map<uint32_t,Material> materials;
std::vector<Vertex> vertexData;
std::vector<Triangle> triangleData;
std::vector<D3D12_RAYTRACING_INSTANCE_DESC> instanceData;
std::vector<RtInstance> lastScene;
std::unordered_map<uint64_t,uint32_t> previousByKey;
std::vector<InstanceMaterial> instanceMaterials;
std::vector<ComPtr<ID3D12Resource>> textureResources;
ComPtr<ID3D12Resource> vertexBuffer,triangleBuffer,instanceMaterialBuffer;
ComPtr<ID3D12Resource> historyTextures[10];
bool historyValid=false;
bool geometryDirty=true;
size_t uploadedVertices=0,uploadedTriangles=0;
uint64_t materialBytes=0;
std::vector<ComPtr<ID3D12Resource>> transient;
uint64_t submitted = 0, accelerationBytes = 0, triangles = 0;
uint32_t width = 0, height = 0;
HANDLE completed = nullptr;
bool ready = false;
~Context() {
if (fence && submitted && completed && fence->GetCompletedValue() < submitted) {
if (SUCCEEDED(fence->SetEventOnCompletion(submitted, completed))) WaitForSingleObject(completed, 2000);
}
if (completed) CloseHandle(completed);
}
void Fail(const Failure& e) {
ready = false; status.lastHresult = e.code;
strncpy_s(status.message, e.what(), _TRUNCATE);
}
void Initialize(void* pointer) {
status.version = 2;
if (!pointer) throw Failure(E_INVALIDARG, "Missing D3D11 device");
Check(((IUnknown*)pointer)->QueryInterface(IID_PPV_ARGS(&device11)), "D3D11.4 device required");
ComPtr<ID3D11DeviceContext> immediate;
device11->GetImmediateContext(&immediate);
Check(immediate.As(&context11), "D3D11.4 context required");
ComPtr<IDXGIDevice> dxgi; Check(device11.As(&dxgi), "DXGI device");
ComPtr<IDXGIAdapter> adapter; Check(dxgi->GetAdapter(&adapter), "Game adapter");
Check(D3D12CreateDevice(adapter.Get(), D3D_FEATURE_LEVEL_12_0, IID_PPV_ARGS(&device)), "D3D12 device on game adapter");
D3D12_FEATURE_DATA_D3D12_OPTIONS5 options{};
Check(device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &options, sizeof(options)), "Ray tracing feature query");
status.tier = (uint32_t)options.RaytracingTier;
if (options.RaytracingTier < D3D12_RAYTRACING_TIER_1_1) throw Failure(DXGI_ERROR_UNSUPPORTED, "DXR 1.1 required; no software fallback");
D3D12_COMMAND_QUEUE_DESC q{}; q.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
Check(device->CreateCommandQueue(&q, IID_PPV_ARGS(&queue)), "Ray tracing queue");
Check(queue->GetTimestampFrequency(&timerFrequency),"GPU timestamp frequency");
D3D12_QUERY_HEAP_DESC timerDesc{};timerDesc.Type=D3D12_QUERY_HEAP_TYPE_TIMESTAMP;timerDesc.Count=2;
Check(device->CreateQueryHeap(&timerDesc,IID_PPV_ARGS(&timer)),"GPU timestamp queries");
timerReadback=Buffer(16,D3D12_HEAP_TYPE_READBACK,D3D12_RESOURCE_STATE_COPY_DEST);
Check(device->CreateCommandAllocator(q.Type, IID_PPV_ARGS(&allocator)), "Command allocator");
Check(device->CreateCommandList(0, q.Type, allocator.Get(), nullptr, IID_PPV_ARGS(&list)), "Command list");
Check(list->Close(), "Close initial command list");
Check(device->CreateFence(0, D3D12_FENCE_FLAG_SHARED, IID_PPV_ARGS(&fence)), "Shared fence");
HANDLE shared = nullptr;
Check(device->CreateSharedHandle(fence.Get(), nullptr, GENERIC_ALL, nullptr, &shared), "Fence handle");
HRESULT open = device11->OpenSharedFence(shared, IID_PPV_ARGS(&fence11)); CloseHandle(shared);
Check(open, "Open D3D12 fence in D3D11");
completed = CreateEvent(nullptr, FALSE, FALSE, nullptr);
if (!completed) throw Failure(HRESULT_FROM_WIN32(GetLastError()), "Fence event");
Check(device11->CreateComputeShader(PackBytes, sizeof(PackBytes), nullptr, &pack), "Pack shader");
Check(device11->CreatePixelShader(CompositeBytes, sizeof(CompositeBytes), nullptr, &composite), "Composite shader");
Check(device11->CreateVertexShader(FullscreenBytes, sizeof(FullscreenBytes), nullptr, &fullscreen), "Fullscreen shader");
D3D11_BUFFER_DESC cb{}; cb.ByteWidth = sizeof(RtParameters); cb.Usage = D3D11_USAGE_DEFAULT; cb.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
Check(device11->CreateBuffer(&cb, nullptr, &constants11), "D3D11 constants");
D3D11_RASTERIZER_DESC raster{}; raster.FillMode=D3D11_FILL_SOLID; raster.CullMode=D3D11_CULL_NONE; raster.DepthClipEnable=TRUE;
Check(device11->CreateRasterizerState(&raster,&rasterizer),"Fullscreen rasterizer");
auto feature = device11->GetFeatureLevel();
Check(device11->CreateDeviceContextState(0, &feature, 1, D3D11_SDK_VERSION, __uuidof(ID3D11Device), nullptr, &isolatedState), "Isolated D3D11 state");
D3D12_DESCRIPTOR_RANGE ranges[7]{};
ranges[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[0].NumDescriptors = 2; ranges[0].BaseShaderRegister = 1;
ranges[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV; ranges[1].NumDescriptors = 9;
ranges[2].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[2].NumDescriptors = 1024; ranges[2].BaseShaderRegister=10;
ranges[3].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[3].NumDescriptors = 4; ranges[3].BaseShaderRegister=6;
ranges[4].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; ranges[4].NumDescriptors = 3; ranges[4].BaseShaderRegister=1036;
ranges[5].RangeType=D3D12_DESCRIPTOR_RANGE_TYPE_SRV;ranges[5].NumDescriptors=5;ranges[5].BaseShaderRegister=1040;
ranges[6].RangeType=D3D12_DESCRIPTOR_RANGE_TYPE_UAV;ranges[6].NumDescriptors=5;ranges[6].BaseShaderRegister=10;
D3D12_ROOT_PARAMETER parameters[17]{};
parameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV;
parameters[1].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
for (int i = 2; i < 4; ++i) { parameters[i].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[i].DescriptorTable.NumDescriptorRanges = 1; parameters[i].DescriptorTable.pDescriptorRanges = &ranges[i-2]; }
for(int i=4;i<7;i++) { parameters[i].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV; parameters[i].Descriptor.ShaderRegister=i-1; }
parameters[7].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[7].DescriptorTable.NumDescriptorRanges=1; parameters[7].DescriptorTable.pDescriptorRanges=&ranges[2];
parameters[8].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[8].DescriptorTable.NumDescriptorRanges=1; parameters[8].DescriptorTable.pDescriptorRanges=&ranges[3];
parameters[9].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV; parameters[9].Descriptor.ShaderRegister=1034;
parameters[10].ParameterType=D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; parameters[10].Constants.ShaderRegister=1; parameters[10].Constants.Num32BitValues=1;
parameters[11].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV;parameters[11].Descriptor.ShaderRegister=1035;
parameters[12].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; parameters[12].DescriptorTable.NumDescriptorRanges=1; parameters[12].DescriptorTable.pDescriptorRanges=&ranges[4];
parameters[13].ParameterType=D3D12_ROOT_PARAMETER_TYPE_SRV;parameters[13].Descriptor.ShaderRegister=1039;
parameters[14].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;parameters[14].DescriptorTable.NumDescriptorRanges=1;parameters[14].DescriptorTable.pDescriptorRanges=&ranges[5];
parameters[15].ParameterType=D3D12_ROOT_PARAMETER_TYPE_UAV;parameters[15].Descriptor.ShaderRegister=9;
parameters[16].ParameterType=D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;parameters[16].DescriptorTable.NumDescriptorRanges=1;parameters[16].DescriptorTable.pDescriptorRanges=&ranges[6];
D3D12_STATIC_SAMPLER_DESC sampler{}; sampler.Filter=D3D12_FILTER_MIN_MAG_MIP_LINEAR; sampler.AddressU=sampler.AddressV=sampler.AddressW=D3D12_TEXTURE_ADDRESS_MODE_WRAP; sampler.MaxLOD=D3D12_FLOAT32_MAX;
D3D12_ROOT_SIGNATURE_DESC signature{}; signature.NumParameters = 17; signature.pParameters = parameters; signature.NumStaticSamplers=1; signature.pStaticSamplers=&sampler;
ComPtr<ID3DBlob> blob, errors;
Check(D3D12SerializeRootSignature(&signature, D3D_ROOT_SIGNATURE_VERSION_1, &blob, &errors), "Serialize root signature");
Check(device->CreateRootSignature(0, blob->GetBufferPointer(), blob->GetBufferSize(), IID_PPV_ARGS(&root)), "Root signature");
D3D12_COMPUTE_PIPELINE_STATE_DESC ps{}; ps.pRootSignature = root.Get(); ps.CS = { RaysBytes, sizeof(RaysBytes) };
Check(device->CreateComputePipelineState(&ps, IID_PPV_ARGS(&pipeline)), "DXR inline ray query pipeline");
ps.CS={DenoiseBytes,sizeof(DenoiseBytes)}; Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&denoisePipeline)),"Edge-aware atrous denoiser");
ps.CS={DenoiseGlassBytes,sizeof(DenoiseGlassBytes)}; Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&glassDenoisePipeline)),"Reflected-surface illumination denoiser");
D3D12_DESCRIPTOR_HEAP_DESC heap{}; heap.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; heap.NumDescriptors = 1052; heap.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
Check(device->CreateDescriptorHeap(&heap, IID_PPV_ARGS(&descriptors)), "Descriptors");
constants = Buffer(Align(sizeof(RtParameters)), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
glassBuffer=Buffer(1024*sizeof(RtGlassMaterial),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
RtGlassMaterial clearGlass{{1,1,1,.04f},{1.52f,.01f,0,0}}; Upload(glassBuffer.Get(),&clearGlass,sizeof(clearGlass));
lightBuffer=Buffer(64*sizeof(RtLight),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
materials.emplace(0,Material{});
Check(device11->CreateComputeShader(CopyScreenBytes,sizeof(CopyScreenBytes),nullptr,©Screen),"Screen texture copier");
surfaceBuffer=Buffer(1024*sizeof(RtSurfaceMaterial),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
surfaces.resize(1024);for(auto& s:surfaces) for(float& v:s.colorEmission)v=1;
Upload(surfaceBuffer.Get(),surfaces.data(),surfaces.size()*sizeof(RtSurfaceMaterial));
Check(device11->CreateComputeShader(CopyEnvironmentBytes,sizeof(CopyEnvironmentBytes),nullptr,©Environment),"Environment copier");
D3D11_SAMPLER_DESC sampler11{};sampler11.Filter=D3D11_FILTER_MIN_MAG_MIP_LINEAR;sampler11.AddressU=sampler11.AddressV=sampler11.AddressW=D3D11_TEXTURE_ADDRESS_CLAMP;sampler11.MaxLOD=D3D11_FLOAT32_MAX;
Check(device11->CreateSamplerState(&sampler11,&environmentSampler),"Environment sampler");
environmentMap=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT,256,128);
environmentCdf=Buffer((256*128+129)*sizeof(float),D3D12_HEAP_TYPE_DEFAULT,D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
ps.CS={EnvironmentRowsBytes,sizeof(EnvironmentRowsBytes)};Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&environmentRowsPipeline)),"Environment row distribution");
ps.CS={EnvironmentTotalBytes,sizeof(EnvironmentTotalBytes)};Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&environmentTotalPipeline)),"Environment marginal distribution");
ps.CS={TemporalBytes,sizeof(TemporalBytes)};Check(device->CreateComputePipelineState(&ps,IID_PPV_ARGS(&temporalPipeline)),"Responsive temporal lighting");
ready = true; strcpy_s(status.message, "DXR 1.1 ready; waiting for scene geometry");
}
ComPtr<ID3D12Resource> Buffer(uint64_t bytes, D3D12_HEAP_TYPE heap, D3D12_RESOURCE_STATES state, D3D12_RESOURCE_FLAGS flags = D3D12_RESOURCE_FLAG_NONE) {
D3D12_HEAP_PROPERTIES props{}; props.Type = heap;
D3D12_RESOURCE_DESC desc{}; desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; desc.Width = std::max<uint64_t>(256, Align(bytes)); desc.Height = 1; desc.DepthOrArraySize = 1; desc.MipLevels = 1; desc.SampleDesc.Count = 1; desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; desc.Flags = flags;
ComPtr<ID3D12Resource> resource;
Check(device->CreateCommittedResource(&props, D3D12_HEAP_FLAG_NONE, &desc, state, nullptr, IID_PPV_ARGS(&resource)), "Allocate ray tracing buffer");
return resource;
}
void Upload(ID3D12Resource* resource, const void* data, size_t bytes) {
void* mapped = nullptr; D3D12_RANGE read{0,0}; Check(resource->Map(0, &read, &mapped), "Map upload buffer");
memcpy(mapped, data, bytes); D3D12_RANGE written{0,bytes}; resource->Unmap(0, &written);
}
void Barrier(ID3D12Resource* resource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after) {
D3D12_RESOURCE_BARRIER barrier{}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Transition = {resource, D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES, before, after}; list->ResourceBarrier(1, &barrier);
}
void UavBarrier(ID3D12Resource* resource) {
D3D12_RESOURCE_BARRIER barrier{}; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV; barrier.UAV.pResource = resource; list->ResourceBarrier(1, &barrier);
}
void WaitPrevious() {
if (!submitted || fence->GetCompletedValue() >= submitted) return;
Check(fence->SetEventOnCompletion(submitted, completed), "Fence completion");
if (WaitForSingleObject(completed, 2000) != WAIT_OBJECT_0) throw Failure(DXGI_ERROR_DEVICE_HUNG, "Ray tracing GPU timeout; effect disabled");
}
SharedTexture Texture(DXGI_FORMAT format,UINT textureWidth=0,UINT textureHeight=0,bool shared=true) {
SharedTexture texture;
D3D12_HEAP_PROPERTIES props{}; props.Type = D3D12_HEAP_TYPE_DEFAULT;
D3D12_RESOURCE_DESC desc{}; desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; desc.Width = textureWidth?textureWidth:width; desc.Height = textureHeight?textureHeight:height; desc.DepthOrArraySize = 1; desc.MipLevels = 1; desc.Format = format; desc.SampleDesc.Count = 1; desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS | D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS;
Check(device->CreateCommittedResource(&props, shared?D3D12_HEAP_FLAG_SHARED:D3D12_HEAP_FLAG_NONE, &desc, D3D12_RESOURCE_STATE_COMMON, nullptr, IID_PPV_ARGS(&texture.resource)), "Ray tracing texture");
if(!shared)return texture; // FP32 guides stay on DX12; DX11 sharing has a restricted format set.
HANDLE handle = nullptr; Check(device->CreateSharedHandle(texture.resource.Get(), nullptr, GENERIC_ALL, nullptr, &handle), "Texture handle");
HRESULT hr = device11->OpenSharedResource1(handle, IID_PPV_ARGS(&texture.texture)); CloseHandle(handle); Check(hr, "Open D3D12 texture in D3D11");
Check(device11->CreateShaderResourceView(texture.texture.Get(), nullptr, &texture.srv), "Texture SRV");
Check(device11->CreateUnorderedAccessView(texture.texture.Get(), nullptr, &texture.uav), "Texture UAV");
return texture;
}
void Resize(uint32_t w, uint32_t h) {
if (w == width && h == height) return;
if (!w || !h || w > 4096 || h > 4096) throw Failure(E_INVALIDARG, "Unsupported trace resolution");
width = w; height = h;
positions = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
surfaceGuide=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassSharp=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);glassGuide=Texture(DXGI_FORMAT_R32G32B32A32_FLOAT,0,0,false);
glassRaw=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassNormal=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);glassFactor=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
normals = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
result = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
reflection = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
indirect = Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassReflection=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT); glassData=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT); filtered=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
glassRefraction=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
moments=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
filteredReflection=Texture(DXGI_FORMAT_R16G16B16A16_FLOAT);
auto handle = descriptors->GetCPUDescriptorHandleForHeapStart();
auto step = device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
D3D12_SHADER_RESOURCE_VIEW_DESC srv{}; srv.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; srv.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; srv.Texture2D.MipLevels = 1;
srv.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; device->CreateShaderResourceView(positions.resource.Get(), &srv, handle); handle.ptr += step;
srv.Format = DXGI_FORMAT_R16G16B16A16_FLOAT; device->CreateShaderResourceView(normals.resource.Get(), &srv, handle); handle.ptr += step;
D3D12_UNORDERED_ACCESS_VIEW_DESC uav{}; uav.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D; uav.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
device->CreateUnorderedAccessView(result.resource.Get(), nullptr, &uav, handle);
handle.ptr+=step; device->CreateUnorderedAccessView(reflection.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(indirect.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(glassReflection.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(glassData.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(filtered.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(glassRefraction.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(moments.resource.Get(),nullptr,&uav,handle);
handle.ptr+=step; device->CreateUnorderedAccessView(filteredReflection.resource.Get(),nullptr,&uav,handle);
historyValid=false;
for(int i=0;i<7;i++) {
historyTextures[i].Reset(); D3D12_HEAP_PROPERTIES props{}; props.Type=D3D12_HEAP_TYPE_DEFAULT;
auto desc=(i==0?positions.resource:normals.resource)->GetDesc(); desc.Flags=D3D12_RESOURCE_FLAG_NONE;srv.Format=desc.Format;
Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[i])),"Radiance history texture");
handle.ptr+=step; device->CreateShaderResourceView(historyTextures[i].Get(),&srv,handle);
}
D3D12_HEAP_PROPERTIES props{};props.Type=D3D12_HEAP_TYPE_DEFAULT;auto desc=surfaceGuide.resource->GetDesc();desc.Flags=D3D12_RESOURCE_FLAG_NONE;
historyTextures[7].Reset();Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[7])),"Material history");
handle=descriptors->GetCPUDescriptorHandleForHeapStart();handle.ptr+=1042*step;srv.Format=DXGI_FORMAT_R16G16B16A16_FLOAT;
device->CreateShaderResourceView(environmentMap.resource.Get(),&srv,handle);handle.ptr+=step;
device->CreateShaderResourceView(surfaceGuide.resource.Get(),&srv,handle);handle.ptr+=step;
device->CreateShaderResourceView(historyTextures[7].Get(),&srv,handle);handle.ptr+=step;
desc=glassGuide.resource->GetDesc();desc.Flags=D3D12_RESOURCE_FLAG_NONE;srv.Format=desc.Format;
historyTextures[8].Reset();Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[8])),"Virtual glass hit history");
device->CreateShaderResourceView(historyTextures[8].Get(),&srv,handle);handle.ptr+=step;
desc=glassNormal.resource->GetDesc();desc.Flags=D3D12_RESOURCE_FLAG_NONE;srv.Format=desc.Format;
historyTextures[9].Reset();Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&desc,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,nullptr,IID_PPV_ARGS(&historyTextures[9])),"Reflected surface normal history");
device->CreateShaderResourceView(historyTextures[9].Get(),&srv,handle);handle.ptr+=step;
device->CreateUnorderedAccessView(glassSharp.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
uav.Format=DXGI_FORMAT_R32G32B32A32_FLOAT;
device->CreateUnorderedAccessView(glassGuide.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
uav.Format=DXGI_FORMAT_R16G16B16A16_FLOAT;
device->CreateUnorderedAccessView(glassRaw.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
device->CreateUnorderedAccessView(glassNormal.resource.Get(),nullptr,&uav,handle);handle.ptr+=step;
device->CreateUnorderedAccessView(glassFactor.resource.Get(),nullptr,&uav,handle);
}
bool BuildMeshes() {
uint32_t built = 0;
for (auto& pair : meshes) {
Mesh& mesh = pair.second; if (mesh.acceleration) continue;
if (built++ >= 6) return false;
auto vertex = Buffer(mesh.vertices.size()*sizeof(float), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
auto index = Buffer(mesh.indices.size()*sizeof(uint32_t), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(vertex.Get(), mesh.vertices.data(), mesh.vertices.size()*sizeof(float)); Upload(index.Get(), mesh.indices.data(), mesh.indices.size()*sizeof(uint32_t));
D3D12_RAYTRACING_GEOMETRY_DESC geometry{}; geometry.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES; geometry.Flags = D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE;
geometry.Triangles.VertexBuffer = {vertex->GetGPUVirtualAddress(), 32}; geometry.Triangles.VertexCount = (UINT)mesh.vertices.size()/8; geometry.Triangles.VertexFormat = DXGI_FORMAT_R32G32B32_FLOAT;
geometry.Triangles.IndexBuffer = index->GetGPUVirtualAddress(); geometry.Triangles.IndexCount = (UINT)mesh.indices.size(); geometry.Triangles.IndexFormat = DXGI_FORMAT_R32_UINT;
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS input{}; input.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL; input.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY; input.NumDescs = 1; input.pGeometryDescs = &geometry; input.Flags = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE;
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO info{}; device->GetRaytracingAccelerationStructurePrebuildInfo(&input, &info);
if (!info.ResultDataMaxSizeInBytes || accelerationBytes + info.ResultDataMaxSizeInBytes > 1024ull*1024*1024) throw Failure(E_OUTOFMEMORY, "Ray tracing geometry exceeds 1 GiB budget");
mesh.acceleration = Buffer(info.ResultDataMaxSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
auto temporary = Buffer(info.ScratchDataSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC build{}; build.Inputs = input; build.DestAccelerationStructureData = mesh.acceleration->GetGPUVirtualAddress(); build.ScratchAccelerationStructureData = temporary->GetGPUVirtualAddress();
list->BuildRaytracingAccelerationStructure(&build, 0, nullptr); UavBarrier(mesh.acceleration.Get());
mesh.bytes=info.ResultDataMaxSizeInBytes;
accelerationBytes += mesh.bytes; triangles += mesh.triangles; ++status.meshes;
transient.push_back(vertex); transient.push_back(index); transient.push_back(temporary);
std::vector<float>().swap(mesh.vertices); std::vector<uint32_t>().swap(mesh.indices);
}
return true;
}
void AppendBuffer(ComPtr<ID3D12Resource>& gpu,const void* data,size_t count,size_t stride,size_t& uploadedCount) {
size_t bytes=count*stride;
if(!gpu || gpu->GetDesc().Width<bytes) {
uint64_t capacity=256; while(capacity<bytes) capacity*=2;
gpu=Buffer(capacity,D3D12_HEAP_TYPE_DEFAULT,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); uploadedCount=0;
}
if(count==uploadedCount) return;
size_t start=uploadedCount*stride,added=bytes-start;
auto upload=Buffer(added,D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(upload.Get(),(const uint8_t*)data+start,added);
Barrier(gpu.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyBufferRegion(gpu.Get(),start,upload.Get(),0,added);
Barrier(gpu.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
transient.push_back(upload); uploadedCount=count;
}
void Retain(const uint32_t* ids,uint32_t count) {
if(count>4096 || (count && !ids)) throw Failure(E_INVALIDARG,"Invalid retained mesh list");
WaitPrevious();
std::unordered_set<uint32_t> keep; for(uint32_t i=0;i<count;i++) keep.insert(ids[i]);
bool removed=false; size_t liveVertices=0,liveTriangles=0;
for(auto it=meshes.begin();it!=meshes.end();) {
if(!keep.count(it->first)) {
if(it->second.acceleration) { accelerationBytes-=it->second.bytes; triangles-=it->second.triangles; --status.meshes; }
it=meshes.erase(it); removed=true;
} else { liveVertices+=it->second.vertexCount; liveTriangles+=it->second.triangles; ++it; }
}
if(!removed) return;
status.triangles=triangles; lastScene.clear();
// Removed BLAS are freed immediately after the fence. Compact shading
// arrays only when accumulated holes are material; active BLAS stay valid.
bool compact=(vertexData.size()>liveVertices+100000 && vertexData.size()>liveVertices*3/2)
|| (triangleData.size()>liveTriangles+100000 && triangleData.size()>liveTriangles*3/2);
if(!compact) return;
std::vector<Vertex> nextVertices; nextVertices.reserve(liveVertices);
std::vector<Triangle> nextTriangles; nextTriangles.reserve(liveTriangles);
for(auto& item:meshes) {
auto& mesh=item.second; uint32_t start=(uint32_t)nextVertices.size(),triStart=(uint32_t)nextTriangles.size();
nextVertices.insert(nextVertices.end(),vertexData.begin()+mesh.vertexOffset,vertexData.begin()+mesh.vertexOffset+mesh.vertexCount);
for(uint32_t i=0;i<mesh.triangles;i++) {
auto tri=triangleData[mesh.triangleOffset+i]; for(auto& v:tri.v) v=v-mesh.vertexOffset+start;
nextTriangles.push_back(tri);
}
mesh.vertexOffset=start;mesh.triangleOffset=triStart;
}
vertexData.swap(nextVertices);triangleData.swap(nextTriangles);
uploadedVertices=uploadedTriangles=0;geometryDirty=true;
}
bool BuildMaterials() {
uint32_t built=0;
// Material zero initializes every descriptor so missing assets have a
// visible neutral fallback, never undefined descriptor accesses.
std::vector<uint32_t> pending; if(!materials[0].built) pending.push_back(0);
for(auto& pair:materials) if(pair.first && !pair.second.built) pending.push_back(pair.first);
for(auto id:pending) {
if(built++>=4) return false;
auto& m=materials[id];
if(materialBytes+m.data.size()>512ull*1024*1024) throw Failure(E_OUTOFMEMORY,"Secondary-ray textures exceed 512 MiB budget");
D3D12_RESOURCE_DESC d{}; d.Dimension=D3D12_RESOURCE_DIMENSION_TEXTURE2D; d.Width=m.width; d.Height=m.height; d.DepthOrArraySize=1; d.MipLevels=(UINT16)m.mips; d.Format=m.format; d.SampleDesc.Count=1;
D3D12_HEAP_PROPERTIES props{}; props.Type=D3D12_HEAP_TYPE_DEFAULT;
ComPtr<ID3D12Resource> texture;
Check(device->CreateCommittedResource(&props,D3D12_HEAP_FLAG_NONE,&d,D3D12_RESOURCE_STATE_COPY_DEST,nullptr,IID_PPV_ARGS(&texture)),"Material texture");
std::vector<D3D12_PLACED_SUBRESOURCE_FOOTPRINT> footprints(m.mips); std::vector<UINT> rows(m.mips); std::vector<UINT64> rowBytes(m.mips); UINT64 total=0;
device->GetCopyableFootprints(&d,0,m.mips,0,footprints.data(),rows.data(),rowBytes.data(),&total);
auto upload=Buffer(total,D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ); void* mapped=nullptr; D3D12_RANGE noRead{0,0}; Check(upload->Map(0,&noRead,&mapped),"Material upload");
size_t offset=0;
for(UINT i=0;i<m.mips;i++) {
for(UINT row=0;row<rows[i];row++) { memcpy((uint8_t*)mapped+footprints[i].Offset+size_t(row)*footprints[i].Footprint.RowPitch,m.data.data()+offset,(size_t)rowBytes[i]); offset+=(size_t)rowBytes[i]; }
D3D12_TEXTURE_COPY_LOCATION dst{}; dst.pResource=texture.Get(); dst.Type=D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; dst.SubresourceIndex=i;
D3D12_TEXTURE_COPY_LOCATION src{}; src.pResource=upload.Get(); src.Type=D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT; src.PlacedFootprint=footprints[i]; list->CopyTextureRegion(&dst,0,0,0,&src,nullptr);
}
upload->Unmap(0,nullptr); Barrier(texture.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
D3D12_SHADER_RESOURCE_VIEW_DESC view{}; view.Format=d.Format; view.ViewDimension=D3D12_SRV_DIMENSION_TEXTURE2D; view.Shader4ComponentMapping=D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; view.Texture2D.MipLevels=m.mips;
auto start=descriptors->GetCPUDescriptorHandleForHeapStart(); auto step=device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
start.ptr+=18*step; auto handle=start; handle.ptr+=id*step; device->CreateShaderResourceView(texture.Get(),&view,handle);
if(id==0) for(UINT i=1;i<1024;i++) { auto dst=start; dst.ptr+=i*step; device->CopyDescriptorsSimple(1,dst,start,D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); }
materialBytes+=m.data.size(); textureResources.push_back(texture); transient.push_back(upload); m.data.clear(); m.data.shrink_to_fit(); m.built=true;
}
return true;
}
void BuildInstances(const RtInstance* data, uint32_t count) {
if (!count || count > 120000) throw Failure(E_INVALIDARG, "Instance count must be 1..120000");
auto& native=instanceData; native.clear(); native.reserve(count); instanceMaterials.clear(); instanceMaterials.resize(count);
bool indexedPrevious=false;
for (uint32_t i = 0; i < count; ++i) {
for(float value:data[i].transform) if(!std::isfinite(value)) throw Failure(E_INVALIDARG,"Nonfinite instance transform");
auto found = meshes.find(data[i].mesh); if (found == meshes.end() || !found->second.acceleration) continue;
D3D12_RAYTRACING_INSTANCE_DESC desc{}; memcpy(desc.Transform, data[i].transform, sizeof(desc.Transform));
desc.InstanceMask = 0xff; desc.InstanceID = i; desc.Flags = D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE; desc.AccelerationStructure = found->second.acceleration->GetGPUVirtualAddress(); native.push_back(desc);
const RtInstance* previous=i<lastScene.size() && lastScene[i].mesh==data[i].mesh && lastScene[i].key==data[i].key?&lastScene[i]:nullptr;
// Camera range culling changes indices, not the identity of surviving
// surfaces. Lazily index the previous snapshot only on a mismatch.
if(!previous && data[i].key) {
if(!indexedPrevious) {
previousByKey.clear();previousByKey.reserve(lastScene.size());
for(uint32_t j=0;j<lastScene.size();j++)if(lastScene[j].key)previousByKey.emplace(lastScene[j].key,j);
indexedPrevious=true;
}
auto old=previousByKey.find(data[i].key);
if(old!=previousByKey.end() && lastScene[old->second].mesh==data[i].mesh)previous=&lastScene[old->second];
}
instanceMaterials[i].previousValid=previous?1:0;
memcpy(instanceMaterials[i].previousTransform,previous?previous->transform:data[i].transform,sizeof(data[i].transform));
instanceMaterials[i].triangleOffset=found->second.triangleOffset; memcpy(instanceMaterials[i].tint,data[i].tint,sizeof(data[i].tint));
}
if (native.empty()) throw Failure(E_INVALIDARG, "No ray tracing instances");
if(!instances || instances->GetDesc().Width<native.size()*sizeof(native[0])) instances = Buffer(native.size()*sizeof(native[0]), D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(instances.Get(), native.data(), native.size()*sizeof(native[0]));
if(!instanceMaterialBuffer || instanceMaterialBuffer->GetDesc().Width<instanceMaterials.size()*sizeof(InstanceMaterial)) instanceMaterialBuffer=Buffer(instanceMaterials.size()*sizeof(InstanceMaterial),D3D12_HEAP_TYPE_UPLOAD,D3D12_RESOURCE_STATE_GENERIC_READ);
Upload(instanceMaterialBuffer.Get(),instanceMaterials.data(),instanceMaterials.size()*sizeof(InstanceMaterial));
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS input{}; input.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL; input.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY; input.NumDescs = (UINT)native.size(); input.InstanceDescs = instances->GetGPUVirtualAddress(); input.Flags = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD;
D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO info{}; device->GetRaytracingAccelerationStructurePrebuildInfo(&input, &info);
if (!tlas || tlas->GetDesc().Width < info.ResultDataMaxSizeInBytes) tlas = Buffer(info.ResultDataMaxSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
if (!scratch || scratch->GetDesc().Width < info.ScratchDataSizeInBytes) scratch = Buffer(info.ScratchDataSizeInBytes, D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC build{}; build.Inputs = input; build.DestAccelerationStructureData = tlas->GetGPUVirtualAddress(); build.ScratchAccelerationStructureData = scratch->GetGPUVirtualAddress();
list->BuildRaytracingAccelerationStructure(&build, 0, nullptr); UavBarrier(tlas.Get()); status.instances = (uint32_t)native.size();
}
int Frame(ID3D11ShaderResourceView* depth, ID3D11ShaderResourceView* normal, ID3D11ShaderResourceView* light, ID3D11ShaderResourceView* material, ID3D11ShaderResourceView* albedo, ID3D11RenderTargetView* target, const RtInstance* scene, uint32_t count, const RtParameters& inputParams) {
RtParameters params=inputParams;opaqueReady=false;
params.environment[0]=environmentSource?1.0f:0.0f;
params.transport[3]=(float)lights.size();
if (!ready) return -1;
if (!depth || !normal || !light || !material || !albedo || !target || !scene) throw Failure(E_INVALIDARG, "Missing frame resources");
bool half=params.sizes[2]==(params.sizes[0]+1)/2 && params.sizes[3]==(params.sizes[1]+1)/2;
bool full=params.sizes[2]==params.sizes[0] && params.sizes[3]==params.sizes[1];
if(!params.sizes[0] || !params.sizes[1] || (!half && !full))
throw Failure(E_INVALIDARG,"Frame dimensions must match half or full resolution ray buffers");
WaitPrevious(); transient.clear(); Resize(params.sizes[2], params.sizes[3]);
if(timerReady) {
void* data=nullptr;D3D12_RANGE read{0,16};Check(timerReadback->Map(0,&read,&data),"Read GPU timestamps");
auto time=(uint64_t*)data;status.gpuMilliseconds=double(time[1]-time[0])*1000.0/double(timerFrequency);
D3D12_RANGE noWrite{0,0};timerReadback->Unmap(0,&noWrite);timerReady=false;
}
params.history[0]=historyValid ? params.history[0] : 0; params.history[1]=(float)status.frames;
Check(allocator->Reset(), "Reset allocator"); Check(list->Reset(allocator.Get(), pipeline.Get()), "Reset list");
bool allBuilt = BuildMeshes(); status.triangles = triangles;
allBuilt=BuildMaterials() && allBuilt;
if (!allBuilt || !count) {
Check(list->Close(), "Close geometry build"); ID3D12CommandList* commands[] = {list.Get()}; queue->ExecuteCommandLists(1, commands);
submitted += 2; Check(queue->Signal(fence.Get(), submitted), "Signal geometry build");
strcpy_s(status.message, "Building cached model acceleration structures"); return 0;
}
if(geometryDirty) {
AppendBuffer(vertexBuffer,vertexData.data(),vertexData.size(),sizeof(Vertex),uploadedVertices);
AppendBuffer(triangleBuffer,triangleData.data(),triangleData.size(),sizeof(Triangle),uploadedTriangles); geometryDirty=false;
}
// Snapshots arrive at 10 Hz. Reusing an identical TLAS avoids repeating
// 20k+ instance conversions and a GPU build on every intervening frame.
if(!tlas || lastScene.size()!=count || memcmp(lastScene.data(),scene,size_t(count)*sizeof(RtInstance))!=0) {
BuildInstances(scene,count);lastScene.assign(scene,scene+count);params.history[2]=1;
} else params.history[2]=0;
if(!historyValid)params.history[0]=0;
// A live engine frame must never replace lighting while its environment input is missing.
if(params.pathSettings[0]>0 && params.environment[3]>0 && !environmentSource) {
Check(list->Close(),"Close pending environment build");ID3D12CommandList* commands[]={list.Get()};queue->ExecuteCommandLists(1,commands);
submitted+=2;Check(queue->Signal(fence.Get(),submitted),"Signal pending environment build");return 0;
}
Upload(constants.Get(), ¶ms, sizeof(params));
// Preserve all engine bindings, including shader class instances and UAVs.
ComPtr<ID3DDeviceContextState> previous; context11->SwapDeviceContextState(isolatedState.Get(), &previous);
try {
context11->ClearState(); context11->UpdateSubresource(constants11.Get(), 0, nullptr, ¶ms, 0, 0);
for(auto& entry:dynamicTextures) {
auto& d=entry.second;if(!d.source || !d.shared.resource)continue;
// LCD content changes in-place without changing its SRV. Copy
// the current pixels on the render queue each frame; the 10 Hz
// binding discovery cadence must not become a display delay.
{
ID3D11ShaderResourceView* src=d.source.Get();ID3D11UnorderedAccessView* dst=d.shared.uav.Get();
context11->CSSetShaderResources(0,1,&src);context11->CSSetUnorderedAccessViews(0,1,&dst,nullptr);
context11->CSSetShader(copyScreen.Get(),nullptr,0);context11->Dispatch((d.width+7)/8,(d.height+7)/8,1);
context11->ClearState();
}
auto handle=descriptors->GetCPUDescriptorHandleForHeapStart();
handle.ptr+=(18+entry.first)*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
D3D12_SHADER_RESOURCE_VIEW_DESC view{};view.Format=DXGI_FORMAT_R16G16B16A16_FLOAT;view.ViewDimension=D3D12_SRV_DIMENSION_TEXTURE2D;
view.Shader4ComponentMapping=D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;view.Texture2D.MipLevels=1;
device->CreateShaderResourceView(d.shared.resource.Get(),&view,handle);
}
if(environmentSource) {
ID3D11ShaderResourceView* src=environmentSource.Get();ID3D11UnorderedAccessView* dst=environmentMap.uav.Get();ID3D11SamplerState* sampler=environmentSampler.Get();
context11->CSSetShaderResources(0,1,&src);context11->CSSetUnorderedAccessViews(0,1,&dst,nullptr);context11->CSSetSamplers(0,1,&sampler);
context11->CSSetShader(copyEnvironment.Get(),nullptr,0);context11->Dispatch(32,16,1);context11->ClearState();
}
ID3D11Buffer* cb = constants11.Get(); context11->CSSetConstantBuffers(0, 1, &cb);
ID3D11ShaderResourceView* packViews[] = {depth, normal, light, material}; context11->CSSetShaderResources(0, 4, packViews);context11->CSSetShaderResources(9,1,&albedo);
ID3D11UnorderedAccessView* writes[] = {positions.uav.Get(), normals.uav.Get(),surfaceGuide.uav.Get()}; context11->CSSetUnorderedAccessViews(0, 3, writes, nullptr);
context11->CSSetShader(pack.Get(), nullptr, 0); context11->Dispatch((width+7)/8, (height+7)/8, 1);
context11->ClearState();
Check(context11->Signal(fence11.Get(), submitted + 1), "Signal D3D11 input"); context11->Flush();
Check(queue->Wait(fence.Get(), submitted + 1), "Wait for D3D11 inputs");
for(auto& d:dynamicTextures) if(d.second.source && d.second.shared.resource)
Barrier(d.second.shared.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(environmentMap.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(positions.resource.Get(), D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(normals.resource.Get(), D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(result.resource.Get(), D3D12_RESOURCE_STATE_COMMON, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassData.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassRefraction.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
ID3D12DescriptorHeap* heaps[] = { descriptors.Get() }; list->SetDescriptorHeaps(1, heaps); list->SetComputeRootSignature(root.Get());
list->SetComputeRootShaderResourceView(0, tlas->GetGPUVirtualAddress()); list->SetComputeRootConstantBufferView(1, constants->GetGPUVirtualAddress());
auto gpu = descriptors->GetGPUDescriptorHandleForHeapStart(); list->SetComputeRootDescriptorTable(2, gpu);
gpu.ptr += 2*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(3, gpu);
list->SetComputeRootShaderResourceView(4,vertexBuffer->GetGPUVirtualAddress()); list->SetComputeRootShaderResourceView(5,triangleBuffer->GetGPUVirtualAddress()); list->SetComputeRootShaderResourceView(6,instanceMaterialBuffer->GetGPUVirtualAddress());
gpu.ptr+=9*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(8,gpu);
gpu.ptr+=4*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(12,gpu);
gpu.ptr+=3*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); list->SetComputeRootDescriptorTable(7,gpu);
list->SetComputeRootShaderResourceView(9,glassBuffer->GetGPUVirtualAddress());
list->SetComputeRootShaderResourceView(11,lightBuffer->GetGPUVirtualAddress());
list->SetComputeRootShaderResourceView(13,surfaceBuffer->GetGPUVirtualAddress());
auto guides=descriptors->GetGPUDescriptorHandleForHeapStart();guides.ptr+=1042*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
list->SetComputeRootDescriptorTable(14,guides);list->SetComputeRootUnorderedAccessView(15,environmentCdf->GetGPUVirtualAddress());
guides.ptr+=5*device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);list->SetComputeRootDescriptorTable(16,guides);
list->EndQuery(timer.Get(),D3D12_QUERY_TYPE_TIMESTAMP,0);
if(environmentSource) {
list->SetPipelineState(environmentRowsPipeline.Get());list->Dispatch(1,128,1);UavBarrier(environmentCdf.Get());
list->SetPipelineState(environmentTotalPipeline.Get());list->Dispatch(1,1,1);UavBarrier(environmentCdf.Get());list->SetPipelineState(pipeline.Get());
}
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassSharp.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassFactor.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
list->Dispatch((width+7)/8, (height+7)/8, 1);
UavBarrier(nullptr);list->SetPipelineState(temporalPipeline.Get());list->Dispatch((width+7)/8,(height+7)/8,1);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassSharp.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassFactor.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(result.resource.Get(), D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COMMON);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassData.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassRefraction.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(positions.resource.Get(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_COMMON);
Barrier(normals.resource.Get(), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_COMMON);
ID3D12Resource* sources[]={positions.resource.Get(),normals.resource.Get(),reflection.resource.Get(),indirect.resource.Get(),glassData.resource.Get(),glassReflection.resource.Get(),moments.resource.Get(),surfaceGuide.resource.Get(),glassGuide.resource.Get(),glassNormal.resource.Get()};
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
const bool denoise=params.pathSettings[3]>0;
const bool pathTraced=params.pathSettings[0]>0;
for(int i=0;i<10;i++) {
// In these modes the first spatial pass supplies the history
// sample. Avoid copying the same 4K history texture twice.
if(denoise && ((i==3 && pathTraced) || (i==5 && params.transport[2]>0)))continue;
Barrier(sources[i],D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(historyTextures[i].Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(historyTextures[i].Get(),sources[i]);
Barrier(historyTextures[i].Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(sources[i],D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
}
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
if(params.pathSettings[3]>0 && params.transport[2]>0) {
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
list->SetPipelineState(glassDenoisePipeline.Get());
bool fromRaw=false;
for(UINT step=1;step<=16;step*=2) {
list->SetComputeRoot32BitConstant(10,step|(fromRaw?256:0),0);list->Dispatch((width+7)/8,(height+7)/8,1);
D3D12_RESOURCE_BARRIER sync{};sync.Type=D3D12_RESOURCE_BARRIER_TYPE_UAV;list->ResourceBarrier(1,&sync);
if(step==1) {
// SVGF feedback tap: a one-pixel guided pass removes
// isolated noise before accumulation, without feeding
// the broad final blur or sharp LCD/direct layer back.
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(historyTextures[5].Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(historyTextures[5].Get(),glassRaw.resource.Get());
Barrier(historyTextures[5].Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
fromRaw=!fromRaw;
}
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(glassReflection.resource.Get(),glassRaw.resource.Get());
Barrier(glassRaw.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassReflection.resource.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassGuide.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(glassNormal.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
}
// Feed back only the first, finest guided iteration. Broad spatial
// reconstruction must not accumulate and progressively lose detail.
if(params.pathSettings[3]>0 && (params.pathSettings[0]>0 || params.effects[0]>0 || params.effects[1]>0)) {
Barrier(result.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
list->SetPipelineState(denoisePipeline.Get());
Barrier(positions.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(normals.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
for(UINT step=1;step<=(params.pathSettings[0]>0?8u:4u);step*=2) {
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
if(!pathTraced) {
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_COMMON,D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
list->SetComputeRoot32BitConstant(10,step,0);
list->Dispatch((width+7)/8,(height+7)/8,1);
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(indirect.resource.Get(),filtered.resource.Get());
if(step==1 && params.pathSettings[0]>0) {
Barrier(historyTextures[3].Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(historyTextures[3].Get(),filtered.resource.Get());
Barrier(historyTextures[3].Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
}
Barrier(filtered.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(indirect.resource.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_COMMON);
if(!pathTraced) {
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_SOURCE);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COPY_DEST);
list->CopyResource(reflection.resource.Get(),filteredReflection.resource.Get());
Barrier(filteredReflection.resource.Get(),D3D12_RESOURCE_STATE_COPY_SOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(reflection.resource.Get(),D3D12_RESOURCE_STATE_COPY_DEST,D3D12_RESOURCE_STATE_COMMON);
}
}
Barrier(positions.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(normals.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(moments.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
}
if(params.pathSettings[3]>0 && (params.pathSettings[0]>0 || params.effects[0]>0 || params.effects[1]>0))
Barrier(result.resource.Get(),D3D12_RESOURCE_STATE_UNORDERED_ACCESS,D3D12_RESOURCE_STATE_COMMON);
Barrier(environmentMap.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
Barrier(surfaceGuide.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
list->EndQuery(timer.Get(),D3D12_QUERY_TYPE_TIMESTAMP,1);
for(auto& d:dynamicTextures) if(d.second.source && d.second.shared.resource)
Barrier(d.second.shared.resource.Get(),D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE,D3D12_RESOURCE_STATE_COMMON);
list->ResolveQueryData(timer.Get(),D3D12_QUERY_TYPE_TIMESTAMP,0,2,timerReadback.Get(),0);timerReady=true;
historyValid=true;
Check(list->Close(), "Close ray dispatch"); ID3D12CommandList* commands[] = {list.Get()}; queue->ExecuteCommandLists(1, commands);
submitted += 2; Check(queue->Signal(fence.Get(), submitted), "Signal ray completion"); Check(context11->Wait(fence11.Get(), submitted), "D3D11 wait for rays");
Composite(depth,normal,light,material,albedo,target,params);
lastParameters=params;opaqueReady=params.pathSettings[2]==1;
} catch (...) { context11->SwapDeviceContextState(previous.Get(), nullptr); throw; }
context11->SwapDeviceContextState(previous.Get(), nullptr);
++status.frames; strcpy_s(status.message, "Hardware DXR local paths, thin dielectric transmission, voxel materials, temporal and atrous denoising"); return 1;
}
int FinishTransparency(ID3D11ShaderResourceView* depth,ID3D11ShaderResourceView* light,ID3D11RenderTargetView* target) {
if(!opaqueReady)return 0;opaqueReady=false;
// Frame already queued context11->Wait for the DX12 fence. This pass
// only appends DX11 commands on that same immediate context; it does
// not read back or overwrite DX12 resources. A second CPU fence wait
// here needlessly stalls engine render submission behind the ray pass.
// Keep WaitPrevious at allocator/upload reuse and resource destruction.
RtParameters params=lastParameters;params.pathSettings[2]=2;
ComPtr<ID3DDeviceContextState> previous;context11->SwapDeviceContextState(isolatedState.Get(),&previous);
try {context11->ClearState();Composite(depth,nullptr,light,nullptr,nullptr,target,params);context11->ClearState();}
catch(...){context11->SwapDeviceContextState(previous.Get(),nullptr);throw;}
context11->SwapDeviceContextState(previous.Get(),nullptr);return 1;
}
void Composite(ID3D11ShaderResourceView* depth,ID3D11ShaderResourceView* normal,ID3D11ShaderResourceView* light,ID3D11ShaderResourceView* material,ID3D11ShaderResourceView* albedo,ID3D11RenderTargetView* target,const RtParameters& params) {
context11->UpdateSubresource(constants11.Get(),0,nullptr,¶ms,0,0);ID3D11Buffer* cb=constants11.Get();
// The HDR source is also the render target: make an SRV copy before binding.
ComPtr<ID3D11Resource> lightResource; light->GetResource(&lightResource);
ComPtr<ID3D11Texture2D> lightTexture; Check(lightResource.As(&lightTexture), "HDR texture");
D3D11_TEXTURE2D_DESC hdr{}; lightTexture->GetDesc(&hdr); hdr.BindFlags = D3D11_BIND_SHADER_RESOURCE; hdr.MiscFlags = 0;
if (!hdrCopy || hdrWidth != hdr.Width || hdrHeight != hdr.Height || hdrFormat != hdr.Format) {
hdrCopy.Reset(); hdrSrv.Reset(); Check(device11->CreateTexture2D(&hdr, nullptr, &hdrCopy), "HDR copy texture");
Check(device11->CreateShaderResourceView(hdrCopy.Get(), nullptr, &hdrSrv), "HDR copy SRV"); hdrWidth = hdr.Width; hdrHeight = hdr.Height; hdrFormat = hdr.Format;
}
context11->CopyResource(hdrCopy.Get(), lightTexture.Get());
ID3D11ShaderResourceView* views[] = {depth, normal, hdrSrv.Get(), material, positions.srv.Get(), normals.srv.Get(), result.srv.Get(),reflection.srv.Get(),indirect.srv.Get(),albedo,glassReflection.srv.Get(),glassData.srv.Get(),glassRefraction.srv.Get(),glassSharp.srv.Get(),glassGuide.srv.Get(),glassFactor.srv.Get()};
context11->PSSetShaderResources(0, 16, views); context11->PSSetConstantBuffers(0, 1, &cb);
context11->VSSetShader(fullscreen.Get(), nullptr, 0); context11->PSSetShader(composite.Get(), nullptr, 0);
context11->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
D3D11_VIEWPORT viewport{0,0,(float)params.sizes[0],(float)params.sizes[1],0,1}; context11->RSSetViewports(1, &viewport);
context11->RSSetState(rasterizer.Get());
context11->OMSetRenderTargets(1, &target, nullptr); context11->Draw(3, 0); context11->ClearState();
}
private:
ComPtr<ID3D11Texture2D> hdrCopy; ComPtr<ID3D11ShaderResourceView> hdrSrv;
UINT hdrWidth = 0, hdrHeight = 0; DXGI_FORMAT hdrFormat = DXGI_FORMAT_UNKNOWN;
};
RT_API int RtCreate(void* device11, void** output) {
if (!output) return E_INVALIDARG;
auto c = new Context(); *output = c;
try { c->Initialize(device11); return 0; } catch (const Failure& e) { c->Fail(e); return e.code; } catch (...) { c->Fail(Failure(E_FAIL,"Native initialization exception")); return E_FAIL; }
}
RT_API int RtEnvironment(void* context,void* cubeSrv) {
if(!context)return E_INVALIDARG;auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
auto source=(ID3D11ShaderResourceView*)cubeSrv;
if(source){D3D11_SHADER_RESOURCE_VIEW_DESC desc{};source->GetDesc(&desc);if(desc.ViewDimension!=D3D11_SRV_DIMENSION_TEXTURECUBE)return E_INVALIDARG;}
c->environmentSource=source;return 0;
}
RT_API int RtFinishTransparency(void* context,void* depth,void* light,void* target) {
if(!context || !depth || !light || !target)return E_INVALIDARG;auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
try{return c->FinishTransparency((ID3D11ShaderResourceView*)depth,(ID3D11ShaderResourceView*)light,(ID3D11RenderTargetView*)target);}
catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtGlassMaterials(void* context,const RtGlassMaterial* materials,uint32_t count) {
if(!context || count>1024 || (count && !materials)) return E_INVALIDARG;
auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
for(uint32_t i=0;i<count;i++) {
const float* v=(const float*)&materials[i];
for(int j=0;j<8;j++) if(!std::isfinite(v[j])) return E_INVALIDARG;
if(materials[i].optics[0]<1 || materials[i].optics[0]>2.5f || materials[i].optics[1]<=0 || materials[i].optics[1]>.5f) return E_INVALIDARG;
for(int j=0;j<4;j++) if(v[j]<0 || v[j]>1) return E_INVALIDARG;
}
if(c->glassMaterials.size()==count && (!count || memcmp(c->glassMaterials.data(),materials,count*sizeof(RtGlassMaterial))==0)) return 0;
try {
c->WaitPrevious(); c->glassMaterials.clear();
if(count) { c->glassMaterials.assign(materials,materials+count);c->Upload(c->glassBuffer.Get(),materials,count*sizeof(RtGlassMaterial)); }
c->historyValid=false; return 0;
} catch(const Failure& e) { c->Fail(e);return e.code; } catch(...) { return E_FAIL; }
}
RT_API int RtLights(void* context,const RtLight* lights,uint32_t count) {
if(!context || count>64 || (count && !lights)) return E_INVALIDARG;
auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
for(uint32_t i=0;i<count;i++) {
for(int j=0;j<16;j++) if(!std::isfinite(((const float*)&lights[i])[j])) return E_INVALIDARG;
if(lights[i].positionRange[3]<=0 || lights[i].colorIntensity[3]<0 || lights[i].directionCone[3]<-1 || lights[i].directionCone[3]>1) return E_INVALIDARG;
}
if(c->lights.size()==count && (!count || memcmp(c->lights.data(),lights,count*sizeof(RtLight))==0)) return 0;
try { c->WaitPrevious();c->lights.clear();if(count){c->lights.assign(lights,lights+count);c->Upload(c->lightBuffer.Get(),lights,count*sizeof(RtLight));}return 0; }
catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtMesh(void* context, uint32_t id, const float* xyz, uint32_t vertices, const uint32_t* indices, uint32_t indexCount, const uint32_t* materials) {
if (!context) return E_INVALIDARG; auto c = (Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
if (c->meshes.count(id)) return 0;
if (!c->ready || !xyz || !indices || !vertices || vertices > 1000000 || !indexCount || indexCount > 6000000 || indexCount%3 || c->meshes.size() >= 4096) return E_INVALIDARG;
for (uint32_t i=0; i<indexCount; ++i) if(indices[i]>=vertices) return E_INVALIDARG;
for(size_t i=0;i<size_t(vertices)*8;i++) if(!std::isfinite(xyz[i])) return E_INVALIDARG;
if(c->vertexData.size()+vertices>8000000 || c->triangleData.size()+indexCount/3>8000000) return E_OUTOFMEMORY;
for(uint32_t i=0;materials && i<indexCount/3;i++) {
if((materials[i]&0xc0000000u)==0xc0000000u) return E_INVALIDARG;
if((materials[i]&0x40000000u) && ((materials[i]>>20)&1023)>=c->glassMaterials.size()) return E_INVALIDARG;
if(materials[i]&0x80000000u) for(int j=0;j<3;j++) {
auto v=xyz+indices[i*3+j]*8;
if(v[5]<0 || v[5]>1023 || v[6]<0 || v[6]>1023 || v[7]<=0) return E_INVALIDARG;
}
}
try {
Mesh mesh; mesh.vertices.assign(xyz, xyz + size_t(vertices)*8); mesh.indices.assign(indices, indices+indexCount); mesh.triangles = indexCount/3;
mesh.triangleOffset=(uint32_t)c->triangleData.size(); uint32_t vertexOffset=(uint32_t)c->vertexData.size();
mesh.vertexOffset=vertexOffset;mesh.vertexCount=vertices;
auto data=(const Vertex*)xyz; c->vertexData.insert(c->vertexData.end(),data,data+vertices);
for(uint32_t i=0;i<indexCount/3;i++) c->triangleData.push_back({{indices[i*3]+vertexOffset,indices[i*3+1]+vertexOffset,indices[i*3+2]+vertexOffset},materials?materials[i]:0});
c->geometryDirty=true; c->meshes.emplace(id, std::move(mesh)); return 0;
}
catch (...) { c->Fail(Failure(E_OUTOFMEMORY,"Model staging allocation")); return E_OUTOFMEMORY; }
}
RT_API int RtMaterial(void* context,uint32_t id,const uint8_t* dds,uint32_t bytes,uint32_t linear) {
if(!context || !id || id>=1024) return E_INVALIDARG; auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
if(c->materials.count(id)) return 0;
try {
Material material;
if(!ParseDds(dds,bytes,material,linear!=0)) {
Material fallback;
// A missing extension map has no emission or colorization. The
// gray color-texture fallback would otherwise invent glowing faces.
if(linear) {fallback.format=DXGI_FORMAT_R8G8B8A8_UNORM;fallback.data={0,0,0,0};}
c->materials.emplace(id,std::move(fallback));return 1;
}
c->materials.emplace(id,std::move(material));return 0;
} catch(...) {return E_OUTOFMEMORY;}
}
RT_API int RtSurfaceMaterials(void* context,const RtSurfaceMaterial* materials,uint32_t count) {
if(!context || !materials || !count || count>1024)return E_INVALIDARG;
auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
for(uint32_t i=0;i<count;i++) {
if(materials[i].texture>=1024 || (materials[i].flags&~15u))return E_INVALIDARG;
for(float v:materials[i].colorEmission)if(!std::isfinite(v)||v<0||v>32)return E_INVALIDARG;
}
if(memcmp(c->surfaces.data(),materials,count*sizeof(RtSurfaceMaterial))==0)return 0;
try {c->WaitPrevious();memcpy(c->surfaces.data(),materials,count*sizeof(RtSurfaceMaterial));
c->Upload(c->surfaceBuffer.Get(),c->surfaces.data(),c->surfaces.size()*sizeof(RtSurfaceMaterial));return 0;}
catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtDynamicMaterial(void* context,uint32_t id,void* textureSrv) {
if(!context || id<992 || id>=1024)return E_INVALIDARG;
auto c=(Context*)context;std::lock_guard<std::mutex> guard(c->mutex);
try {
c->WaitPrevious();auto& d=c->dynamicTextures[id];
if(!textureSrv){d.source.Reset();return 0;}
auto source=(ID3D11ShaderResourceView*)textureSrv;D3D11_SHADER_RESOURCE_VIEW_DESC srv{};source->GetDesc(&srv);
if(srv.ViewDimension!=D3D11_SRV_DIMENSION_TEXTURE2D || srv.Texture2D.MostDetailedMip!=0)return 1;
ComPtr<ID3D11Resource> resource;source->GetResource(&resource);ComPtr<ID3D11Texture2D> texture;
if(FAILED(resource.As(&texture)))return 1;
D3D11_TEXTURE2D_DESC desc{};texture->GetDesc(&desc);
if(!desc.Width || !desc.Height || desc.Width>2048 || desc.Height>2048 || desc.ArraySize!=1 || desc.SampleDesc.Count!=1)return 1;
if(desc.Width!=d.width || desc.Height!=d.height) {
uint64_t pixels=c->dynamicPixels-uint64_t(d.width)*d.height+uint64_t(desc.Width)*desc.Height;
if(pixels>16u*1024*1024)return 1;
auto shared=c->Texture(DXGI_FORMAT_R16G16B16A16_FLOAT,desc.Width,desc.Height);
d.shared=std::move(shared);d.width=desc.Width;d.height=desc.Height;c->dynamicPixels=pixels;
}
d.source=source;return 0;
}catch(const Failure& e){c->Fail(e);return e.code;}catch(...){return E_FAIL;}
}
RT_API int RtRetainMeshes(void* context,const uint32_t* ids,uint32_t count) {
if(!context) return E_INVALIDARG; auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
try { c->Retain(ids,count); return 0; }
catch(const Failure& e) { c->Fail(e); return e.code; }
catch(...) { c->Fail(Failure(E_OUTOFMEMORY,"Scene retirement allocation")); return E_OUTOFMEMORY; }
}
RT_API int RtFrame(void* context, void* depth, void* normal, void* light, void* material, void* albedo, void* target, const RtInstance* instances, uint32_t count, const RtParameters* parameters) {
if (!context || !parameters) return E_INVALIDARG; auto c = (Context*)context; std::lock_guard<std::mutex> guard(c->mutex);
auto start = std::chrono::steady_clock::now(); int result = 0;
try { result = c->Frame((ID3D11ShaderResourceView*)depth,(ID3D11ShaderResourceView*)normal,(ID3D11ShaderResourceView*)light,(ID3D11ShaderResourceView*)material,(ID3D11ShaderResourceView*)albedo,(ID3D11RenderTargetView*)target,instances,count,*parameters); }
catch (const Failure& e) { c->Fail(e); result = e.code; } catch (...) { c->Fail(Failure(E_FAIL,"Native frame exception")); result = E_FAIL; }
c->status.cpuMilliseconds = std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-start).count(); return result;
}
RT_API void RtGetStatus(void* context, RtStatus* status) { if(context && status) { auto c=(Context*)context; std::lock_guard<std::mutex> guard(c->mutex); *status=c->status; } }
RT_API void RtDestroy(void* context) { delete (Context*)context; }