Add spare Vulkan RT scene slot for pipelining

asset/shader/vulkan/raytrace.rgen

@@ -151,14 +151,30 @@ HardwareRaytraceInstanceData GetRaytraceInstanceData(const int instance_index)
     return raytrace_instances[instance_index];
 }
 
+bool UseSharedSceneTransform()
+{
+    return raytrace_instances.length() > 0 &&
+           raytrace_instances[0].metadata.z != 0u;
+}
+
 vec3 TransformPoint(const mat4 matrix, const vec3 point)
 {
     return (matrix * vec4(point, 1.0)).xyz;
 }
 
+mat4 GetObjectToWorld(const HardwareRaytraceInstanceData instance_data)
+{
+    return UseSharedSceneTransform() ? ubo.model : instance_data.object_to_world;
+}
+
+mat4 GetWorldToObject(const HardwareRaytraceInstanceData instance_data)
+{
+    return UseSharedSceneTransform() ? ubo.model_inv : instance_data.world_to_object;
+}
+
 mat3 GetNormalMatrix(const HardwareRaytraceInstanceData instance_data)
 {
-    return transpose(mat3(instance_data.world_to_object));
+    return transpose(mat3(GetWorldToObject(instance_data)));
 }
 
 // ----------------------------------------------------------------------------
@@ -392,6 +408,14 @@ bool anyHitTriangles(const vec3 ray_origin, const vec3 ray_dir, const float max_
         return false;
     }
 
+    vec3 trace_origin = ray_origin;
+    vec3 trace_dir = ray_dir;
+    if (UseSharedSceneTransform())
+    {
+        trace_origin = TransformPoint(ubo.model_inv, ray_origin);
+        trace_dir = normalize((ubo.model_inv * vec4(ray_dir, 0.0)).xyz);
+    }
+
     ray_payload.hit_data = vec4(0.0);
     ray_payload.index_data = ivec4(-1);
     traceRayEXT(
@@ -401,9 +425,9 @@ bool anyHitTriangles(const vec3 ray_origin, const vec3 ray_dir, const float max_
         0,
         0,
         0,
-        ray_origin,
+        trace_origin,
         0.001,
-        ray_dir,
+        trace_dir,
         max_t,
         0);
     return ray_payload.hit_data.x != 0.0;
@@ -436,6 +460,14 @@ HitInfo TraceScene(const vec3 ray_origin_world, const vec3 ray_dir_world)
         return info;
     }
 
+    vec3 trace_origin = ray_origin_world;
+    vec3 trace_dir = ray_dir_world;
+    if (UseSharedSceneTransform())
+    {
+        trace_origin = TransformPoint(ubo.model_inv, ray_origin_world);
+        trace_dir = normalize((ubo.model_inv * vec4(ray_dir_world, 0.0)).xyz);
+    }
+
     ray_payload.hit_data = vec4(0.0);
     ray_payload.index_data = ivec4(-1);
     traceRayEXT(
@@ -445,9 +477,9 @@ HitInfo TraceScene(const vec3 ray_origin_world, const vec3 ray_dir_world)
         0,
         0,
         0,
-        ray_origin_world,
+        trace_origin,
         0.001,
-        ray_dir_world,
+        trace_dir,
         1.0e30,
         0);
     if (ray_payload.hit_data.x == 0.0)
@@ -475,7 +507,7 @@ HitInfo TraceScene(const vec3 ray_origin_world, const vec3 ray_dir_world)
         tri.v0.position * w +
         tri.v1.position * info.bary.x +
         tri.v2.position * info.bary.y;
-    info.pos_world = TransformPoint(instance_data.object_to_world, info.pos_model);
+    info.pos_world = TransformPoint(GetObjectToWorld(instance_data), info.pos_model);
     info.normal_model = normalize(
         tri.v0.normal * w +
         tri.v1.normal * info.bary.x +

frame/vulkan/buffer_resources.cpp

@@ -23,7 +23,7 @@ void BufferResourceManager::Clear()
 {
     storage_buffers_.clear();
     storage_buffer_indices_.clear();
-    uniform_buffer_ = {};
+    uniform_buffers_.clear();
 }
 
 BufferResource BufferResourceManager::MakeGpuBuffer(
@@ -216,57 +216,74 @@ bool BufferResourceManager::UpdateStorageBuffer(
     return true;
 }
 
-void BufferResourceManager::BuildUniformBuffer(vk::DeviceSize size_bytes)
+void BufferResourceManager::BuildUniformBuffers(
+    std::size_t count,
+    vk::DeviceSize size_bytes)
 {
-    if (size_bytes == 0)
+    if (count == 0 || size_bytes == 0)
     {
-        throw std::runtime_error("Uniform buffer size must be non-zero.");
+        throw std::runtime_error(
+            "Uniform buffer count and size must be non-zero.");
     }
 
-    vk::UniqueDeviceMemory uniform_memory;
-    auto uniform_buf = memory_manager_->CreateBuffer(
-        size_bytes,
-        vk::BufferUsageFlagBits::eUniformBuffer,
-        vk::MemoryPropertyFlagBits::eHostVisible |
-            vk::MemoryPropertyFlagBits::eHostCoherent,
-        uniform_memory);
+    uniform_buffers_.clear();
+    uniform_buffers_.reserve(count);
+    for (std::size_t i = 0; i < count; ++i)
+    {
+        vk::UniqueDeviceMemory uniform_memory;
+        auto uniform_buf = memory_manager_->CreateBuffer(
+            size_bytes,
+            vk::BufferUsageFlagBits::eUniformBuffer,
+            vk::MemoryPropertyFlagBits::eHostVisible |
+                vk::MemoryPropertyFlagBits::eHostCoherent,
+            uniform_memory);
 
-    uniform_buffer_.name = "uniforms";
-    uniform_buffer_.size = size_bytes;
-    uniform_buffer_.buffer = std::move(uniform_buf);
-    uniform_buffer_.memory = std::move(uniform_memory);
+        BufferResource uniform_buffer = {};
+        uniform_buffer.name = "uniforms_" + std::to_string(i);
+        uniform_buffer.size = size_bytes;
+        uniform_buffer.buffer = std::move(uniform_buf);
+        uniform_buffer.memory = std::move(uniform_memory);
+        uniform_buffers_.push_back(std::move(uniform_buffer));
+    }
 }
 
 void BufferResourceManager::UpdateUniform(
+    std::size_t index,
     const void* data,
     std::size_t byte_count) const
 {
-    if (!uniform_buffer_.buffer ||
-        !uniform_buffer_.memory ||
-        uniform_buffer_.size == 0)
+    if (index >= uniform_buffers_.size())
+    {
+        (*logger_)->warn("Uniform buffer index {} is out of range.", index);
+        return;
+    }
+    const auto& uniform_buffer = uniform_buffers_[index];
+    if (!uniform_buffer.buffer ||
+        !uniform_buffer.memory ||
+        uniform_buffer.size == 0)
     {
         (*logger_)->warn("Uniform buffer not initialized before update.");
         return;
     }
-    if (byte_count > static_cast<std::size_t>(uniform_buffer_.size))
+    if (byte_count > static_cast<std::size_t>(uniform_buffer.size))
     {
         (*logger_)->warn(
             "Uniform update size {} exceeds buffer capacity {}.",
             byte_count,
-            static_cast<std::size_t>(uniform_buffer_.size));
+            static_cast<std::size_t>(uniform_buffer.size));
         return;
     }
     void* mapped = device_.mapMemory(
-        *uniform_buffer_.memory, 0, uniform_buffer_.size);
+        *uniform_buffer.memory, 0, uniform_buffer.size);
     if (data && byte_count > 0)
     {
         std::memcpy(mapped, data, byte_count);
     }
     else
     {
-        std::memset(mapped, 0, uniform_buffer_.size);
+        std::memset(mapped, 0, uniform_buffer.size);
     }
-    device_.unmapMemory(*uniform_buffer_.memory);
+    device_.unmapMemory(*uniform_buffer.memory);
 }
 
 void BufferResourceManager::LogCpuBufferSamples(

frame/vulkan/buffer_resources.h

@@ -39,17 +39,39 @@ class BufferResourceManager
     bool UpdateStorageBuffer(
         const std::string& name,
         const std::vector<std::uint8_t>& bytes);
-    void BuildUniformBuffer(vk::DeviceSize size_bytes);
-    void UpdateUniform(const void* data, std::size_t byte_count) const;
+    void BuildUniformBuffers(
+        std::size_t count,
+        vk::DeviceSize size_bytes);
+    void BuildUniformBuffer(vk::DeviceSize size_bytes)
+    {
+        BuildUniformBuffers(1, size_bytes);
+    }
+    void UpdateUniform(
+        std::size_t index,
+        const void* data,
+        std::size_t byte_count) const;
+    void UpdateUniform(const void* data, std::size_t byte_count) const
+    {
+        UpdateUniform(0, data, byte_count);
+    }
 
     const std::vector<BufferResource>& GetStorageBuffers() const
     {
         return storage_buffers_;
     }
 
+    const BufferResource* GetUniformBuffer(std::size_t index) const
+    {
+        if (index >= uniform_buffers_.size())
+        {
+            return nullptr;
+        }
+        return uniform_buffers_[index].buffer ? &uniform_buffers_[index]
+                                              : nullptr;
+    }
     const BufferResource* GetUniformBuffer() const
     {
-        return uniform_buffer_.buffer ? &uniform_buffer_ : nullptr;
+        return GetUniformBuffer(0);
     }
 
     void LogCpuBufferSamples(
@@ -69,7 +91,7 @@ class BufferResourceManager
     const Logger* logger_;
     std::vector<BufferResource> storage_buffers_;
     std::unordered_map<std::string, std::size_t> storage_buffer_indices_;
-    BufferResource uniform_buffer_;
+    std::vector<BufferResource> uniform_buffers_;
 };
 
 } // namespace frame::vulkan