Pass:send supports raytracer; Bugfixes;

Author: bjornbytes

src/api/l_graphics.c

@@ -489,6 +489,7 @@ static int l_lovrGraphicsGetFeatures(lua_State* L) {
   lua_pushboolean(L, features.wireframe), lua_setfield(L, -2, "wireframe");
   lua_pushboolean(L, features.depthClamp), lua_setfield(L, -2, "depthClamp");
   lua_pushboolean(L, features.depthResolve), lua_setfield(L, -2, "depthResolve");
+  lua_pushboolean(L, features.raytracing), lua_setfield(L, -2, "raytracing");
   lua_pushboolean(L, features.indirectDrawFirstInstance), lua_setfield(L, -2, "indirectDrawFirstInstance");
   lua_pushboolean(L, features.packedBuffers), lua_setfield(L, -2, "packedBuffers");
   lua_pushboolean(L, features.float64), lua_setfield(L, -2, "float64");

src/api/l_graphics_pass.c

@@ -727,7 +727,7 @@ static int l_lovrPassSend(lua_State* L) {
   const char* name = luaL_checklstring(L, 2, &length);
 
   if (lua_isnoneornil(L, 3)) {
-    return luax_typeerror(L, 3, "Buffer, Texture, Sampler, number, vector, table, or boolean");
+    return luax_typeerror(L, 3, "Buffer, Texture, Sampler, Raytracer, number, vector, table, or boolean");
   }
 
   Buffer* buffer = luax_totype(L, 3, Buffer);
@@ -753,6 +753,13 @@ static int l_lovrPassSend(lua_State* L) {
     return 0;
   }
 
+  Raytracer* raytracer = luax_totype(L, 3, Raytracer);
+
+  if (raytracer) {
+    luax_assert(L, lovrPassSendRaytracer(pass, name, length, raytracer));
+    return 0;
+  }
+
   void* pointer;
   DataField* format;
   luax_assert(L, lovrPassSendData(pass, name, length, &pointer, &format));

src/core/gpu_vk.c

@@ -505,7 +505,7 @@ bool gpu_tree_init(gpu_tree* tree, gpu_tree_info* info) {
           .vertexFormat = convertAttributeType(mesh->vertexType),
           .vertexStride = mesh->vertexStride,
           .maxVertex = mesh->vertexCount,
-          .indexType = mesh->indexOffset == ~0u ? (VkIndexType) mesh->indexType : VK_INDEX_TYPE_NONE_KHR
+          .indexType = mesh->indexOffset == ~0u ? VK_INDEX_TYPE_NONE_KHR : (VkIndexType) mesh->indexType
         }
       };
 
@@ -3753,7 +3753,7 @@ static VkBufferUsageFlags getBufferUsage(gpu_buffer_type type) {
         VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
         VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
         VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-        (state.extensions.bufferDeviceAddress ? VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT : 0);
+        (state.extensions.bufferDeviceAddress ? VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT : 0) |
         (state.extensions.accelerationStructure ? VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR : 0);
     case GPU_BUFFER_STREAM:
       return

src/modules/graphics/graphics.c

@@ -150,6 +150,7 @@ struct Shader {
   uint32_t bufferMask;
   uint32_t textureMask;
   uint32_t samplerMask;
+  uint32_t raytracerMask;
   uint32_t storageMask;
   uint32_t pushConstantSize;
   uint32_t uniformSize;
@@ -299,10 +300,11 @@ struct Model {
 
 struct Raytracer {
   uint32_t ref;
+  uint32_t count;
   RaytracerInfo info;
+  Sync sync;
   gpu_tree* gpu;
   gpu_tree_instance* instances;
-  uint32_t count;
   bool canUpdate;
 };
 
@@ -414,8 +416,8 @@ typedef struct {
   void* next;
   uint64_t count;
   uint64_t textureMask;
-  uint64_t padding;
-  Access list[41];
+  uint64_t raytracerMask;
+  Access list[41]; // 1024 bytes total
 } AccessBlock;
 
 typedef struct {
@@ -621,10 +623,11 @@ static uint32_t measureTexture(TextureFormat format, uint32_t w, uint32_t h, uin
 static bool checkTextureBounds(const TextureInfo* info, uint32_t offset[4], uint32_t extent[3]);
 static void mipmapTexture(gpu_stream* stream, Texture* texture, uint32_t base, uint32_t count);
 static ShaderResource* findShaderResource(Shader* shader, const char* name, size_t length);
-static Access* getNextAccess(Pass* pass, int type, bool texture);
+static Access* getNextAccess(Pass* pass, int type, bool texture, bool raytracer);
 static void trackBuffer(Pass* pass, Buffer* buffer, gpu_phase phase, gpu_cache cache);
 static void trackTexture(Pass* pass, Texture* texture, gpu_phase phase, gpu_cache cache);
 static void trackMaterial(Pass* pass, Material* material);
+static void trackRaytracer(Pass* pass, Raytracer* raytracer, gpu_phase phase, gpu_cache cache);
 static bool syncResource(Access* access, gpu_barrier* barrier);
 static gpu_barrier syncTransfer(Sync* sync, gpu_phase phase, gpu_cache cache);
 static void updateModelTransforms(Model* model, uint32_t nodeIndex, float* parent);
@@ -950,6 +953,7 @@ void lovrGraphicsGetFeatures(GraphicsFeatures* features) {
   features->wireframe = state.features.wireframe;
   features->depthClamp = state.features.depthClamp;
   features->depthResolve = state.features.depthResolve;
+  features->raytracing = state.features.rayQuery;
   features->indirectDrawFirstInstance = state.features.indirectDrawFirstInstance;
   features->packedBuffers = state.features.packedBuffers;
   features->float64 = state.features.float64;
@@ -3542,11 +3546,13 @@ Shader* lovrShaderCreate(const ShaderInfo* info) {
       bool buffer = resource->type == SPV_UNIFORM_BUFFER || resource->type == SPV_STORAGE_BUFFER;
       bool texture = resource->type == SPV_SAMPLED_TEXTURE || resource->type == SPV_STORAGE_TEXTURE || resource->type == SPV_COMBINED_TEXTURE_SAMPLER;
       bool sampler = resource->type == SPV_SAMPLER;
+      bool raytracer = resource->type == SPV_ACCELERATION_STRUCTURE;
       bool storage = resource->type == SPV_STORAGE_BUFFER || resource->type == SPV_STORAGE_TEXTURE;
 
       shader->bufferMask |= (buffer << *binding);
       shader->textureMask |= (texture << *binding);
       shader->samplerMask |= (sampler << *binding);
+      shader->raytracerMask |= (raytracer << *binding);
       shader->storageMask |= (storage << *binding);
 
       gpu_cache cache;
@@ -5967,8 +5973,13 @@ static void lovrPassRelease(Pass* pass) {
   for (uint32_t i = 0; i < COUNTOF(pass->access); i++) {
     for (AccessBlock* block = pass->access[i]; block != NULL; block = block->next) {
       for (uint32_t j = 0; j < block->count; j++) {
-        bool texture = block->textureMask & (1ull << j);
-        lovrRelease(block->list[j].object, texture ? lovrTextureDestroy : lovrBufferDestroy);
+        if (block->textureMask & (1ull << j)) {
+          lovrRelease(block->list[j].object, lovrTextureDestroy);
+        } else if (block->raytracerMask & (1ull << j)) {
+          lovrRelease(block->list[j].object, lovrRaytracerDestroy);
+        } else {
+          lovrRelease(block->list[j].object, lovrBufferDestroy);
+        }
       }
     }
   }
@@ -6979,6 +6990,22 @@ bool lovrPassSendSampler(Pass* pass, const char* name, size_t length, Sampler* s
   return true;
 }
 
+bool lovrPassSendRaytracer(Pass* pass, const char* name, size_t length, Raytracer* raytracer) {
+  Shader* shader = pass->pipeline->shader;
+  lovrCheck(shader, "A Shader must be active to send resources");
+
+  ShaderResource* resource = findShaderResource(shader, name, length);
+  lovrCheck(resource, "Shader has no variable named '%s'", name);
+  uint32_t slot = resource->binding;
+
+  lovrCheck(shader->raytracerMask & (1u << slot), "Trying to send a Raytracer to '%s', but the shader variable isn't a Raytracer", name);
+
+  trackRaytracer(pass, raytracer, resource->phase, resource->cache);
+  pass->bindings[slot].tree = raytracer->gpu;
+  pass->flags |= DIRTY_BINDINGS;
+  return true;
+}
+
 bool lovrPassSendData(Pass* pass, const char* name, size_t length, void** data, DataField** format) {
   Shader* shader = pass->pipeline->shader;
   lovrCheck(shader, "A Shader must be active to send data to it");
@@ -8976,7 +9003,7 @@ static ShaderResource* findShaderResource(Shader* shader, const char* name, size
   return NULL;
 }
 
-static Access* getNextAccess(Pass* pass, int type, bool texture) {
+static Access* getNextAccess(Pass* pass, int type, bool texture, bool raytracer) {
   AccessBlock* block = pass->access[type];
 
   if (!block || block->count >= COUNTOF(block->list)) {
@@ -8985,16 +9012,18 @@ static Access* getNextAccess(Pass* pass, int type, bool texture) {
     new->next = block;
     new->count = 0;
     new->textureMask = 0;
+    new->raytracerMask = 0;
     block = new;
   }
 
   block->textureMask |= (uint64_t) texture << block->count;
+  block->raytracerMask |= (uint64_t) raytracer << block->count;
   return &block->list[block->count++];
 }
 
 static void trackBuffer(Pass* pass, Buffer* buffer, gpu_phase phase, gpu_cache cache) {
   if (!buffer) return;
-  Access* access = getNextAccess(pass, phase == GPU_PHASE_SHADER_COMPUTE ? ACCESS_COMPUTE : ACCESS_RENDER, false);
+  Access* access = getNextAccess(pass, phase == GPU_PHASE_SHADER_COMPUTE ? ACCESS_COMPUTE : ACCESS_RENDER, false, false);
   access->sync = buffer->sync;
   access->object = buffer;
   access->phase = phase;
@@ -9011,7 +9040,7 @@ static void trackTexture(Pass* pass, Texture* texture, gpu_phase phase, gpu_cach
     cache = 0;
   }
 
-  Access* access = getNextAccess(pass, phase == GPU_PHASE_SHADER_COMPUTE ? ACCESS_COMPUTE : ACCESS_RENDER, true);
+  Access* access = getNextAccess(pass, phase == GPU_PHASE_SHADER_COMPUTE ? ACCESS_COMPUTE : ACCESS_RENDER, true, false);
   access->sync = texture->sync;
   access->object = texture;
   access->phase = phase;
@@ -9036,6 +9065,15 @@ static void trackMaterial(Pass* pass, Material* material) {
   trackTexture(pass, material->info.normalTexture, phase, cache);
 }
 
+static void trackRaytracer(Pass* pass, Raytracer* raytracer, gpu_phase phase, gpu_cache cache) {
+  Access* access = getNextAccess(pass, phase == GPU_PHASE_SHADER_COMPUTE ? ACCESS_COMPUTE : ACCESS_RENDER, false, true);
+  access->sync = &raytracer->sync;
+  access->object = raytracer;
+  access->phase = phase;
+  access->cache = cache;
+  lovrRetain(raytracer);
+}
+
 static bool syncResource(Access* access, gpu_barrier* barrier) {
   // There are 4 types of access patterns:
   // - read after read:

src/modules/graphics/graphics.h

@@ -47,6 +47,7 @@ typedef struct {
   bool wireframe;
   bool depthClamp;
   bool depthResolve;
+  bool raytracing;
   bool indirectDrawFirstInstance;
   bool packedBuffers;
   bool float64;
@@ -701,6 +702,7 @@ void lovrPassSetWireframe(Pass* pass, bool wireframe);
 bool lovrPassSendBuffer(Pass* pass, const char* name, size_t length, Buffer* buffer, uint32_t offset, uint32_t extent);
 bool lovrPassSendTexture(Pass* pass, const char* name, size_t length, Texture* texture);
 bool lovrPassSendSampler(Pass* pass, const char* name, size_t length, Sampler* sampler);
+bool lovrPassSendRaytracer(Pass* pass, const char* name, size_t length, Raytracer* raytracer);
 bool lovrPassSendData(Pass* pass, const char* name, size_t length, void** data, DataField** format);
 
 bool lovrPassPoints(Pass* pass, uint32_t count, float** vertices);