Revert "Next big changes to make WebGPU work"

This reverts commit 0a95ee2fa8.

engine/asset/src/asset.cpp

@@ -50,7 +50,7 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
     Expects(numVertices > 0);
         
     const auto read_buffer = [&f = file.value(), numVertices](unsigned int size) -> GFXBuffer* {
-        auto buffer = engine->get_gfx()->create_buffer(nullptr, size * static_cast<unsigned int>(numVertices), GFXBufferUsage::Vertex);
+        auto buffer = engine->get_gfx()->create_buffer(nullptr, size * static_cast<unsigned int>(numVertices), false, GFXBufferUsage::Vertex);
         auto buffer_ptr = reinterpret_cast<unsigned char*>(engine->get_gfx()->get_buffer_contents(buffer));
         if(buffer_ptr != nullptr) {
             f.read(buffer_ptr, size * static_cast<unsigned int>(numVertices));
@@ -78,15 +78,15 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
     
     Expects(numIndices > 0);
     
-    mesh->index_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(uint32_t) * numIndices, GFXBufferUsage::Index);
+    mesh->index_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(uint32_t) * numIndices, false, GFXBufferUsage::Index);
     auto index_ptr = reinterpret_cast<uint32_t*>(engine->get_gfx()->get_buffer_contents(mesh->index_buffer));
     if(index_ptr != nullptr) {
         file->read(index_ptr, sizeof(uint32_t) * numIndices);
-
-        engine->get_gfx()->release_buffer_contents(mesh->index_buffer, index_ptr);
     } else {
         file->seek(sizeof(uint32_t) * numIndices);
     }
+    
+    engine->get_gfx()->release_buffer_contents(mesh->index_buffer, index_ptr);
 
     int bone_len = 0;
     file->read(&bone_len);
@@ -172,7 +172,7 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
         int numBones = 0;
         file->read(&numBones);
         
-        p.bone_batrix_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(Matrix4x4) * 128, GFXBufferUsage::Storage);
+        p.bone_batrix_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(Matrix4x4) * 128, true, GFXBufferUsage::Storage);
         
         if(numBones > 0) {
             p.offset_matrices.resize(numBones);

engine/gfx/public/gfx.hpp

@@ -57,19 +57,11 @@ inline GFXTextureUsage operator&(const GFXTextureUsage a, const GFXTextureUsage
 }
 
 enum class GFXBufferUsage : int {
-	Storage = 0,
+	Storage,
-	Vertex = 1,
+	Vertex,
-	Index = 2
+	Index
 };
 
-inline GFXBufferUsage operator|(const GFXBufferUsage a, const GFXBufferUsage b) {
-    return static_cast<GFXBufferUsage>(static_cast<int>(a) | static_cast<int>(b));
-}
-
-inline GFXBufferUsage operator&(const GFXBufferUsage a, const GFXBufferUsage b) {
-    return static_cast<GFXBufferUsage>(static_cast<int>(a) & static_cast<int>(b));
-}
-
 enum class GFXBlendFactor : int {
 	One,
     Zero,
@@ -317,6 +309,7 @@ public:
     // buffer operations
     virtual GFXBuffer* create_buffer([[maybe_unused]] void* data,
                                      [[maybe_unused]] const GFXSize size,
+                                     [[maybe_unused]] const bool is_dynamic,
                                      [[maybe_unused]] const GFXBufferUsage usage) { return nullptr; }
     virtual void copy_buffer([[maybe_unused]] GFXBuffer* buffer,
                              [[maybe_unused]] void* data,

engine/gfx/vulkan/include/gfx_vulkan.hpp

@@ -50,7 +50,7 @@ public:
 	void recreate_view(platform::window_ptr identifier, uint32_t width, uint32_t height) override;
 
     // buffer operations
-    GFXBuffer* create_buffer(void* data, GFXSize size, GFXBufferUsage usage) override;
+    GFXBuffer* create_buffer(void* data, GFXSize size, bool dynamic_data, GFXBufferUsage usage) override;
     void copy_buffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) override;
 
     void* get_buffer_contents(GFXBuffer* buffer) override;

engine/gfx/vulkan/src/gfx_vulkan.cpp

@@ -263,7 +263,7 @@ void GFXVulkan::recreate_view(const platform::window_ptr identifier, const uint3
     }
 }
 
-GFXBuffer* GFXVulkan::create_buffer(void *data, const GFXSize size, const GFXBufferUsage usage) {
+GFXBuffer* GFXVulkan::create_buffer(void *data, const GFXSize size, const bool dynamic_data, const GFXBufferUsage usage) {
 	auto buffer = new GFXVulkanBuffer();
 
 	vkDeviceWaitIdle(device);

engine/gfx/webgpu/include/gfx_webgpu.hpp

@@ -15,7 +15,7 @@ public:
     bool supports_feature(GFXFeature feature) override;
 
     // buffer
-    GFXBuffer* create_buffer(void* data, GFXSize size, GFXBufferUsage usage) override;
+    GFXBuffer* create_buffer(void* data, GFXSize size, bool is_dynamic, GFXBufferUsage usage) override;
     void copy_buffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) override;
 
     void* get_buffer_contents(GFXBuffer* buffer) override;

engine/gfx/webgpu/src/gfx_webgpu.cpp

@@ -186,23 +186,13 @@ const char* GFXWebGPU::get_name() {
     return "WebGPU";
 }
 
-GFXCommandBuffer* presentation_command_buffer = nullptr;
-
 GFXCommandBuffer* GFXWebGPU::acquire_command_buffer(bool for_presentation_use) {
-    if(for_presentation_use) {
+    return new GFXCommandBuffer();
-        if(presentation_command_buffer == nullptr)
-            presentation_command_buffer = new GFXCommandBuffer();
-
-        presentation_command_buffer->commands.clear();
-
-        return presentation_command_buffer;
-    } else {
-        return new GFXCommandBuffer();
-    }
 }
 
-GFXBuffer* GFXWebGPU::create_buffer(void* data, const GFXSize size, const GFXBufferUsage usage) {
+GFXBuffer* GFXWebGPU::create_buffer(void* data, const GFXSize size, const bool is_dynamic, const GFXBufferUsage usage) {
     auto buffer = new GFXWebGPUBuffer();
+
     buffer->size = size;
 
     WGPUBufferDescriptor desc = {};
@@ -222,13 +212,10 @@ GFXBuffer* GFXWebGPU::create_buffer(void* data, const GFXSize size, const GFXBuf
     }
 
     desc.usage |= WGPUBufferUsage_Uniform; // TODO: not currently exposed in gfx api
-    desc.usage |= WGPUBufferUsage_CopyDst;
 
     buffer->handle = wgpuDeviceCreateBuffer(device, &desc);
 
-    if(data != nullptr) {
+    wgpuQueueWriteBuffer(queue, buffer->handle, 0, data, size);
-        wgpuQueueWriteBuffer(queue, buffer->handle, 0, data, size);
-    }
 
     return buffer;
 }
@@ -247,21 +234,17 @@ void* GFXWebGPU::get_buffer_contents(GFXBuffer* buffer) {
 
 void GFXWebGPU::release_buffer_contents(GFXBuffer* buffer, void* handle) {
     auto wgpu_buffer = (GFXWebGPUBuffer*)buffer;
+
+    wgpuBufferUnmap(wgpu_buffer->handle);
 }
 
 GFXTexture* GFXWebGPU::create_texture(const GFXTextureCreateInfo& info) {
     auto texture = new GFXWebGPUTexture();
 
-    int array_length = info.array_length;
-    if (info.type == GFXTextureType::Cubemap)
-        array_length = 6;
-    else if (info.type == GFXTextureType::CubemapArray)
-        array_length *= 6;
-
     WGPUTextureDescriptor descriptor = {};
     descriptor.size.width = info.width;
     descriptor.size.height = info.height;
-    descriptor.size.depthOrArrayLayers = array_length;
+    descriptor.size.depthOrArrayLayers = info.array_length;
 
     descriptor.dimension = WGPUTextureDimension_2D;
 
@@ -277,13 +260,13 @@ GFXTexture* GFXWebGPU::create_texture(const GFXTextureCreateInfo& info) {
     if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::Sampled)
         descriptor.usage |= WGPUTextureUsage_TextureBinding;
 
-    if((info.usage & GFXTextureUsage::Attachment) == GFXTextureUsage::Attachment)
+    if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::Attachment)
         descriptor.usage |= WGPUTextureUsage_RenderAttachment;
 
-    if((info.usage & GFXTextureUsage::TransferDst) == GFXTextureUsage::TransferDst)
+    if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::TransferDst)
         descriptor.usage |= WGPUTextureUsage_CopyDst;
 
-    if((info.usage & GFXTextureUsage::TransferSrc) == GFXTextureUsage::TransferSrc)
+    if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::TransferSrc)
         descriptor.usage |= WGPUTextureUsage_CopySrc;
 
     if((info.usage & GFXTextureUsage::Storage) == GFXTextureUsage::Storage)
@@ -295,24 +278,10 @@ GFXTexture* GFXWebGPU::create_texture(const GFXTextureCreateInfo& info) {
     view_descriptor.label = info.label.data();
     view_descriptor.format = descriptor.format;
     view_descriptor.mipLevelCount = descriptor.mipLevelCount;
+    view_descriptor.dimension = WGPUTextureViewDimension_2D;
     view_descriptor.baseArrayLayer = 0;
     view_descriptor.aspect = WGPUTextureAspect_All;
-    view_descriptor.arrayLayerCount = array_length;
+    view_descriptor.arrayLayerCount = info.array_length;
-
-    switch(info.type) {
-        case GFXTextureType::Single2D:
-            view_descriptor.dimension = WGPUTextureViewDimension_2D;
-            break;
-        case GFXTextureType::Array2D:
-            view_descriptor.dimension = WGPUTextureViewDimension_2DArray;
-            break;
-        case GFXTextureType::Cubemap:
-            view_descriptor.dimension = WGPUTextureViewDimension_Cube;
-            break;
-        case GFXTextureType::CubemapArray:
-            view_descriptor.dimension = WGPUTextureViewDimension_CubeArray;
-            break;
-    }
 
     texture->view = wgpuTextureCreateView(texture->handle, &view_descriptor);
 
@@ -344,18 +313,12 @@ GFXSampler* GFXWebGPU::create_sampler(const GFXSamplerCreateInfo& info) {
 GFXFramebuffer* GFXWebGPU::create_framebuffer(const GFXFramebufferCreateInfo& info) {
     auto framebuffer = new GFXWebGPUFramebuffer();
 
-    for(auto attachment : info.attachments) {
-        framebuffer->attachments.push_back((GFXWebGPUTexture*)attachment);
-    }
-
     return framebuffer;
 }
 
 GFXRenderPass* GFXWebGPU::create_render_pass(const GFXRenderPassCreateInfo& info) {
     auto render_pass = new GFXWebGPURenderPass();
 
-    render_pass->attachments = info.attachments;
-
     return render_pass;
 }
 
@@ -384,8 +347,6 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate
         }
     }
 
-    std::vector<WGPUColorTargetState> color_targets;
-
     WGPUFragmentState fragment = {};
     fragment.entryPoint = "main";
 
@@ -393,27 +354,6 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate
     if (has_fragment_stage) {
         descriptor.fragment = &fragment;
 
-        if(info.render_pass == nullptr) {
-            // swapchain image
-            WGPUColorTargetState target_state = {};
-            target_state.format = WGPUTextureFormat_BGRA8Unorm;
-            target_state.writeMask = WGPUColorWriteMask_All;
-
-            color_targets.push_back(target_state);
-
-            prism::log("is using swapchain image :-)");
-        } else {
-            for(auto attachment : ((GFXWebGPURenderPass*)info.render_pass)->attachments) {
-                if(attachment != GFXPixelFormat::DEPTH_32F) {
-                    WGPUColorTargetState target_state = {};
-                    target_state.format = toPixFormat(attachment);
-                    target_state.writeMask = WGPUColorWriteMask_All;
-
-                    color_targets.push_back(target_state);
-                }
-            }
-        }
-
         const bool fragment_use_shader_source = !info.shaders.fragment_src.is_path();
 
         if (fragment_use_shader_source) {
@@ -429,9 +369,6 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate
         }
     }
 
-    fragment.targetCount = color_targets.size();
-    fragment.targets = color_targets.data();
-
     descriptor.vertex.entryPoint = "main";
 
     prism::log("building pipeline {}", info.label);
@@ -502,24 +439,15 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate
     // create bind group layout
     std::vector<WGPUBindGroupLayoutEntry> group_entries = {};
     for (auto& binding : info.shader_input.bindings) {
+        // ignore push constants
+        if (binding.type == GFXBindingType::PushConstant)
+            continue;
+
         WGPUBindGroupLayoutEntry entry = {};
         entry.binding = binding.binding;
         entry.visibility = WGPUShaderStage_Vertex | WGPUShaderStage_Fragment;
 
         switch (binding.type) {
-        case GFXBindingType::PushConstant:
-        {
-            prism::log("Note: enabling push constant emulation for pipeline {}", info.label);
-
-            pipeline->push_constant_emulation_buffer = (GFXWebGPUBuffer*)create_buffer(nullptr,
-                                                                                       pipeline->push_constant_emulation_size,
-                                                                                       GFXBufferUsage::Storage);
-
-            pipeline->push_constant_emulation_buffer_index = binding.binding;
-
-            entry.buffer.type = WGPUBufferBindingType_Uniform;
-        }
-            break;
 		case GFXBindingType::StorageBuffer:
         {
             entry.buffer.type = WGPUBufferBindingType_Uniform;
@@ -532,11 +460,11 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate
 			break;
 		case GFXBindingType::SampledImage:
 		{
-            entry.texture.viewDimension = WGPUTextureViewDimension_2D;
+            entry.texture.sampleType = WGPUTextureSampleType_Force32;
 		}
 		    break;
 		case GFXBindingType::Sampler: {
-            entry.sampler.type = WGPUSamplerBindingType_Filtering;
+            entry.sampler.type = WGPUSamplerBindingType_Comparison;
         }
 			break;
 		}
@@ -550,17 +478,9 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate
     bind_group_layout_descriptor.entryCount = group_entries.size();
     bind_group_layout_descriptor.entries = group_entries.data();
 
-    auto layout = wgpuDeviceCreateBindGroupLayout(device, &bind_group_layout_descriptor);
+    pipeline->bind_group_layout = wgpuDeviceCreateBindGroupLayout(device, &bind_group_layout_descriptor);
-
-    WGPUPipelineLayoutDescriptor pipeline_layout_descriptor = {};
-    pipeline_layout_descriptor.label = pipeline->label.c_str();
-    pipeline_layout_descriptor.bindGroupLayoutCount = 1;
-    pipeline_layout_descriptor.bindGroupLayouts = &layout;
-
-    pipeline->layout =  wgpuDeviceCreatePipelineLayout(device, &pipeline_layout_descriptor);
 
     pipeline->render_handle = wgpuDeviceCreateRenderPipeline(device, &descriptor);
-    pipeline->bind_group_layout = wgpuRenderPipelineGetBindGroupLayout(pipeline->render_handle, 0);
 
     return pipeline;
 }
@@ -598,9 +518,7 @@ GFXPipeline* GFXWebGPU::create_compute_pipeline(const GFXComputePipelineCreateIn
 }
 
 void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_ptr window) {
-    WGPUTextureView backBufView = nullptr;
+    WGPUTextureView backBufView = wgpuSwapChainGetCurrentTextureView(swapchain);
-    if(window != nullptr)
-        backBufView = wgpuSwapChainGetCurrentTextureView(swapchain);
 
     WGPUCommandEncoder command_encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
 
@@ -743,8 +661,6 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_
 
                 if(current_encoder == CurrentEncoder::Render)
                     wgpuRenderPassEncoderEndPass(render_encoder);
-
-                render_encoder = nullptr;
             }
             case GFXCommandType::SetGraphicsPipeline:
             {
@@ -814,30 +730,8 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_
                 boundSamplers[command.data.bind_sampler.index] = command.data.bind_sampler.sampler;
             }
                 break;
-            case GFXCommandType::SetPushConstant:
-            {
-                need_encoder(CurrentEncoder::Render);
-
-                if(current_pipeline != nullptr) {
-                    uint32_t offset = current_pipeline->current_push_constant_offset;
-
-                    wgpuQueueWriteBuffer(queue, current_pipeline->push_constant_emulation_buffer->handle, offset, command.data.set_push_constant.bytes.data(), command.data.set_push_constant.bytes.size());
-
-                    current_pipeline->current_push_constant_offset += 128;
-
-                    BoundShaderBuffer bsb;
-                    bsb.buffer = current_pipeline->push_constant_emulation_buffer;
-                    bsb.offset = offset;
-                    bsb.size = command.data.set_push_constant.size;
-
-                    boundShaderBuffers[current_pipeline->push_constant_emulation_buffer_index] = bsb;
-                }
-            }
-                break;
             case GFXCommandType::Draw:
             {
-                need_encoder(CurrentEncoder::Render);
-
                 if(current_pipeline == nullptr)
                     continue;
 
@@ -852,8 +746,6 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_
                 break;
             case GFXCommandType::DrawIndexed:
             {
-                need_encoder(CurrentEncoder::Render);
-
                 if(current_pipeline == nullptr)
                     continue;
 
@@ -955,9 +847,7 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_
     wgpuQueueSubmit(queue, 1, &commands);
     wgpuCommandBufferRelease(commands);
 
-    if(window != nullptr) {
+    wgpuTextureViewRelease(backBufView);
-        wgpuTextureViewRelease(backBufView);
-    }
 }
 
 uint64_t GFXWebGPU::get_bind_group_hash(GFXWebGPUPipeline *pipeline) {

engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp

@@ -11,13 +11,7 @@ public:
     WGPURenderPipeline render_handle = nullptr;
     WGPUComputePipeline compute_handle = nullptr;
 
-    WGPUPipelineLayout layout = nullptr;
     WGPUBindGroupLayout bind_group_layout = nullptr;
 
     std::map<uint64_t, WGPUBindGroup> cached_bind_groups;
-
-    int push_constant_emulation_buffer_index = -1;
-    GFXWebGPUBuffer* push_constant_emulation_buffer = nullptr;
-    size_t push_constant_emulation_size = 1000000; // 1 mb
-    size_t current_push_constant_offset = 0;
 };

engine/gfx/webgpu/src/gfx_webgpu_renderpass.hpp

@@ -4,5 +4,5 @@
 
 class GFXWebGPURenderPass : public GFXRenderPass {
 public:
-    std::vector<GFXPixelFormat> attachments;
+
 };

engine/renderer/src/imguipass.cpp

@@ -203,12 +203,12 @@ void ImGuiPass::update_buffers(RenderTarget& target, const ImDrawData& draw_data
     Expects(new_index_size > 0);
     
     if(target.vertex_buffer[target.current_frame] == nullptr || target.current_vertex_size[target.current_frame] < new_vertex_size) {
-        target.vertex_buffer[target.current_frame] = engine->get_gfx()->create_buffer(nullptr, new_vertex_size, GFXBufferUsage::Vertex);
+        target.vertex_buffer[target.current_frame] = engine->get_gfx()->create_buffer(nullptr, new_vertex_size, true, GFXBufferUsage::Vertex);
         target.current_vertex_size[target.current_frame] = new_vertex_size;
     }
     
     if(target.index_buffer[target.current_frame] == nullptr || target.current_index_size[target.current_frame] < new_index_size) {
-        target.index_buffer[target.current_frame] = engine->get_gfx()->create_buffer(nullptr, new_index_size, GFXBufferUsage::Index);
+        target.index_buffer[target.current_frame] = engine->get_gfx()->create_buffer(nullptr, new_index_size, true, GFXBufferUsage::Index);
         target.current_index_size[target.current_frame] = new_index_size;
     }
 

engine/renderer/src/renderer.cpp

@@ -558,7 +558,7 @@ void renderer::create_render_target_resources(RenderTarget& target) {
     textureInfo.width = extent.width;
     textureInfo.height = extent.height;
     textureInfo.format = GFXPixelFormat::RGBA_32F;
-    textureInfo.usage = GFXTextureUsage::Attachment | GFXTextureUsage::Sampled;
+    textureInfo.usage = GFXTextureUsage::Attachment | GFXTextureUsage::Sampled | GFXTextureUsage::Storage;
 
     target.offscreenColorTexture = gfx->create_texture(textureInfo);
 
@@ -579,7 +579,7 @@ void renderer::create_render_target_resources(RenderTarget& target) {
         create_post_pipelines();
     }
     
-    target.sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), GFXBufferUsage::Storage);
+    target.sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), true, GFXBufferUsage::Storage);
 }
 
 void renderer::create_post_pipelines() {
@@ -590,7 +590,7 @@ void renderer::create_post_pipelines() {
     pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("post.frag"));
     
     pipelineInfo.shader_input.bindings = {
-        {0, GFXBindingType::PushConstant},
+        {4, GFXBindingType::PushConstant},
         {1, GFXBindingType::SampledImage},
         {2, GFXBindingType::SampledImage},
         {3, GFXBindingType::SampledImage},
@@ -718,7 +718,7 @@ void renderer::create_histogram_resources() {
     
     histogram_average_pipeline = gfx->create_compute_pipeline(create_info);
 
-    histogram_buffer = gfx->create_buffer(nullptr, sizeof(uint32_t) * 256, GFXBufferUsage::Storage);
+    histogram_buffer = gfx->create_buffer(nullptr, sizeof(uint32_t) * 256, false, GFXBufferUsage::Storage);
     
     GFXTextureCreateInfo texture_info = {};
     texture_info.label = "Average Luminance Store";

engine/renderer/src/scenecapture.cpp

@@ -113,7 +113,7 @@ SceneCapture::SceneCapture(GFX* gfx) {
     
     environmentCube = gfx->create_texture(cubeTextureInfo);
     
-    sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), GFXBufferUsage::Storage);
+    sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), true, GFXBufferUsage::Storage);
     
     createSkyResources();
     createIrradianceResources();

engine/renderer/src/shadowpass.cpp

@@ -409,6 +409,6 @@ void ShadowPass::create_offscreen_resources() {
     
     offscreen_framebuffer = gfx->create_framebuffer(info);
 
-    point_location_buffer = gfx->create_buffer(nullptr, sizeof(prism::float4) * max_point_shadows, GFXBufferUsage::Storage);
+    point_location_buffer = gfx->create_buffer(nullptr, sizeof(prism::float4) * max_point_shadows, false, GFXBufferUsage::Storage);
     point_location_map = reinterpret_cast<prism::float4*>(gfx->get_buffer_contents(point_location_buffer));
 }

engine/shadercompiler/src/shadercompiler.cpp

@@ -38,7 +38,7 @@ std::vector<uint32_t> compile_glsl_to_spv(const std::string_view source_string,
 
         // alright, so to make webgpu happy we are going to hand-waive all of our push constant blocks
         // away into UBOs. let's start by rewriting our GLSL. yay...
-        newString = replace_substring(newString, "push_constant", "binding = 0");
+        newString = replace_substring(newString, "push_constant", "binding = 10");
     }
 
     const char* InputCString = newString.c_str();

example/data/render_options.cfg

@@ -1,2 +1 @@
-rs_aa false
+rs_aa false
-rs_ibl false