#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,&copyScreen),"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,&copyEnvironment),"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(), &params, 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, &params, 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,&params,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; }
