Fix example 67

Author: kevyuu

67_RayQueryGeometry/app_resources/common.hlsl

@@ -5,17 +5,22 @@
 
 NBL_CONSTEXPR uint32_t WorkgroupSize = 16;
 
+enum NormalType : uint32_t
+{
+    NT_R8G8B8A8_SNORM,
+    NT_R32G32B32_SFLOAT,
+    NT_UNKNOWN
+};
+
 // we need bitfield support in NBL_HLSL_DECLARE_STRUCT it seems
 struct SGeomInfo
 {
     uint64_t vertexBufferAddress;
     uint64_t indexBufferAddress;
     uint64_t normalBufferAddress;
 
-    uint32_t objType : 29;
-    uint32_t indexType : 2; // 16 bit, 32 bit or none
-    uint32_t smoothNormals : 1;	// flat for cube, rectangle, disk
-    uint32_t padding;
+    uint32_t normalType : 2;
+    uint32_t indexType : 1; // 16 bit, 32 bit
 };
 
 struct SPushConstants
@@ -29,18 +34,4 @@ struct SPushConstants
     float32_t2 offsetNDC;
 };
 
-#ifdef __HLSL_VERSION
-enum ObjectType : uint32_t  // matches c++
-{
-    OT_CUBE = 0,
-    OT_SPHERE,
-    OT_CYLINDER,
-    OT_RECTANGLE,
-    OT_CONE,
-    OT_ICOSPHERE,
-
-    OT_COUNT
-};
-#endif
-
 #endif  // RQG_COMMON_HLSL

67_RayQueryGeometry/app_resources/render.comp.hlsl

@@ -25,41 +25,47 @@ float3 unpackNormals3x10(uint32_t v)
     return clamp(float3(pn) / 511.0, -1.0, 1.0);
 }
 
-float3 calculateSmoothNormals(int instID, int primID, SGeomInfo geom, float2 bary)
+float3 calculateNormals(int primID, SGeomInfo geom, float2 bary)
 {
     const uint indexType = geom.indexType;
-    const uint objType = geom.objType;
+    const uint normalType = geom.normalType;
 
     const uint64_t vertexBufferAddress = geom.vertexBufferAddress;
     const uint64_t indexBufferAddress = geom.indexBufferAddress;
     const uint64_t normalBufferAddress = geom.normalBufferAddress;
 
     uint32_t3 indices;
-    switch (indexType)
+    if (indexBufferAddress == 0)
     {
-        case 0: // EIT_16BIT
-            indices = uint32_t3((nbl::hlsl::bda::__ptr<uint16_t3>::create(indexBufferAddress)+primID).deref().load());
-            break;
-        case 1: // EIT_32BIT
-            indices = uint32_t3((nbl::hlsl::bda::__ptr<uint32_t3>::create(indexBufferAddress)+primID).deref().load());
-            break;
-        default:    // EIT_NONE
+        indices[0] = primID * 3;
+        indices[1] = indices[0] + 1;
+        indices[2] = indices[0] + 2;
+    }
+    else {
+        switch (indexType)
         {
-            indices[0] = primID * 3;
-            indices[1] = indices[0] + 1;
-            indices[2] = indices[0] + 2;
+            case 0: // EIT_16BIT
+                indices = uint32_t3((nbl::hlsl::bda::__ptr<uint16_t3>::create(indexBufferAddress)+primID).deref().load());
+                break;
+            case 1: // EIT_32BIT
+                indices = uint32_t3((nbl::hlsl::bda::__ptr<uint32_t3>::create(indexBufferAddress)+primID).deref().load());
+                break;
         }
     }
 
+    if (normalBufferAddress == 0 || normalType == NT_UNKNOWN)
+    {
+        float3 v0 = vk::RawBufferLoad<float3>(vertexBufferAddress + indices[0] * 12);
+        float3 v1 = vk::RawBufferLoad<float3>(vertexBufferAddress + indices[1] * 12);
+        float3 v2 = vk::RawBufferLoad<float3>(vertexBufferAddress + indices[2] * 12);
+
+        return normalize(cross(v2 - v0, v1 - v0));
+    }
+
     float3 n0, n1, n2;
-    switch (objType)
+    switch (normalType)
     {
-        case OT_CUBE:
-        case OT_SPHERE:
-        case OT_RECTANGLE:
-        case OT_CYLINDER:
-        //case OT_ARROW:
-        case OT_CONE:
+        case NT_R8G8B8A8_SNORM:
         {
             uint32_t v0 = vk::RawBufferLoad<uint32_t>(normalBufferAddress + indices[0] * 4);
             uint32_t v1 = vk::RawBufferLoad<uint32_t>(normalBufferAddress + indices[1] * 4);
@@ -70,13 +76,13 @@ float3 calculateSmoothNormals(int instID, int primID, SGeomInfo geom, float2 bar
             n2 = normalize(nbl::hlsl::spirv::unpackSnorm4x8(v2).xyz);
         }
         break;
-        case OT_ICOSPHERE:
-        default:
+        case NT_R32G32B32_SFLOAT:
         {
             n0 = normalize(vk::RawBufferLoad<float3>(normalBufferAddress + indices[0] * 12));
             n1 = normalize(vk::RawBufferLoad<float3>(normalBufferAddress + indices[1] * 12));
             n2 = normalize(vk::RawBufferLoad<float3>(normalBufferAddress + indices[2] * 12));
         }
+        break;
     }
 
     float3 barycentrics = float3(0.0, bary);
@@ -113,15 +119,16 @@ void main(uint32_t3 threadID : SV_DispatchThreadID)
 
     if (spirv::rayQueryGetIntersectionTypeKHR(query, true) == spv::RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR)
     {
-        const int instID = spirv::rayQueryGetIntersectionInstanceIdKHR(query, true);
+        const int instanceCustomIndex = spirv::rayQueryGetIntersectionInstanceCustomIndexKHR(query, true);
+        const int geometryIndex = spirv::rayQueryGetIntersectionGeometryIndexKHR(query, true);
         const int primID = spirv::rayQueryGetIntersectionPrimitiveIndexKHR(query, true);
 
         // TODO: candidate for `bda::__ptr<SGeomInfo>`
-        const SGeomInfo geom = vk::RawBufferLoad<SGeomInfo>(pc.geometryInfoBuffer + instID * sizeof(SGeomInfo),8);
+        const SGeomInfo geom = vk::RawBufferLoad<SGeomInfo>(pc.geometryInfoBuffer + (instanceCustomIndex + geometryIndex) * sizeof(SGeomInfo), 8);
 
         float3 normals;
         float2 barycentrics = spirv::rayQueryGetIntersectionBarycentricsKHR(query, true);
-        normals = calculateSmoothNormals(instID, primID, geom, barycentrics);
+        normals = calculateNormals(primID, geom, barycentrics);
 
         normals = normalize(normals) * 0.5 + 0.5;
         color = float4(normals, 1.0);

67_RayQueryGeometry/include/common.hpp

@@ -17,67 +17,17 @@ using namespace nbl::examples;
 
 namespace nbl::scene
 {
-enum ObjectType : uint8_t
-{
-	OT_CUBE,
-	OT_SPHERE,
-	OT_CYLINDER,
-	OT_RECTANGLE,
-	OT_CONE,
-	OT_ICOSPHERE,
-
-	OT_COUNT,
-	OT_UNKNOWN = std::numeric_limits<uint8_t>::max()
-};
-
-static constexpr uint32_t s_smoothNormals[OT_COUNT] = { 0, 1, 1, 0, 1, 1 };
-
-struct ObjectMeta
-{
-	ObjectType type = OT_UNKNOWN;
-	std::string_view name = "Unknown";
-};
-
-struct ObjectDrawHookCpu
-{
-	nbl::core::matrix3x4SIMD model;
-	ObjectMeta meta;
-};
-
-enum GeometryShader
-{
-	GP_BASIC = 0,
-	GP_CONE,
-	GP_ICO,
-
-	GP_COUNT
-};
 
+using PolygonGeometryData = core::smart_refctd_ptr<ICPUPolygonGeometry>;
+using GeometryCollectionData = core::smart_refctd_ptr<ICPUGeometryCollection>;
+using GeometryData = std::variant<PolygonGeometryData, GeometryCollectionData>;
 struct ReferenceObjectCpu
 {
-	ObjectMeta meta;
   core::matrix3x4SIMD transform;
-	core::smart_refctd_ptr<ICPUPolygonGeometry> data;
+	GeometryData data;
+  uint32_t instanceID;
 };
 
-struct ReferenceObjectGpu
-{
-	struct Bindings
-	{
-		nbl::asset::SBufferBinding<IGPUBuffer> vertex, index;
-	};
-
-	ObjectMeta meta;
-	Bindings bindings;
-	uint32_t vertexStride;
-	nbl::asset::E_INDEX_TYPE indexType = nbl::asset::E_INDEX_TYPE::EIT_UNKNOWN;
-	uint32_t indexCount = {};
-
-	const bool useIndex() const
-	{
-		return bindings.index.buffer && (indexType != E_INDEX_TYPE::EIT_UNKNOWN);
-	}
-};
 }