prepare creation of Top level aceleration structure for raytracing

DX12BLAS.cpp

@@ -0,0 +1,94 @@
+#include "DX12BLAS.h"
+
+#include "DX12Buffer.h"
+#include "DX12CommandQueue.h"
+
+Framework::DX12BLAS::DX12BLAS(
+    ID3D12Device5* zDevice, DX12DirectCommandQueue* zDirectQueue)
+    : ReferenceCounter(),
+      scratchBuffer(0),
+      resultBuffer(0),
+      zDevice(zDevice),
+      zDirectQueue(zDirectQueue),
+      geometryDesc(new D3D12_RAYTRACING_GEOMETRY_DESC())
+{}
+
+Framework::DX12BLAS::~DX12BLAS()
+{
+    if (scratchBuffer)
+    {
+        scratchBuffer->release();
+    }
+    if (resultBuffer)
+    {
+        resultBuffer->release();
+    }
+    delete geometryDesc;
+}
+
+void Framework::DX12BLAS::build(
+    DX12Buffer* vertexBuffer, DX12Buffer* indexBuffer)
+{
+    memset(geometryDesc, 0, sizeof(D3D12_RAYTRACING_GEOMETRY_DESC));
+    geometryDesc->Type = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
+    geometryDesc->Flags = D3D12_RAYTRACING_GEOMETRY_FLAG_NONE;
+    geometryDesc->Triangles.VertexBuffer.StartAddress
+        = vertexBuffer->zBuffer()->GetGPUVirtualAddress();
+    geometryDesc->Triangles.VertexBuffer.StrideInBytes
+        = vertexBuffer->getElementLength();
+    geometryDesc->Triangles.VertexCount
+        = (unsigned)vertexBuffer->getElementCount();
+    geometryDesc->Triangles.VertexFormat = DXGI_FORMAT_R32G32B32_FLOAT;
+    geometryDesc->Triangles.IndexBuffer
+        = indexBuffer->zBuffer()->GetGPUVirtualAddress();
+    geometryDesc->Triangles.IndexCount
+        = (unsigned)indexBuffer->getElementCount();
+    geometryDesc->Triangles.IndexFormat = DXGI_FORMAT_R32_UINT;
+
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS prebuildDesc;
+    prebuildDesc.Type
+        = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL;
+    prebuildDesc.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
+    prebuildDesc.NumDescs = 1;
+    prebuildDesc.pGeometryDescs = geometryDesc;
+    prebuildDesc.Flags
+        = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE;
+
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO info = {};
+    zDevice->GetRaytracingAccelerationStructurePrebuildInfo(
+        &prebuildDesc, &info);
+
+    scratchBuffer->setLength((int)info.ScratchDataSizeInBytes);
+    scratchBuffer->createBufferWithoutData(D3D12_RESOURCE_STATE_COMMON);
+    resultBuffer->setLength((int)info.ResultDataMaxSizeInBytes);
+    resultBuffer->createBufferWithoutData(
+        D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE);
+
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC buildDesc;
+    buildDesc.Inputs.Type
+        = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL;
+    buildDesc.Inputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
+    buildDesc.Inputs.NumDescs = 1;
+    buildDesc.Inputs.pGeometryDescs = geometryDesc;
+    buildDesc.DestAccelerationStructureData
+        = {resultBuffer->zBuffer()->GetGPUVirtualAddress()};
+    buildDesc.ScratchAccelerationStructureData
+        = {scratchBuffer->zBuffer()->GetGPUVirtualAddress()};
+    buildDesc.SourceAccelerationStructureData = 0;
+    buildDesc.Inputs.Flags
+        = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE;
+
+    // Build the AS
+    zDirectQueue->getCommandList()->BuildRaytracingAccelerationStructure(
+        &buildDesc, 0, nullptr);
+}
+
+Framework::DX12Buffer* Framework::DX12BLAS::zScratchBuffer() const
+{
+    return scratchBuffer;
+}
+
+Framework::DX12Buffer* Framework::DX12BLAS::zResultBuffer() const
+{
+    return resultBuffer;
+}

DX12BLAS.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "ReferenceCounter.h"
+
+struct ID3D12Device5;
+struct D3D12_RAYTRACING_GEOMETRY_DESC;
+
+namespace Framework
+{
+    class DX12Buffer;
+    class DX12DirectCommandQueue;
+
+    class DX12BLAS : public ReferenceCounter
+    {
+    private:
+        DX12Buffer* scratchBuffer;
+        DX12Buffer* resultBuffer;
+
+        ID3D12Device5* zDevice;
+        DX12DirectCommandQueue* zDirectQueue;
+        D3D12_RAYTRACING_GEOMETRY_DESC* geometryDesc;
+
+    public:
+        DX12BLAS(ID3D12Device5* zDevice, DX12DirectCommandQueue* zDirectQueue);
+        ~DX12BLAS();
+        void build(DX12Buffer* vertexBuffer, DX12Buffer* indexBuffer);
+        DX12Buffer* zScratchBuffer() const;
+        DX12Buffer* zResultBuffer() const;
+    };
+} // namespace Framework

DX12BLASModel.cpp

@@ -2,13 +2,16 @@
 
 #include "Model3D.h"
 
-Framework::DX12BLASModel::DX12BLASModel(
-    Model3DData* zModelData, ID3D12Device5* zDevice)
+Framework::DX12BLASModel::DX12BLASModel(Model3DData* zModelData,
+    ID3D12Device5* zDevice,
+    DX12DirectCommandQueue* zDirectQueue)
     : ReferenceCounter(),
       zModelData(zModelData),
       zDevice(zDevice),
+      zDirectQueue(zDirectQueue),
       vertexBuffers(0),
-      indexBuffers(0)
+      indexBuffers(0),
+      blasList(0)
 {}
 
 Framework::DX12BLASModel::~DX12BLASModel()
@@ -21,6 +24,10 @@ Framework::DX12BLASModel::~DX12BLASModel()
     {
         indexBuffers->release();
     }
+    if (blasList)
+    {
+        blasList->release();
+    }
 }
 
 void Framework::DX12BLASModel::calculateBuffers()
@@ -106,8 +113,14 @@ void Framework::DX12BLASModel::calculateBuffers()
     {
         indexBuffers = new RCArray<DX12Buffer>();
     }
+    if (!blasList)
+    {
+        blasList = new RCArray<DX12BLAS>();
+    }
     vertexBuffers->clear();
     indexBuffers->clear();
+    blasList->clear();
+    boneIds.clear();
     for (int i = 0; i <= maxBoneId; i++)
     {
         if (boneVertexCount[i] > 0 && boneIndexCount[i] > 0)
@@ -124,6 +137,11 @@ void Framework::DX12BLASModel::calculateBuffers()
             indexBuffer->setLength(boneIndexCount[i] * sizeof(int));
             indexBuffer->copyToGPU();
             indexBuffers->add(indexBuffer);
+
+            DX12BLAS* blas = new DX12BLAS(zDevice, zDirectQueue);
+            blas->build(vertexBuffer, indexBuffer);
+            blasList->add(blas);
+            boneIds.add(i);
         }
         delete[] boneIndexMapping[i];
         delete[] boneVertexBuffers[i];
@@ -141,14 +159,13 @@ int Framework::DX12BLASModel::getBufferCount() const
     return vertexBuffers ? vertexBuffers->getEntryCount() : 0;
 }
 
-const Framework::RCArray<Framework::DX12Buffer>*
-Framework::DX12BLASModel::zVertexBuffers() const
+const Framework::RCArray<Framework::DX12BLAS>*
+Framework::DX12BLASModel::zBLAS() const
 {
-    return vertexBuffers;
+    return blasList;
 }
 
-const Framework::RCArray<Framework::DX12Buffer>*
-Framework::DX12BLASModel::zIndexBuffers() const
+const Framework::Array<int>* Framework::DX12BLASModel::zBoneIds() const
 {
-    return indexBuffers;
-}
+    return &boneIds;
+}

DX12BLASModel.h

@@ -1,11 +1,13 @@
 #pragma once
 
 #include "Array.h"
+#include "DX12BLAS.h"
 #include "DX12Buffer.h"
 
 namespace Framework
 {
     class Model3DData;
+    class DX12DirectCommandQueue;
 
     class DX12BLASModel : public ReferenceCounter
     {
@@ -14,15 +16,20 @@ namespace Framework
         ID3D12Device5* zDevice;
         RCArray<DX12Buffer>* vertexBuffers;
         RCArray<DX12Buffer>* indexBuffers;
+        DX12DirectCommandQueue* zDirectQueue;
+        RCArray<DX12BLAS>* blasList;
+        Array<int> boneIds;
 
     public:
-        DX12BLASModel(Model3DData* zModelData, ID3D12Device5* zDevice);
+        DX12BLASModel(Model3DData* zModelData,
+            ID3D12Device5* zDevice,
+            DX12DirectCommandQueue* zDirectQueue);
         ~DX12BLASModel();
 
         void calculateBuffers();
         int getBufferCount() const;
-        const RCArray<DX12Buffer>* zVertexBuffers() const;
-        const RCArray<DX12Buffer>* zIndexBuffers() const;
+        const RCArray<DX12BLAS>* zBLAS() const;
+        const Array<int>* zBoneIds() const;
     };
 
 } // namespace Framework

DX12GraphicsApi.cpp

@@ -38,7 +38,6 @@ DirectX12::DirectX12()
       swapChain(0),
       rtvHeap(0),
       dsvHeap(0),
-      shaderBufferHeap(0),
       depthBuffer(0),
       backBufferIndex(0),
       tearing(0),
@@ -47,15 +46,10 @@ DirectX12::DirectX12()
       vertexBufferView(0),
       indexBufferView(0),
       signature(0),
-      pipeline(0),
       texturModel(0),
       uiTexture(0),
       texturRegister(new TextureList()),
-      vertexShader(0),
-      pixelShader(0),
       blasModels(0),
-      blasScratchBuffer(0),
-      blasResultBuffer(0),
       lastModelId(-1)
 {
     for (int i = 0; i < 2; i++)
@@ -72,14 +66,6 @@ DirectX12::~DirectX12()
         }
         delete[] blasModels;
     }
-    if (blasScratchBuffer)
-    {
-        blasScratchBuffer->release();
-    }
-    if (blasResultBuffer)
-    {
-        blasResultBuffer->release();
-    }
     if (directCommandQueue)
     {
         directCommandQueue->flush();
@@ -97,13 +83,9 @@ DirectX12::~DirectX12()
     }
     if (depthBuffer) depthBuffer->Release();
     if (dsvHeap) dsvHeap->Release();
-    if (shaderBufferHeap) shaderBufferHeap->Release();
-    if (vertexShader) vertexShader->release();
-    if (pixelShader) pixelShader->release();
     texturRegister->release();
     if (uiTexture) uiTexture->release();
     if (texturModel) texturModel->release();
-    if (pipeline) pipeline->Release();
     if (signature) signature->Release();
     delete indexBufferView;
     delete vertexBufferView;
@@ -123,6 +105,10 @@ DirectX12::~DirectX12()
         getDLLRegister()->releaseDLL("d3d12.dll");
     }
     if (debug) debug->Release();
+    for (const D3D12_RAYTRACING_INSTANCE_DESC* desc : instanceDescs)
+    {
+        delete desc;
+    }
 }
 
 void DirectX12::updateBottomLevelAccelerationStructure()
@@ -145,85 +131,10 @@ void DirectX12::updateBottomLevelAccelerationStructure()
             blasModels[id]->calculateBuffers();
             bufferCount += blasModels[id]->getBufferCount();
         }
-        D3D12_RAYTRACING_GEOMETRY_DESC* geometryDescs
-            = new D3D12_RAYTRACING_GEOMETRY_DESC[bufferCount];
-        memset(geometryDescs,
-            0,
-            sizeof(D3D12_RAYTRACING_GEOMETRY_DESC) * bufferCount);
-        int bufferIndex = 0;
-        for (const Model3DData* model : *modelList->zModels())
-        {
-            int id = model->getId();
-            for (int i = 0; i < blasModels[id]->getBufferCount()
-                            && bufferIndex < bufferCount;
-                i++)
-            {
-                DX12Buffer* vertexBuffer
-                    = blasModels[id]->zVertexBuffers()->z(i);
-                DX12Buffer* indexBuffer = blasModels[id]->zIndexBuffers()->z(i);
-                geometryDescs[bufferIndex].Type
-                    = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
-                geometryDescs[bufferIndex].Flags
-                    = D3D12_RAYTRACING_GEOMETRY_FLAG_NONE;
-                geometryDescs[bufferIndex].Triangles.VertexBuffer.StartAddress
-                    = vertexBuffer->zBuffer()->GetGPUVirtualAddress();
-                geometryDescs[bufferIndex].Triangles.VertexBuffer.StrideInBytes
-                    = vertexBuffer->getElementLength();
-                geometryDescs[bufferIndex].Triangles.VertexCount
-                    = (unsigned)vertexBuffer->getElementCount();
-                geometryDescs[bufferIndex].Triangles.VertexFormat
-                    = DXGI_FORMAT_R32G32B32_FLOAT;
-                geometryDescs[bufferIndex].Triangles.IndexBuffer
-                    = indexBuffer->zBuffer()->GetGPUVirtualAddress();
-                geometryDescs[bufferIndex].Triangles.IndexCount
-                    = (unsigned)indexBuffer->getElementCount();
-                geometryDescs[bufferIndex].Triangles.IndexFormat
-                    = DXGI_FORMAT_R32_UINT;
-                bufferIndex++;
-            }
-        }
-        D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS prebuildDesc;
-        prebuildDesc.Type
-            = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL;
-        prebuildDesc.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
-        prebuildDesc.NumDescs = bufferCount;
-        prebuildDesc.pGeometryDescs = geometryDescs;
-        prebuildDesc.Flags
-            = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE;
-
-        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO info = {};
-        device->GetRaytracingAccelerationStructurePrebuildInfo(
-            &prebuildDesc, &info);
-
-        blasScratchBuffer->setLength((int)info.ScratchDataSizeInBytes);
-        blasScratchBuffer->createBufferWithoutData(D3D12_RESOURCE_STATE_COMMON);
-        blasResultBuffer->setLength((int)info.ResultDataMaxSizeInBytes);
-        blasResultBuffer->createBufferWithoutData(
-            D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE);
-
-        D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC buildDesc;
-        buildDesc.Inputs.Type
-            = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL;
-        buildDesc.Inputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
-        buildDesc.Inputs.NumDescs = bufferCount;
-        buildDesc.Inputs.pGeometryDescs = geometryDescs;
-        buildDesc.DestAccelerationStructureData
-            = {blasResultBuffer->zBuffer()->GetGPUVirtualAddress()};
-        buildDesc.ScratchAccelerationStructureData
-            = {blasScratchBuffer->zBuffer()->GetGPUVirtualAddress()};
-        buildDesc.SourceAccelerationStructureData = 0;
-        buildDesc.Inputs.Flags
-            = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE;
-
-        // Build the AS
-        directCommandQueue->getCommandList()
-            ->BuildRaytracingAccelerationStructure(&buildDesc, 0, nullptr);
         directCommandQueue
             ->execute(); // TODO: check if this is realy necessary
                          // here, because maybe the command list is
                          // executed in the render function anyway
-
-        delete[] geometryDescs;
     }
 }
 
@@ -467,11 +378,6 @@ void DirectX12::initialize(
     copyCommandQueue = new DX12CopyCommandQueue(device);
     computeCommandQueue = new DX12ComputeCommandQueue(device);
 
-    blasScratchBuffer
-        = new DX12Buffer(1, device, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
-    blasResultBuffer
-        = new DX12Buffer(1, device, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
-
     IDXGIFactory5* fac5 = 0;
     factory->QueryInterface(__uuidof(IDXGIFactory5), (void**)&fac5);
     if (fac5)
@@ -664,64 +570,6 @@ void DirectX12::initialize(
     device->CreateDepthStencilView(
         depthBuffer, &dsv, dsvHeap->GetCPUDescriptorHandleForHeapStart());
 
-    D3D12_DESCRIPTOR_HEAP_DESC sbheapDesc = {};
-    sbheapDesc.NumDescriptors = 6;
-    sbheapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
-    sbheapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
-    res = device->CreateDescriptorHeap(
-        &sbheapDesc, __uuidof(ID3D12DescriptorHeap), (void**)&shaderBufferHeap);
-    if (FAILED(res))
-    {
-        factory->Release();
-        Logging::error() << "ERROR: CreateDescriptorHeap returned " << res
-                         << "\n";
-        WMessageBox(fenster->getWindowHandle(),
-            new Text("Fehler"),
-            new Text("CreateDescriptorHeap ist Fehlgeschlagen."),
-            MB_ICONERROR);
-        return;
-    }
-
-    vertexShader
-        = new DX12VertexShader(device, copyCommandQueue, directCommandQueue);
-    vertexShader->setCompiledByteArray(
-        (unsigned char*)DX12VertexShaderBytes, sizeof(DX12VertexShaderBytes));
-    vertexShader->createConstBuffer(sizeof(Mat4<float>) * 2, 0);
-    vertexShader->createConstBuffer(sizeof(Mat4<float>) * 128, 1);
-
-    pixelShader
-        = new DX12PixelShader(device, copyCommandQueue, directCommandQueue);
-    pixelShader->setCompiledByteArray(
-        (unsigned char*)DX12PixelShaderBytes, sizeof(DX12PixelShaderBytes));
-    pixelShader->createConstBuffer(sizeof(float) * 4, 2);
-    pixelShader->createConstBuffer(sizeof(float) * 3, 3);
-    pixelShader->createConstBuffer(sizeof(int) * 2, 4);
-
-    D3D12_INPUT_ELEMENT_DESC inputLayout[] = {
-        {"POSITION",
-         0, DXGI_FORMAT_R32G32B32_FLOAT,
-         0, D3D12_APPEND_ALIGNED_ELEMENT,
-         D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
-        {"TEXCOORD",
-         0, DXGI_FORMAT_R32G32_FLOAT,
-         0, D3D12_APPEND_ALIGNED_ELEMENT,
-         D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
-        {"NORMAL",
-         0, DXGI_FORMAT_R32G32B32_FLOAT,
-         0, D3D12_APPEND_ALIGNED_ELEMENT,
-         D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
-        {"KNOCHEN_ID",
-         0, DXGI_FORMAT_R32_UINT,
-         0, D3D12_APPEND_ALIGNED_ELEMENT,
-         D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0},
-        {"VERTEX_ID",
-         0, DXGI_FORMAT_R32_UINT,
-         0, D3D12_APPEND_ALIGNED_ELEMENT,
-         D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}
-    };
-
-    vertexShader->createInputLayout(inputLayout, 5);
-
     D3D12_FEATURE_DATA_ROOT_SIGNATURE featureData = {};
     featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1;
     if (FAILED(device->CheckFeatureSupport(
@@ -834,75 +682,10 @@ void DirectX12::initialize(
     rdesc.ForcedSampleCount = 0;
     rdesc.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
 
-    D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {};
-    psoDesc.InputLayout = {vertexShader->zInputLayout(),
-        (unsigned)vertexShader->getInputLayoutSize()};
-    psoDesc.pRootSignature = signature;
-    psoDesc.VS = {vertexShader->getCompiledShader(),
-        (unsigned __int64)vertexShader->getCompiledLength()};
-    psoDesc.PS = {pixelShader->getCompiledShader(),
-        (unsigned __int64)pixelShader->getCompiledLength()};
-    psoDesc.RasterizerState = rdesc;
-    psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT);
-    psoDesc.DepthStencilState.DepthEnable = FALSE;
-    psoDesc.DepthStencilState.StencilEnable = FALSE;
-    psoDesc.SampleMask = UINT_MAX;
-    psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
-    psoDesc.NumRenderTargets = 1;
-    psoDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
-    psoDesc.SampleDesc.Count = 1;
-
-    D3D12_CPU_DESCRIPTOR_HANDLE sbHeapHandle
-        = shaderBufferHeap->GetCPUDescriptorHandleForHeapStart();
-    unsigned int incr = device->GetDescriptorHandleIncrementSize(
-        D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
-    D3D12_CONSTANT_BUFFER_VIEW_DESC desc;
-    vertexShader->getViewDesc(0, desc);
-    device->CreateConstantBufferView(&desc, sbHeapHandle);
-    res = device->GetDeviceRemovedReason();
-    sbHeapHandle.ptr += incr;
-    vertexShader->getViewDesc(1, desc);
-    device->CreateConstantBufferView(&desc, sbHeapHandle);
-    sbHeapHandle.ptr += incr;
-    pixelShader->getViewDesc(2, desc);
-    device->CreateConstantBufferView(&desc, sbHeapHandle);
-    sbHeapHandle.ptr += incr;
-    pixelShader->getViewDesc(3, desc);
-    device->CreateConstantBufferView(&desc, sbHeapHandle);
-    sbHeapHandle.ptr += incr;
-    pixelShader->getViewDesc(4, desc);
-    device->CreateConstantBufferView(&desc, sbHeapHandle);
-    sbHeapHandle.ptr += incr;
-
     uiTexture->updateTextur();
 
-    D3D12_SHADER_RESOURCE_VIEW_DESC vd;
-    vd.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
-    vd.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
-    vd.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-    vd.Texture2D.MipLevels = 1;
-    vd.Texture2D.MostDetailedMip = 0;
-    vd.Texture2D.PlaneSlice = 0;
-    vd.Texture2D.ResourceMinLODClamp = 0;
-    device->CreateShaderResourceView(
-        ((DX12Texture*)uiTexture)->getResource(), &vd, sbHeapHandle);
-
     directCommandQueue->execute();
 
-    res = device->CreateGraphicsPipelineState(
-        &psoDesc, __uuidof(ID3D12PipelineState), (void**)&pipeline);
-    if (FAILED(res))
-    {
-        factory->Release();
-        Logging::error() << "ERROR: CreatePipelineState returned " << res
-                         << "\n";
-        WMessageBox(fenster->getWindowHandle(),
-            new Text("Fehler"),
-            new Text("CreatePipelineState ist Fehlgeschlagen."),
-            MB_ICONERROR);
-        return;
-    }
-
     factory->Release();
 }
 
@@ -942,8 +725,6 @@ void DirectX12::beginFrame(bool fill2D, bool fill3D, int fillColor)
         //  directCommandQueue->getCommandList()->ClearRenderTargetView(
         //      rtv, color, 0, 0);
     }
-    int lc[] = {0, 0};
-    pixelShader->fillConstBuffer((char*)lc, 4, sizeof(int) * 2);
 
     uiTexture->updateTextur();
 }
@@ -953,22 +734,55 @@ void DirectX12::renderKamera(Cam3D* zKamera)
     // TODO
     // directCommandQueue->getCommandList()->RSSetViewports(
     //     1, (D3D12_VIEWPORT*)zKamera->zViewPort());
+    Mat4<float> identity = Mat4<float>::identity();
 
-    Mat4<float> tmp = zKamera->getProjectionMatrix() * zKamera->getViewMatrix();
-
-    viewAndProj[0] = zKamera->getViewMatrix();
-    viewAndProj[1] = zKamera->getProjectionMatrix();
-    kamPos = zKamera->getWorldPosition();
-    if (vertexShader)
-        vertexShader->fillConstBuffer(
-            (char*)viewAndProj, 0, sizeof(Mat4<float>) * 2);
-    if (pixelShader)
-        pixelShader->fillConstBuffer((char*)&kamPos, 2, sizeof(float) * 3);
     World3D* w = zKamera->zWorld();
-    w->render([this](Model3D* obj) {
-        // TODO: create or update top level aceleration structure if a model was
-        // changed
-    });
+    ArrayIterator<D3D12_RAYTRACING_INSTANCE_DESC*> instanceIterator
+        = instanceDescs.begin();
+    int objectIndex = 0;
+    int instanceIndex = 0;
+    w->render(
+        [this, &instanceIterator, &objectIndex, &instanceIndex, &identity](
+            Model3D* obj) {
+            obj->calculateMatrices(identity, matrixBuffer);
+            int modelId = obj->zModelData()->getId();
+            DX12BLASModel* blasModel = blasModels[modelId];
+            ArrayIterator<int> boneIds = blasModel->zBoneIds()->begin();
+            for (const DX12BLAS* blas : *blasModel->zBLAS())
+            {
+                D3D12_RAYTRACING_INSTANCE_DESC* desc = 0;
+                if (instanceIndex < instanceDescs.getEntryCount())
+                {
+                    desc = instanceIterator.val();
+                    instanceIterator++;
+                }
+                else
+                {
+                    desc = new D3D12_RAYTRACING_INSTANCE_DESC();
+                    instanceDescs.add(desc);
+                }
+                desc->InstanceID = objectIndex;
+                desc->InstanceContributionToHitGroupIndex = objectIndex;
+                desc->Flags = D3D12_RAYTRACING_INSTANCE_FLAG_NONE;
+                desc->InstanceMask = 0xFF;
+                desc->AccelerationStructure
+                    = blas->zResultBuffer()->zBuffer()->GetGPUVirtualAddress();
+                memcpy(desc->Transform,
+                    &matrixBuffer[boneIds.val()],
+                    sizeof(float) * 12);
+                boneIds++;
+                instanceIndex++;
+            }
+            objectIndex++;
+        });
+    // TODO: add gui model to instanceDescs if the gui should be rendered in
+    // this kamera
+    while (instanceIterator)
+    {
+        instanceIterator.val()->InstanceMask = 0;
+        instanceIterator++;
+    }
+
     // TODO: call ray tracing
 }
 
@@ -979,9 +793,6 @@ void DirectX12::presentFrame()
 
     viewAndProj[0] = Mat4<float>::identity();
     viewAndProj[1] = Mat4<float>::identity();
-    if (vertexShader)
-        vertexShader->fillConstBuffer(
-            (char*)viewAndProj, 0, sizeof(Mat4<float>) * 2);
 
     D3D12_RESOURCE_BARRIER barrier;
     ZeroMemory(&barrier, sizeof(barrier));

DX12GraphicsApi.h

@@ -20,6 +20,7 @@ struct D3D12_INDEX_BUFFER_VIEW;
 struct ID3D12RootSignature;
 struct ID3D12PipelineState;
 struct ID3D12GraphicsCommandList4;
+struct D3D12_RAYTRACING_INSTANCE_DESC;
 
 namespace Framework
 {
@@ -47,7 +48,6 @@ namespace Framework
         IDXGISwapChain4* swapChain;
         ID3D12DescriptorHeap* rtvHeap;
         ID3D12DescriptorHeap* dsvHeap;
-        ID3D12DescriptorHeap* shaderBufferHeap;
         ID3D12Resource* depthBuffer;
         ID3D12Resource* backBuffer[2];
         int backBufferIndex;
@@ -57,18 +57,14 @@ namespace Framework
         D3D12_VERTEX_BUFFER_VIEW* vertexBufferView;
         D3D12_INDEX_BUFFER_VIEW* indexBufferView;
         ID3D12RootSignature* signature;
-        ID3D12PipelineState* pipeline;
         Mat4<float> matrixBuffer[MAX_KNOCHEN_ANZ];
         Mat4<float> viewAndProj[2];
         Vec3<float> kamPos;
         TextureModel* texturModel;
         Texture* uiTexture;
         TextureList* texturRegister;
-        DX12VertexShader* vertexShader;
-        DX12PixelShader* pixelShader;
         DX12BLASModel** blasModels;
-        DX12Buffer* blasScratchBuffer;
-        DX12Buffer* blasResultBuffer;
+        Array<D3D12_RAYTRACING_INSTANCE_DESC*> instanceDescs;
         int lastModelId;
 
         DLLEXPORT void updateBottomLevelAccelerationStructure();

DX12Shader.cpp

@@ -85,53 +85,4 @@ void DX12Shader::getViewDesc(int index, D3D12_CONSTANT_BUFFER_VIEW_DESC& view)
     if (!zB) return;
     view.SizeInBytes = (unsigned)zB->getElementCount() * zB->getElementLength();
     view.BufferLocation = zB->zBuffer()->GetGPUVirtualAddress();
-}
-
-DX12PixelShader::DX12PixelShader(ID3D12Device5* device,
-    DX12CopyCommandQueue* copy,
-    DX12DirectCommandQueue* direct)
-    : DX12Shader(device, copy, direct)
-{}
-
-// Constructor
-DX12VertexShader::DX12VertexShader(ID3D12Device5* device,
-    DX12CopyCommandQueue* copy,
-    DX12DirectCommandQueue* direct)
-    : DX12Shader(device, copy, direct)
-{
-    inputLayout = 0;
-    inputLayoutSize = 0;
-}
-
-// Destructor
-DX12VertexShader::~DX12VertexShader()
-{
-    delete[] inputLayout;
-}
-
-// Creates an InputLayout for the shader
-// Must only be called after compile
-//  zD3d11Device: The device used to create the layout
-//  descArray: An array with initialization data
-//  anz: The number of elements in the array
-bool DX12VertexShader::createInputLayout(
-    D3D12_INPUT_ELEMENT_DESC* descArray, int anz)
-{
-    delete[] inputLayout;
-    inputLayout = new D3D12_INPUT_ELEMENT_DESC[anz];
-    memcpy(inputLayout, descArray, anz * sizeof(D3D12_INPUT_ELEMENT_DESC));
-    inputLayoutSize = anz;
-    return 1;
-}
-
-// Returns the number of input parameters of the shader
-int DX12VertexShader::getInputLayoutSize() const
-{
-    return inputLayoutSize;
-}
-
-// Returns a list of formats for each input value
-D3D12_INPUT_ELEMENT_DESC* DX12VertexShader::zInputLayout() const
-{
-    return inputLayout;
 }

DX12Shader.h

@@ -54,37 +54,4 @@ namespace Framework
         virtual void getViewDesc(
             int index, D3D12_CONSTANT_BUFFER_VIEW_DESC& view);
     };
-
-    class DX12PixelShader : public DX12Shader
-    {
-    public:
-        DX12PixelShader(ID3D12Device5* device,
-            DX12CopyCommandQueue* copy,
-            DX12DirectCommandQueue* direct);
-    };
-
-    class DX12VertexShader : public DX12Shader
-    {
-    private:
-        D3D12_INPUT_ELEMENT_DESC* inputLayout;
-        int inputLayoutSize;
-
-    public:
-        //! Constructor
-        DX12VertexShader(ID3D12Device5* device,
-            DX12CopyCommandQueue* copy,
-            DX12DirectCommandQueue* direct);
-        //! Destructor
-        ~DX12VertexShader();
-        //! Creates an input layout for the shader.
-        //! May only be called after compile.
-        //!  zD3d11Device: The device with which the layout should be created
-        //! \param descArray An array with initialization data
-        //! \param anz The number of elements in the array
-        bool createInputLayout(D3D12_INPUT_ELEMENT_DESC* descArray, int anz);
-        //! Returns the number of input parameters of the shader
-        int getInputLayoutSize() const;
-        //! Returns a list of formats for each input value
-        D3D12_INPUT_ELEMENT_DESC* zInputLayout() const;
-    };
 } // namespace Framework

Framework.vcxproj

@@ -208,6 +208,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClInclude Include="DX11Buffer.h" />
     <ClInclude Include="DX11GraphicsApi.h" />
     <ClInclude Include="DX11Shader.h" />
+    <ClInclude Include="DX12BLAS.h" />
     <ClInclude Include="DX12BLASModel.h" />
     <ClInclude Include="DX12GraphicsApi.h" />
     <ClInclude Include="DX9GraphicsApi.h" />
@@ -321,6 +322,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClCompile Include="AsynchronCall.cpp" />
     <ClCompile Include="DX11Buffer.cpp" />
     <ClCompile Include="DX11Shader.cpp" />
+    <ClCompile Include="DX12BLAS.cpp" />
     <ClCompile Include="DX12BLASModel.cpp" />
     <ClCompile Include="SelectionBox.cpp" />
     <ClCompile Include="Console.cpp" />

Framework.vcxproj.filters

@@ -415,6 +415,9 @@
     <ClInclude Include="DX11Shader.h">
       <Filter>Framework\Graphics\DX\DX11</Filter>
     </ClInclude>
+    <ClInclude Include="DX12BLAS.h">
+      <Filter>Framework\Graphics\DX\DX12</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Model3DCollection.h">
@@ -687,6 +690,9 @@
     <ClCompile Include="DX11Shader.cpp">
       <Filter>Framework\Graphics\DX\DX11</Filter>
     </ClCompile>
+    <ClCompile Include="DX12BLAS.cpp">
+      <Filter>Framework\Graphics\DX\DX12</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <FxCompile Include="DX11VertexShader.hlsl">