Windows should now work completely.

Add material index support and optimize ray query paths

- Introduced `materialIndex` in `InstanceData` to streamline per-instance material assignments in ray queries.
- Enhanced Vulkan descriptor bindings, adding new storage buffers for material and geometry data (Bindings 12 and 13).
- Extended `ModelLoader` with material index mapping and lookup functions for improved glTF material handling.
- Implemented robust material index resolution logic and authoritative mappings in TLAS build paths.
- Improved handling of alpha-masked and environment objects with dynamic ray-query classifications.
- Optimized geometry info and material buffer generation for better consistency in ray tracing workflows.
- Addressed descriptor flag size mismatches and resolved instances of unsafe type casting in Vulkan resource bindings.

Author: gpx1000

attachments/simple_engine/engine.cpp

@@ -906,6 +906,10 @@ void Engine::ProcessPendingBalls() {
       // Set bounciness from material
       rigidBody->SetRestitution(ballMaterial.bounciness);
 
+      // Request an acceleration structure build so the new ball is included in Ray Query mode.
+      // We do this after creating the rigid body and initializing the entity.
+      renderer->RequestAccelerationStructureBuild("Ball spawned");
+
       // Apply throw force and spin
       glm::vec3 throwImpulse = pendingBall.throwDirection * pendingBall.throwForce;
       rigidBody->ApplyImpulse(throwImpulse, glm::vec3(0.0f));

attachments/simple_engine/imgui_system.cpp

@@ -208,8 +208,6 @@ void ImGuiSystem::NewFrame() {
         ImGui::PopStyleVar();
       }
       ImGui::End();
-      ImGui::Render();
-      frameAlreadyRendered = true;
       return;
     }
   }
@@ -1034,7 +1032,7 @@ void ImGuiSystem::updateBuffers(uint32_t frameIndex) {
     if (frameIndex >= vertexCounts.size())
       return; // Safety
 
-    if (drawData->TotalVtxCount > vertexCounts[frameIndex]) {
+    if (static_cast<uint32_t>(drawData->TotalVtxCount) > vertexCounts[frameIndex]) {
       // Clean up old buffer
       vertexBuffers[frameIndex] = vk::raii::Buffer(nullptr);
       vertexBufferMemories[frameIndex] = vk::raii::DeviceMemory(nullptr);
@@ -1059,7 +1057,7 @@ void ImGuiSystem::updateBuffers(uint32_t frameIndex) {
       vertexCounts[frameIndex] = drawData->TotalVtxCount;
     }
 
-    if (drawData->TotalIdxCount > indexCounts[frameIndex]) {
+    if (static_cast<uint32_t>(drawData->TotalIdxCount) > indexCounts[frameIndex]) {
       // Clean up old buffer
       indexBuffers[frameIndex] = vk::raii::Buffer(nullptr);
       indexBufferMemories[frameIndex] = vk::raii::DeviceMemory(nullptr);

attachments/simple_engine/mesh_component.h

@@ -38,12 +38,16 @@ struct InstanceData {
   // Normal matrix as glm::mat3x4 (3 columns of vec4: xyz = normal matrix columns, w unused)
   glm::mat3x4 normalMatrix{};
 
+  // Material index for this instance
+  uint32_t materialIndex{0};
+
   InstanceData() {
     // Initialize as identity matrices
     modelMatrix = glm::mat4(1.0f);
     normalMatrix[0] = glm::vec4(1.0f, 0.0f, 0.0f, 0.0f);
     normalMatrix[1] = glm::vec4(0.0f, 1.0f, 0.0f, 0.0f);
     normalMatrix[2] = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f);
+    materialIndex = 0;
   }
 
   explicit InstanceData(const glm::mat4& transform, uint32_t matIndex = 0) {
@@ -56,7 +60,7 @@ struct InstanceData {
     normalMatrix[1] = glm::vec4(normalMat3[1], 0.0f);
     normalMatrix[2] = glm::vec4(normalMat3[2], 0.0f);
 
-    // Note: matIndex parameter ignored since materialIndex field was removed
+    materialIndex = matIndex;
   }
 
   // Helper methods for backward compatibility

attachments/simple_engine/model_loader.cpp

@@ -222,6 +222,10 @@ static bool LoadKTX2Image(tinygltf::Image* image,
 void ModelLoader::ProcessMaterials(const tinygltf::Model& gltfModel,
                                    const std::string& baseTexturePath,
                                    std::set<std::string>& loadedTextures) {
+  // Build/refresh an index -> material mapping that matches glTF material indices.
+  materialsByIndex.clear();
+  materialsByIndex.resize(gltfModel.materials.size(), nullptr);
+
   // Process materials first
   for (size_t i = 0; i < gltfModel.materials.size(); ++i) {
     const auto& gltfMaterial = gltfModel.materials[i];
@@ -570,7 +574,11 @@ void ModelLoader::ProcessMaterials(const tinygltf::Model& gltfModel,
     }
 
     // Store the material
+    Material* rawPtr = material.get();
     materials[material->GetName()] = std::move(material);
+    if (i < materialsByIndex.size()) {
+      materialsByIndex[i] = rawPtr;
+    }
   }
 
   // Handle KHR_materials_pbrSpecularGlossiness.diffuseTexture for baseColor when still missing
@@ -1617,7 +1625,7 @@ bool ModelLoader::ParseGLTF(const std::string& filename, Model* model) {
       }
 
       for (uint32_t index : materialMesh.indices) {
-        combinedIndices.push_back(index + vertexOffset);
+        combinedIndices.push_back(index + static_cast<uint32_t>(vertexOffset));
       }
     }
   }
@@ -1785,6 +1793,13 @@ const Material* ModelLoader::GetMaterial(const std::string& materialName) const
   return nullptr;
 }
 
+const Material* ModelLoader::GetMaterialByIndex(uint32_t materialIndex) const {
+  if (materialIndex < materialsByIndex.size()) {
+    return materialsByIndex[materialIndex];
+  }
+  return nullptr;
+}
+
 const std::vector<Animation>& ModelLoader::GetAnimations(const std::string& modelName) const {
   auto it = models.find(modelName);
   if (it != models.end() && it->second) {

attachments/simple_engine/model_loader.h

@@ -375,6 +375,13 @@ class ModelLoader {
 	 */
     const Material* GetMaterial(const std::string& materialName) const;
 
+    /**
+	 * @brief Get a material by its glTF material index.
+	 * @param materialIndex The material index as used by glTF primitives/instances.
+	 * @return Pointer to the material, or nullptr if out of range / not available.
+	 */
+    const Material* GetMaterialByIndex(uint32_t materialIndex) const;
+
     /**
 	 * @brief Get animations from a loaded model.
 	 * @param modelName The name of the model.
@@ -441,6 +448,9 @@ class ModelLoader {
     // Loaded materials
     std::unordered_map<std::string, std::unique_ptr<Material>> materials;
 
+    // Mapping from glTF material index -> Material pointer (rebuilt on each model load).
+    std::vector<Material*> materialsByIndex;
+
     // Extracted lights per model
     std::unordered_map<std::string, std::vector<ExtractedLight>> extractedLights;
 

attachments/simple_engine/physics_system.cpp

@@ -1276,7 +1276,7 @@ void PhysicsSystem::SimulatePhysicsOnGPU(const std::chrono::milliseconds deltaTi
 
   // Step 1: Integrate forces and velocities
   vulkanResources.commandBuffer.bindPipeline(vk::PipelineBindPoint::eCompute, *vulkanResources.integratePipeline);
-  vulkanResources.commandBuffer.dispatch((rigidBodies.size() + 63) / 64, 1, 1);
+  vulkanResources.commandBuffer.dispatch(static_cast<uint32_t>((rigidBodies.size() + 63) / 64), 1, 1);
 
   // Memory barrier to ensure integration is complete before collision detection
   vk::MemoryBarrier memoryBarrier;
@@ -1293,7 +1293,7 @@ void PhysicsSystem::SimulatePhysicsOnGPU(const std::chrono::milliseconds deltaTi
 
   // Step 2: Broad-phase collision detection
   vulkanResources.commandBuffer.bindPipeline(vk::PipelineBindPoint::eCompute, *vulkanResources.broadPhasePipeline);
-  uint32_t numPairs = (rigidBodies.size() * (rigidBodies.size() - 1)) / 2;
+  uint32_t numPairs = static_cast<uint32_t>((rigidBodies.size() * (rigidBodies.size() - 1)) / 2);
   // Dispatch number of workgroups matching [numthreads(64,1,1)] in BroadPhaseCS
   // One workgroup has 64 threads, each processes one pair by index
   uint32_t broadPhaseThreads = (numPairs + 63) / 64;

attachments/simple_engine/renderdoc_debug_system.cpp

@@ -20,7 +20,9 @@
 #include <iostream>
 
 #if defined(_WIN32)
-#	define WIN32_LEAN_AND_MEAN
+#	ifndef WIN32_LEAN_AND_MEAN
+#		define WIN32_LEAN_AND_MEAN
+#	endif
 #	include <windows.h>
 #elif defined(__APPLE__) || defined(__linux__)
 #	include <dlfcn.h>

attachments/simple_engine/renderer.h

@@ -96,6 +96,15 @@ struct LightData {
   alignas(4) float outerConeAngle; // For spotlights
 };
 
+struct ShadowUniforms {
+  alignas(16) glm::mat4 view;
+  alignas(16) glm::mat4 proj;
+};
+
+struct ShadowPushConstants {
+  alignas(16) glm::mat4 model;
+};
+
 /**
  * @brief Structure for the uniform buffer object (now without fixed light arrays).
  */
@@ -598,15 +607,9 @@ class Renderer {
       }
     }
 
-    // Descriptor set deferred update machinery
-    void MarkEntityDescriptorsDirty(Entity* entity);
-    void ProcessDirtyDescriptorsForFrame(uint32_t frameIndex);
-    bool updateDescriptorSetsForFrame(Entity* entity,
-                                      const std::string& texturePath,
-                                      bool usePBR,
-                                      uint32_t frameIndex,
-                                      bool imagesOnly = false,
-                                      bool uboOnly = false);
+	// Descriptor set deferred update machinery
+	void MarkEntityDescriptorsDirty(Entity *entity);
+	void ProcessDirtyDescriptorsForFrame(uint32_t frameIndex);
 
     // Texture aliasing: map canonical IDs to actual loaded keys (e.g., file paths) to avoid duplicates
     inline void RegisterTextureAlias(const std::string& aliasId, const std::string& targetId) {
@@ -822,10 +825,16 @@ class Renderer {
           .count());
         asBuildRequestStartNs.store(nowNs, std::memory_order_relaxed);
       }
-      if (reason)
+      if (reason) {
         lastASBuildRequestReason = reason;
-      else
+        std::cout << "[AS] Requesting rebuild. Reason: " << reason << std::endl;
+      } else {
         lastASBuildRequestReason = "(no reason)";
+      }
+
+      // Explicit requests bypass the freeze to ensure dynamic objects (like balls) are added
+      asDevOverrideAllowRebuild = true;
+
       watchdogSuppressed.store(true, std::memory_order_relaxed);
       asBuildRequested.store(true, std::memory_order_release);
     }
@@ -860,7 +869,7 @@ class Renderer {
 	 * @param lights The light data to upload.
 	 * @return True if successful, false otherwise.
 	 */
-    bool updateLightStorageBuffer(uint32_t frameIndex, const std::vector<ExtractedLight>& lights);
+    bool updateLightStorageBuffer(uint32_t frameIndex, const std::vector<ExtractedLight>& lights, CameraComponent* camera = nullptr);
 
     /**
 	 * @brief Update all existing descriptor sets with new light storage buffer references.
@@ -1514,13 +1523,24 @@ class Renderer {
       bool materialCacheValid = false;
       const Material* cachedMaterial = nullptr;
       // Derived flags used by render queues and sorting heuristics
-      bool cachedIsBlended = false;
-      bool cachedIsGlass = false;
-      bool cachedIsLiquid = false;
-      // Material-derived push constants defaults (static per-entity unless material changes)
-      MaterialProperties cachedMaterialProps{};
-    };
-    std::unordered_map<Entity *, EntityResources> entityResources;
+		bool cachedIsBlended = false;
+		bool cachedIsGlass   = false;
+		bool cachedIsLiquid  = false;
+		// Material-derived push constants defaults (static per-entity unless material changes)
+		MaterialProperties cachedMaterialProps{};
+	};
+
+	// Cached job for rendering a single entity in a frame
+	struct RenderJob
+	{
+		Entity             *entity;
+		EntityResources    *entityRes;
+		MeshResources      *meshRes;
+		MeshComponent      *meshComp;
+		TransformComponent *transformComp;
+		bool                isAlphaMasked;
+	};
+	std::unordered_map<Entity *, EntityResources> entityResources;
 
     // Descriptor pool (declared after entity resources to ensure proper destruction order)
     vk::raii::DescriptorPool descriptorPool = nullptr;
@@ -1639,7 +1659,7 @@ class Renderer {
     const uint32_t MAX_FRAMES_IN_FLIGHT = 2u;
 
     // --- Performance & diagnostics ---
-    // CPU-side frustum culling toggle and last-frame stats
+    UniformBufferObject frameUboTemplate{};
     bool enableFrustumCulling = true;
     uint32_t lastCullingVisibleCount = 0;
     uint32_t lastCullingCulledCount = 0;
@@ -1756,12 +1776,26 @@ class Renderer {
     bool createUniformBuffers(Entity* entity);
     bool createDescriptorPool();
     bool createDescriptorSets(Entity* entity, const std::string& texturePath, bool usePBR = false);
-    // Refresh only the currentFrame PBR descriptor set bindings that Forward+ relies on
-    // (b6 = lights SSBO, b7 = tile headers, b8 = tile indices). Safe to call after
-    // we've waited on the frame fence at the start of Render().
-    void refreshPBRForwardPlusBindingsForFrame(uint32_t frameIndex);
-    bool createCommandBuffers();
-    bool createSyncObjects();
+    bool createDescriptorSets(Entity *entity, EntityResources &res, const std::string &texturePath, bool usePBR = false);
+	bool updateDescriptorSetsForFrame(Entity            *entity,
+	                                  const std::string &texturePath,
+	                                  bool               usePBR,
+	                                  uint32_t           frameIndex,
+	                                  bool               imagesOnly = false,
+	                                  bool               uboOnly    = false);
+	bool updateDescriptorSetsForFrame(Entity            *entity,
+	                                  EntityResources   &res,
+	                                  const std::string &texturePath,
+	                                  bool               usePBR,
+	                                  uint32_t           frameIndex,
+	                                  bool               imagesOnly = false,
+	                                  bool               uboOnly    = false);
+	// Refresh only the currentFrame PBR descriptor set bindings that Forward+ relies on
+	// (b6 = lights SSBO, b7 = tile headers, b8 = tile indices). Safe to call after
+	// we've waited on the frame fence at the start of Render().
+	void refreshPBRForwardPlusBindingsForFrame(uint32_t frameIndex);
+	bool createCommandBuffers();
+	bool createSyncObjects();
 
     void cleanupSwapChain();
 
@@ -1772,14 +1806,14 @@ class Renderer {
     void renderReflectionPass(vk::raii::CommandBuffer& cmd,
                               const glm::vec4& planeWS,
                               CameraComponent* camera,
-                              const std::vector<Entity *>& entities);
+                              const std::vector<RenderJob>      &jobs);
 
     // Ensure Vulkan-Hpp dispatcher is initialized for the current thread when using RAII objects on worker threads
     void ensureThreadLocalVulkanInit() const;
 
     // Cache and classify an entity's material for raster rendering (opaque vs blended, glass/liquid flags,
     // and push-constant defaults). This avoids repeated per-frame string parsing and material lookups.
-    void ensureEntityMaterialCache(Entity* entity);
+    void ensureEntityMaterialCache(Entity* entity, EntityResources &res);
 
     // ===================== Culling helpers =====================
     struct FrustumPlanes {
@@ -1800,9 +1834,10 @@ class Renderer {
                                       const FrustumPlanes& frustum);
     void recreateSwapChain();
 
-    void updateUniformBuffer(uint32_t currentImage, Entity* entity, CameraComponent* camera);
-    void updateUniformBuffer(uint32_t currentImage, Entity* entity, CameraComponent* camera, const glm::mat4& customTransform);
-    void updateUniformBufferInternal(uint32_t currentImage, Entity* entity, CameraComponent* camera, UniformBufferObject& ubo);
+    void updateUniformBuffer(uint32_t currentImage, Entity* entity, EntityResources *entityRes, CameraComponent* camera, TransformComponent *tc = nullptr);
+    void updateUniformBuffer(uint32_t currentImage, Entity* entity, EntityResources *entityRes, CameraComponent* camera, const glm::mat4& customTransform);
+    void updateUniformBufferInternal(uint32_t currentImage, Entity* entity, EntityResources *entityRes, CameraComponent* camera, UniformBufferObject& ubo);
+	void prepareFrameUboTemplate(CameraComponent *camera);
 
     vk::raii::ShaderModule createShaderModule(const std::vector<char>& code);
 

attachments/simple_engine/renderer_pipelines.cpp

@@ -172,13 +172,29 @@ bool Renderer::createPBRDescriptorSetLayout() {
         .descriptorCount = 1,
         .stageFlags = vk::ShaderStageFlagBits::eFragment,
         .pImmutableSamplers = nullptr
+      },
+      // Binding 12: Ray-query geometry info buffer (per-instance addresses + material indices)
+      vk::DescriptorSetLayoutBinding{
+        .binding = 12,
+        .descriptorType = vk::DescriptorType::eStorageBuffer,
+        .descriptorCount = 1,
+        .stageFlags = vk::ShaderStageFlagBits::eFragment,
+        .pImmutableSamplers = nullptr
+      },
+      // Binding 13: Ray-query material buffer (PBR material properties)
+      vk::DescriptorSetLayoutBinding{
+        .binding = 13,
+        .descriptorType = vk::DescriptorType::eStorageBuffer,
+        .descriptorCount = 1,
+        .stageFlags = vk::ShaderStageFlagBits::eFragment,
+        .pImmutableSamplers = nullptr
       }
     };
 
     // Create a descriptor set layout
     // Descriptor indexing: set per-binding flags for UPDATE_AFTER_BIND on UBO (0) and sampled images (1..5)
     vk::DescriptorSetLayoutBindingFlagsCreateInfo bindingFlagsInfo{};
-    std::array<vk::DescriptorBindingFlags, 12> bindingFlags{};
+    std::array<vk::DescriptorBindingFlags, 14> bindingFlags{};
     if (descriptorIndexingEnabled) {
       bindingFlags[0] = vk::DescriptorBindingFlagBits::eUpdateAfterBind | vk::DescriptorBindingFlagBits::eUpdateUnusedWhilePending;
       bindingFlags[1] = vk::DescriptorBindingFlagBits::eUpdateAfterBind | vk::DescriptorBindingFlagBits::eUpdateUnusedWhilePending;