New GPU material instance format

Material instances now use a separate GPU buffer.
GPU instance data references Material instances by index.

data/Shaders/debugdraw/debugdraw.hlsl

@@ -15,10 +15,10 @@ VS_Output VS_DebugDraw(uint _vertexID : VertexID)
 {
     VS_Output output = (VS_Output) 0;
 
-    ByteAddressBuffer buf = getBuffer(debugDrawRootConstants3D.getBufferHandle());
+    ByteAddressBuffer buf = getBuffer(debugDrawRootConstants3D.getVertexBufferHandle());
 
     Vertex vert;
-           vert.Load(buf, debugDrawRootConstants3D.getVertexFormat(), _vertexID, debugDrawRootConstants3D.getBufferOffset());
+           vert.Load(buf, debugDrawRootConstants3D.getVertexFormat(), _vertexID, debugDrawRootConstants3D.getVertexBufferOffset());
 
     ViewConstants viewConstants;
     viewConstants.Load(getBuffer(RESERVEDSLOT_BUFSRV_VIEWCONSTANTS));

data/Shaders/debugdraw/debugdraw.hlsli

@@ -54,18 +54,18 @@ struct DebugDrawRootConstants3D
         return taper;
     }
 
-    void setBufferHandle(uint _stream0, uint _offset = 0)
+    void setVertexBufferHandle(uint _stream0, uint _offset = 0)
     {
         stream0 = packUint16low(stream0, _stream0);
         stream0Offset = _offset;
     }
 
-    uint getBufferHandle()
+    uint getVertexBufferHandle()
     {
         return unpackUint16low(stream0);
     }
 
-    uint getBufferOffset()
+    uint getVertexBufferOffset()
     {
         return stream0Offset;
     }

data/Shaders/default/default.hlsl

@@ -65,7 +65,7 @@ VS_Output VS_Forward(uint _vertexID : VertexID)
     GPUMaterialData materialData = instanceDataHeader.getGPUMaterialData(instanceDataOffset, rootConstants3D.getMatID());
 
     Vertex vert;
-           vert.Load(getBuffer(rootConstants3D.getBufferHandle()), rootConstants3D.getVertexFormat(), _vertexID, rootConstants3D.getBufferOffset());
+           vert.Load(getBuffer(rootConstants3D.getVertexBufferHandle()), rootConstants3D.getVertexFormat(), _vertexID, rootConstants3D.getVertexBufferOffset());
 
     ViewConstants viewConstants;
     viewConstants.Load(getBuffer(RESERVEDSLOT_BUFSRV_VIEWCONSTANTS));
@@ -290,7 +290,7 @@ VS_Output VS_Deferred(uint _vertexID : VertexID)
     GPUMaterialData materialData = instanceDataHeader.getGPUMaterialData(instanceDataOffset, rootConstants3D.getMatID());
 
     Vertex vert;
-           vert.Load(getBuffer(rootConstants3D.getBufferHandle()), rootConstants3D.getVertexFormat(), _vertexID, rootConstants3D.getBufferOffset());
+           vert.Load(getBuffer(rootConstants3D.getVertexBufferHandle()), rootConstants3D.getVertexFormat(), _vertexID, rootConstants3D.getVertexBufferOffset());
 
     ViewConstants viewConstants;
     viewConstants.Load(getBuffer(RESERVEDSLOT_BUFSRV_VIEWCONSTANTS));

data/Shaders/postprocess/postprocess.hlsl

@@ -4,6 +4,7 @@
 #include "system/view.hlsli"
 #include "system/depthstencil.hlsli"
 #include "system/msaa.hlsli"
+#include "system/instancedata.hlsli"
 
 #if _FXAA
 #include "FXAA.hlsli"
@@ -151,6 +152,19 @@ float4 DebugRayTracing(float4 color, float2 uv, uint2 screenSize, ViewConstants
                     color.rgb = float3(frac(primitiveIndex.xxx / 256.0f));
                 }
                 break;
+
+                case DisplayMode::RayTracing_Material:
+                {
+                    uint instanceDataOffset = query.CommittedInstanceID();
+                    GPUInstanceData instanceDataHeader = getBuffer(RESERVEDSLOT_BUFSRV_INSTANCEDATA).Load<GPUInstanceData>(instanceDataOffset);
+                    float4 instanceColor = instanceDataHeader.getInstanceColor();
+
+                    GPUMaterialData materialData = instanceDataHeader.getGPUMaterialData(instanceDataOffset, query.CommittedGeometryIndex());
+                    float4 materialColor = materialData.getAlbedoColor();                
+
+                    color.rgb = instanceColor.rgb * materialColor.rgb;
+                }
+                break;
             }
         }       
         break;

data/Shaders/system/displaymodes.hlsli

@@ -55,7 +55,8 @@ vg_enum_class(DisplayMode, uint,
     RayTracing_Barycentrics,
     RayTracing_InstanceID,
     RayTracing_GeometryIndex,
-    RayTracing_PrimitiveIndex,  
+    RayTracing_PrimitiveIndex,
+    RayTracing_Material,  
 
     PostProcess_Depth,
     PostProcess_LinearDepth,

data/Shaders/system/instancedata.hlsli

@@ -2,71 +2,27 @@
 
 #include "system/packing.hlsli"
 #include "system/table.hlsli"
-#include "system/material_consts.hlsli"
+#include "system/materialdata.hlsli"
 
-struct GPUMaterialData
-{
-    #ifdef __cplusplus
-    GPUMaterialData()
-    {
-        setAlbedoTextureHandle(RESERVEDSLOT_TEXSRV_DEFAULT_ALBEDO);
-        setNormalTextureHandle(RESERVEDSLOT_TEXSRV_DEFAULT_NORMAL);
-        setPBRTextureHandle(RESERVEDSLOT_TEXSRV_DEFAULT_PBR);
-
-        setAlbedoColor(float4(1,1,1,1));
-        setNormalStrength(1.0f);
-        setOcclusion(1.0f);
-        setRoughness(0.25f);
-        setMetalness(0.0f);
-        setTiling(float2(1.0f, 1.0f));
-    }   
-    #endif 
-
-    uint4 textures;         // .x = albedo | normal, .y = pbr | unused, .y = unused, .w = flags
-    float4 albedoColor;
-    float4 data;
-    float4 tiling;
-
-    void        setAlbedoTextureHandle  (uint _value)   { textures.x = packUint16low(textures.x, _value); }
-    uint        getAlbedoTextureHandle  ()              { return unpackUint16low(textures.x); }
-
-    void        setNormalTextureHandle  (uint _value)   { textures.x = packUint16high(textures.x, _value); }
-    uint        getNormalTextureHandle  ()              { return unpackUint16high(textures.x); }
-
-    void        setPBRTextureHandle     (uint _value)   { textures.y = packUint16low(textures.y, _value); }
-    uint        getPBRTextureHandle     ()              { return unpackUint16low(textures.y); }
-
-    void        setUVSource             (UVSource _value) { textures.w = packA8(textures.w, (uint)_value); }
-    UVSource    getUVSource             ()              { return (UVSource)unpackA8(textures.w);}
-
-    void        setAlbedoColor          (float4 _value) { albedoColor = _value; }
-    float4      getAlbedoColor          ()              { return albedoColor; }
-
-    void        setNormalStrength       (float _value)  { data.w = _value; }
-    float       getNormalStrength       ()              { return data.w; }
-
-    void        setOcclusion            (float _value)  { data.x = _value; }
-    float       getOcclusion            ()              { return data.x; }
-
-    void        setRoughness            (float _value)  { data.y = _value; }
-    float       getRoughness            ()              { return data.y; }
-
-    void        setMetalness            (float _value)  { data.z = _value; }
-    float       getMetalness            ()              { return data.z; }
-
-    void        setTiling               (float2 _value) { tiling.xy = _value; }
-    float2      getTiling               ()              { return tiling.xy; }
-};
+#define MAX_MATERIAL_PER_INSTANCE 16
 
+//--------------------------------------------------------------------------------------
+// GPUInstanceData
+// Materials use 16-bits indices and up to 16 materials per instance are supported
+//--------------------------------------------------------------------------------------
 struct GPUInstanceData
 {
-    uint4 data;
+    uint4 m_header;
+    uint  m_materials[MAX_MATERIAL_PER_INSTANCE];
 
-    void setMaterialCount           (uint _count)   { data.x = packUint16low(data.x, _count); }
-    uint getMaterialCount           ()              { return unpackUint16low(data.x); }
+    void setMaterialCount           (uint _count)   { m_header.x = packUint16low(m_header.x, _count); }
+    uint getMaterialCount           ()              { return unpackUint16low(m_header.x); }
 
-    void setInstanceColor           (float4 _color) { data.y = packRGBA8(_color); }
-    float4 getInstanceColor         ()              { return unpackRGBA8(data.y); }
+    void setInstanceColor           (float4 _color) { m_header.y = packRGBA8(_color); }
+    float4 getInstanceColor         ()              { return unpackRGBA8(m_header.y); }
+
+    void setMaterialHandle          (uint _index, uint _handle) { m_materials[_index] = _handle; }
+    uint getMaterialHandle          (uint _index)               { return _index < MAX_MATERIAL_PER_INSTANCE ? m_materials[_index] : 0; }
 
     #ifndef __cplusplus
     //--------------------------------------------------------------------------------------
@@ -75,15 +31,9 @@ struct GPUInstanceData
     //--------------------------------------------------------------------------------------
     GPUMaterialData getGPUMaterialData  (uint instanceDataOffset, uint _matID)
     {
-        uint matIndex = _matID;
-        uint matOffset;
-
-        if (matIndex < getMaterialCount())
-            matOffset = instanceDataOffset + sizeof(GPUInstanceData) + matIndex * sizeof(GPUMaterialData);
-        else
-            matOffset = 0 + sizeof(GPUInstanceData) + 0 * sizeof(GPUMaterialData);  
-
-        return getBuffer(RESERVEDSLOT_BUFSRV_INSTANCEDATA).Load<GPUMaterialData>(matOffset);
+        uint matIndex = getMaterialHandle(_matID);
+        uint matOffset = matIndex * sizeof(GPUMaterialData);
+        return getBuffer(RESERVEDSLOT_BUFSRV_MATERIALDATA).Load<GPUMaterialData>(matOffset);
     }
     #endif
 };

data/Shaders/system/materialdata.hlsli

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "system/packing.hlsli"
+#include "system/table.hlsli"
+#include "system/material_consts.hlsli"
+
+struct GPUMaterialData
+{
+    #ifdef __cplusplus
+    GPUMaterialData()
+    {
+        setAlbedoTextureHandle(RESERVEDSLOT_TEXSRV_DEFAULT_ALBEDO);
+        setNormalTextureHandle(RESERVEDSLOT_TEXSRV_DEFAULT_NORMAL);
+        setPBRTextureHandle(RESERVEDSLOT_TEXSRV_DEFAULT_PBR);
+
+        setAlbedoColor(float4(1,1,1,1));
+        setNormalStrength(1.0f);
+        setOcclusion(1.0f);
+        setRoughness(0.25f);
+        setMetalness(0.0f);
+        setTiling(float2(1.0f, 1.0f));
+
+        tiling.zw = 0; // unused
+    }   
+    #endif 
+
+    uint4 textures;         // .x = albedo | normal, .y = pbr | unused, .y = unused, .w = flags
+    float4 albedoColor;
+    float4 data;
+    float4 tiling;
+
+    void        setAlbedoTextureHandle  (uint _value)   { textures.x = packUint16low(textures.x, _value); }
+    uint        getAlbedoTextureHandle  ()              { return unpackUint16low(textures.x); }
+
+    void        setNormalTextureHandle  (uint _value)   { textures.x = packUint16high(textures.x, _value); }
+    uint        getNormalTextureHandle  ()              { return unpackUint16high(textures.x); }
+
+    void        setPBRTextureHandle     (uint _value)   { textures.y = packUint16low(textures.y, _value); }
+    uint        getPBRTextureHandle     ()              { return unpackUint16low(textures.y); }
+
+    void        setUVSource             (UVSource _value) { textures.w = packA8(textures.w, (uint)_value); }
+    UVSource    getUVSource             ()              { return (UVSource)unpackA8(textures.w);}
+
+    void        setAlbedoColor          (float4 _value) { albedoColor = _value; }
+    float4      getAlbedoColor          ()              { return albedoColor; }
+
+    void        setNormalStrength       (float _value)  { data.w = _value; }
+    float       getNormalStrength       ()              { return data.w; }
+
+    void        setOcclusion            (float _value)  { data.x = _value; }
+    float       getOcclusion            ()              { return data.x; }
+
+    void        setRoughness            (float _value)  { data.y = _value; }
+    float       getRoughness            ()              { return data.y; }
+
+    void        setMetalness            (float _value)  { data.z = _value; }
+    float       getMetalness            ()              { return data.z; }
+
+    void        setTiling               (float2 _value) { tiling.xy = _value; }
+    float2      getTiling               ()              { return tiling.xy; }
+};

data/Shaders/system/rootConstants3D.hlsli

@@ -52,21 +52,21 @@ struct RootConstants3D
         return instanceDataOffset;
     }
 
-    // buffer
+    // vertex buffer
     // stream0 address : 16;
     // stream0 offset  : 16
-    void setBufferHandle(uint _stream0, uint _offset = 0)
+    void setVertexBufferHandle(uint _stream0, uint _offset = 0)
     {
         stream0 = packUint16low(stream0, _stream0);
         stream0Offset = _offset;
     }
 
-    uint getBufferHandle()
+    uint getVertexBufferHandle()
     {
         return unpackUint16low(stream0);
     }
 
-    uint getBufferOffset()
+    uint getVertexBufferOffset()
     {
         return stream0Offset;
     }

data/Shaders/system/table.hlsli

@@ -49,6 +49,7 @@ vg_enum_class(ReservedSlot, uint,
     LastTexture             = InvalidTexture2D,
 
     // Buffer
+    MaterialDataBufSrv      = BINDLESS_BUFFER_INVALID - 5,
     InstanceDataBufSrv      = BINDLESS_BUFFER_INVALID - 4,
     SkinningMatricesBufSrv  = BINDLESS_BUFFER_INVALID - 3,
     LightsConstantBufSrv    = BINDLESS_BUFFER_INVALID - 2,
@@ -82,6 +83,7 @@ vg_enum_class(ReservedSlot, uint,
 #define RESERVEDSLOT_TEXSRV_IMGUIFONTTEX        (BINDLESS_TEXTURE_INVALID - 1)
 
 // Buffer SRV
+#define RESERVEDSLOT_BUFSRV_MATERIALDATA        (BINDLESS_BUFFER_INVALID - 5)
 #define RESERVEDSLOT_BUFSRV_INSTANCEDATA        (BINDLESS_BUFFER_INVALID - 4)
 #define RESERVEDSLOT_BUFSRV_SKINNINGMATRICES    (BINDLESS_BUFFER_INVALID - 3)
 #define RESERVEDSLOT_BUFSRV_LIGHTSCONSTANTS     (BINDLESS_BUFFER_INVALID - 2)

src/gfx/Raytracing/TLAS.hpp

@@ -65,6 +65,6 @@ namespace vg::gfx
     //--------------------------------------------------------------------------------------
     void TLAS::addInstance(const gfx::BLAS * _blas, const core::float4x4 & _world, const core::u32 _instanceID)
     {
-        super::addInstance(_blas, _world, 0/*_instanceID*/);
+        super::addInstance(_blas, _world, _instanceID);
     }
 }

src/renderer/DebugDraw/DebugDraw.cpp

@@ -500,7 +500,7 @@ namespace vg::renderer
         DebugDrawRootConstants3D debugDraw3D;
         {
             debugDraw3D.setWorldMatrix(transpose(aabbMatrixWS));
-            debugDraw3D.setBufferHandle(m_box->getVertexBuffer()->getBufferHandle(), m_box->getVertexBufferOffset());
+            debugDraw3D.setVertexBufferHandle(m_box->getVertexBuffer()->getBufferHandle(), m_box->getVertexBufferOffset());
             debugDraw3D.setVertexFormat(VertexFormat::DebugDraw);
         }
 
@@ -564,7 +564,7 @@ namespace vg::renderer
         DebugDrawRootConstants3D debugDrawRoot3D;
 
         debugDrawRoot3D.setWorldMatrix(float4x4::identity());
-        debugDrawRoot3D.setBufferHandle(m_gridVB->getBufferHandle());
+        debugDrawRoot3D.setVertexBufferHandle(m_gridVB->getBufferHandle());
         debugDrawRoot3D.setVertexFormat(VertexFormat::DebugDraw);
         debugDrawRoot3D.setColor(float4(1, 1, 1, 1));
 
@@ -587,7 +587,7 @@ namespace vg::renderer
         DebugDrawRootConstants3D debugDrawRoot3D;
 
         debugDrawRoot3D.setWorldMatrix(float4x4::identity());
-        debugDrawRoot3D.setBufferHandle(m_axisVB->getBufferHandle());
+        debugDrawRoot3D.setVertexBufferHandle(m_axisVB->getBufferHandle());
         debugDrawRoot3D.setVertexFormat(VertexFormat::DebugDraw);
         debugDrawRoot3D.setColor(float4(1, 1, 1, 1));
 
@@ -854,7 +854,7 @@ namespace vg::renderer
             // Root constants
             DebugDrawRootConstants3D debugDrawRoot3D;
             debugDrawRoot3D.setWorldMatrix(float4x4::identity());
-            debugDrawRoot3D.setBufferHandle(drawData.m_debugDrawVB->getBufferHandle(), drawData.m_linesVBOffset);
+            debugDrawRoot3D.setVertexBufferHandle(drawData.m_debugDrawVB->getBufferHandle(), drawData.m_linesVBOffset);
             debugDrawRoot3D.setVertexFormat(VertexFormat::DebugDraw);
             debugDrawRoot3D.setColor(float4(1, 1, 1, 1));
 
@@ -934,7 +934,7 @@ namespace vg::renderer
 
         // Root constants
         DebugDrawRootConstants3D debugDraw3D;
-        debugDraw3D.setBufferHandle(_geometry->getVertexBuffer()->getBufferHandle());
+        debugDraw3D.setVertexBufferHandle(_geometry->getVertexBuffer()->getBufferHandle());
         debugDraw3D.setVertexFormat(VertexFormat::DebugDraw);
 
         // Transparent

src/renderer/Instance/Mesh/MeshInstance.hpp

@@ -235,7 +235,10 @@ namespace vg::renderer
         auto * tlas = _view->getTLAS();
 
         if (const auto * blas = getInstanceBLAS())
-            tlas->addInstance(blas, getGlobalMatrix(), _index);
+        {
+            u32 rayTracingID = getGPUInstanceDataOffset();
+            tlas->addInstance(blas, getGlobalMatrix(), rayTracingID);
+        }
 
         return true;
     }
@@ -260,9 +263,9 @@ namespace vg::renderer
             root3D.setGPUInstanceDataOffset(getGPUInstanceDataOffset());
 
             if (IsSkinned())
-                root3D.setBufferHandle(m_skinnedMeshBuffer->getBufferHandle(), m_skinnedMeshBufferOffset);
+                root3D.setVertexBufferHandle(m_skinnedMeshBuffer->getBufferHandle(), m_skinnedMeshBufferOffset);
             else
-                root3D.setBufferHandle(geo->getVertexBuffer()->getBufferHandle(), geo->getVertexBufferOffset());
+                root3D.setVertexBufferHandle(geo->getVertexBuffer()->getBufferHandle(), geo->getVertexBufferOffset());
 
             u16 flags = 0;
             root3D.setFlags(flags);