From 0a95ee2fa8fbf23ba8b3a17c78d6d3dc35ecfcd9 Mon Sep 17 00:00:00 2001 From: Joshua Goins Date: Mon, 7 Mar 2022 11:11:17 -0500 Subject: [PATCH] Next big changes to make WebGPU work Dynamic buffers are removed, since that's now the renderer's job. Texture usage and buffer usage has changed too. --- engine/asset/src/asset.cpp | 10 +- engine/gfx/public/gfx.hpp | 15 +- engine/gfx/vulkan/include/gfx_vulkan.hpp | 2 +- engine/gfx/vulkan/src/gfx_vulkan.cpp | 2 +- engine/gfx/webgpu/include/gfx_webgpu.hpp | 2 +- engine/gfx/webgpu/src/gfx_webgpu.cpp | 152 +++++++++++++++--- engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp | 6 + .../gfx/webgpu/src/gfx_webgpu_renderpass.hpp | 2 +- engine/renderer/src/imguipass.cpp | 4 +- engine/renderer/src/renderer.cpp | 8 +- engine/renderer/src/scenecapture.cpp | 2 +- engine/renderer/src/shadowpass.cpp | 2 +- engine/shadercompiler/src/shadercompiler.cpp | 2 +- example/data/render_options.cfg | 3 +- 14 files changed, 168 insertions(+), 44 deletions(-) diff --git a/engine/asset/src/asset.cpp b/engine/asset/src/asset.cpp index 207514c..270b41b 100644 --- a/engine/asset/src/asset.cpp +++ b/engine/asset/src/asset.cpp @@ -50,7 +50,7 @@ std::unique_ptr 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(numVertices), false, GFXBufferUsage::Vertex); + auto buffer = engine->get_gfx()->create_buffer(nullptr, size * static_cast(numVertices), GFXBufferUsage::Vertex); auto buffer_ptr = reinterpret_cast(engine->get_gfx()->get_buffer_contents(buffer)); if(buffer_ptr != nullptr) { f.read(buffer_ptr, size * static_cast(numVertices)); @@ -78,15 +78,15 @@ std::unique_ptr load_mesh(const prism::path& path) { Expects(numIndices > 0); - mesh->index_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(uint32_t) * numIndices, false, GFXBufferUsage::Index); + mesh->index_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(uint32_t) * numIndices, GFXBufferUsage::Index); auto index_ptr = reinterpret_cast(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 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, true, GFXBufferUsage::Storage); + p.bone_batrix_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(Matrix4x4) * 128, GFXBufferUsage::Storage); if(numBones > 0) { p.offset_matrices.resize(numBones); diff --git a/engine/gfx/public/gfx.hpp b/engine/gfx/public/gfx.hpp index 180d972..f274749 100755 --- a/engine/gfx/public/gfx.hpp +++ b/engine/gfx/public/gfx.hpp @@ -57,11 +57,19 @@ inline GFXTextureUsage operator&(const GFXTextureUsage a, const GFXTextureUsage } enum class GFXBufferUsage : int { - Storage, - Vertex, - Index + Storage = 0, + Vertex = 1, + Index = 2 }; +inline GFXBufferUsage operator|(const GFXBufferUsage a, const GFXBufferUsage b) { + return static_cast(static_cast(a) | static_cast(b)); +} + +inline GFXBufferUsage operator&(const GFXBufferUsage a, const GFXBufferUsage b) { + return static_cast(static_cast(a) & static_cast(b)); +} + enum class GFXBlendFactor : int { One, Zero, @@ -309,7 +317,6 @@ 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, diff --git a/engine/gfx/vulkan/include/gfx_vulkan.hpp b/engine/gfx/vulkan/include/gfx_vulkan.hpp index a675930..8b5e47a 100755 --- a/engine/gfx/vulkan/include/gfx_vulkan.hpp +++ b/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, bool dynamic_data, GFXBufferUsage usage) override; + GFXBuffer* create_buffer(void* data, GFXSize size, GFXBufferUsage usage) override; void copy_buffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) override; void* get_buffer_contents(GFXBuffer* buffer) override; diff --git a/engine/gfx/vulkan/src/gfx_vulkan.cpp b/engine/gfx/vulkan/src/gfx_vulkan.cpp index 8d1dfb0..8886f42 100755 --- a/engine/gfx/vulkan/src/gfx_vulkan.cpp +++ b/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 bool dynamic_data, const GFXBufferUsage usage) { +GFXBuffer* GFXVulkan::create_buffer(void *data, const GFXSize size, const GFXBufferUsage usage) { auto buffer = new GFXVulkanBuffer(); vkDeviceWaitIdle(device); diff --git a/engine/gfx/webgpu/include/gfx_webgpu.hpp b/engine/gfx/webgpu/include/gfx_webgpu.hpp index 50eace7..2b06487 100755 --- a/engine/gfx/webgpu/include/gfx_webgpu.hpp +++ b/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, bool is_dynamic, GFXBufferUsage usage) override; + GFXBuffer* create_buffer(void* data, GFXSize size, GFXBufferUsage usage) override; void copy_buffer(GFXBuffer* buffer, void* data, GFXSize offset, GFXSize size) override; void* get_buffer_contents(GFXBuffer* buffer) override; diff --git a/engine/gfx/webgpu/src/gfx_webgpu.cpp b/engine/gfx/webgpu/src/gfx_webgpu.cpp index 7a17226..9eee9cb 100755 --- a/engine/gfx/webgpu/src/gfx_webgpu.cpp +++ b/engine/gfx/webgpu/src/gfx_webgpu.cpp @@ -186,13 +186,23 @@ const char* GFXWebGPU::get_name() { return "WebGPU"; } +GFXCommandBuffer* presentation_command_buffer = nullptr; + GFXCommandBuffer* GFXWebGPU::acquire_command_buffer(bool for_presentation_use) { - return new GFXCommandBuffer(); + if(for_presentation_use) { + 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 bool is_dynamic, const GFXBufferUsage usage) { +GFXBuffer* GFXWebGPU::create_buffer(void* data, const GFXSize size, const GFXBufferUsage usage) { auto buffer = new GFXWebGPUBuffer(); - buffer->size = size; WGPUBufferDescriptor desc = {}; @@ -212,10 +222,13 @@ GFXBuffer* GFXWebGPU::create_buffer(void* data, const GFXSize size, const bool i } desc.usage |= WGPUBufferUsage_Uniform; // TODO: not currently exposed in gfx api + desc.usage |= WGPUBufferUsage_CopyDst; buffer->handle = wgpuDeviceCreateBuffer(device, &desc); - wgpuQueueWriteBuffer(queue, buffer->handle, 0, data, size); + if(data != nullptr) { + wgpuQueueWriteBuffer(queue, buffer->handle, 0, data, size); + } return buffer; } @@ -234,17 +247,21 @@ 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 = info.array_length; + descriptor.size.depthOrArrayLayers = array_length; descriptor.dimension = WGPUTextureDimension_2D; @@ -260,13 +277,13 @@ GFXTexture* GFXWebGPU::create_texture(const GFXTextureCreateInfo& info) { if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::Sampled) descriptor.usage |= WGPUTextureUsage_TextureBinding; - if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::Attachment) + if((info.usage & GFXTextureUsage::Attachment) == GFXTextureUsage::Attachment) descriptor.usage |= WGPUTextureUsage_RenderAttachment; - if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::TransferDst) + if((info.usage & GFXTextureUsage::TransferDst) == GFXTextureUsage::TransferDst) descriptor.usage |= WGPUTextureUsage_CopyDst; - if((info.usage & GFXTextureUsage::Sampled) == GFXTextureUsage::TransferSrc) + if((info.usage & GFXTextureUsage::TransferSrc) == GFXTextureUsage::TransferSrc) descriptor.usage |= WGPUTextureUsage_CopySrc; if((info.usage & GFXTextureUsage::Storage) == GFXTextureUsage::Storage) @@ -278,10 +295,24 @@ 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 = info.array_length; + view_descriptor.arrayLayerCount = 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); @@ -313,12 +344,18 @@ 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; } @@ -347,6 +384,8 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate } } + std::vector color_targets; + WGPUFragmentState fragment = {}; fragment.entryPoint = "main"; @@ -354,6 +393,27 @@ 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) { @@ -369,6 +429,9 @@ 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); @@ -439,15 +502,24 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate // create bind group layout std::vector 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; @@ -460,11 +532,11 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate break; case GFXBindingType::SampledImage: { - entry.texture.sampleType = WGPUTextureSampleType_Force32; + entry.texture.viewDimension = WGPUTextureViewDimension_2D; } break; case GFXBindingType::Sampler: { - entry.sampler.type = WGPUSamplerBindingType_Comparison; + entry.sampler.type = WGPUSamplerBindingType_Filtering; } break; } @@ -478,9 +550,17 @@ GFXPipeline* GFXWebGPU::create_graphics_pipeline(const GFXGraphicsPipelineCreate bind_group_layout_descriptor.entryCount = group_entries.size(); bind_group_layout_descriptor.entries = group_entries.data(); - pipeline->bind_group_layout = wgpuDeviceCreateBindGroupLayout(device, &bind_group_layout_descriptor); + auto 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; } @@ -518,7 +598,9 @@ GFXPipeline* GFXWebGPU::create_compute_pipeline(const GFXComputePipelineCreateIn } void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_ptr window) { - WGPUTextureView backBufView = wgpuSwapChainGetCurrentTextureView(swapchain); + WGPUTextureView backBufView = nullptr; + if(window != nullptr) + backBufView = wgpuSwapChainGetCurrentTextureView(swapchain); WGPUCommandEncoder command_encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); @@ -661,6 +743,8 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_ if(current_encoder == CurrentEncoder::Render) wgpuRenderPassEncoderEndPass(render_encoder); + + render_encoder = nullptr; } case GFXCommandType::SetGraphicsPipeline: { @@ -730,8 +814,30 @@ 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; @@ -746,6 +852,8 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_ break; case GFXCommandType::DrawIndexed: { + need_encoder(CurrentEncoder::Render); + if(current_pipeline == nullptr) continue; @@ -847,7 +955,9 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_ wgpuQueueSubmit(queue, 1, &commands); wgpuCommandBufferRelease(commands); - wgpuTextureViewRelease(backBufView); + if(window != nullptr) { + wgpuTextureViewRelease(backBufView); + } } uint64_t GFXWebGPU::get_bind_group_hash(GFXWebGPUPipeline *pipeline) { diff --git a/engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp b/engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp index 80d6c38..7a7cd3e 100644 --- a/engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp +++ b/engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp @@ -11,7 +11,13 @@ public: WGPURenderPipeline render_handle = nullptr; WGPUComputePipeline compute_handle = nullptr; + WGPUPipelineLayout layout = nullptr; WGPUBindGroupLayout bind_group_layout = nullptr; std::map 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; }; diff --git a/engine/gfx/webgpu/src/gfx_webgpu_renderpass.hpp b/engine/gfx/webgpu/src/gfx_webgpu_renderpass.hpp index fb9c7e5..41df913 100644 --- a/engine/gfx/webgpu/src/gfx_webgpu_renderpass.hpp +++ b/engine/gfx/webgpu/src/gfx_webgpu_renderpass.hpp @@ -4,5 +4,5 @@ class GFXWebGPURenderPass : public GFXRenderPass { public: - + std::vector attachments; }; diff --git a/engine/renderer/src/imguipass.cpp b/engine/renderer/src/imguipass.cpp index 8eba875..ab0432c 100755 --- a/engine/renderer/src/imguipass.cpp +++ b/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, true, GFXBufferUsage::Vertex); + target.vertex_buffer[target.current_frame] = engine->get_gfx()->create_buffer(nullptr, new_vertex_size, 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, true, GFXBufferUsage::Index); + target.index_buffer[target.current_frame] = engine->get_gfx()->create_buffer(nullptr, new_index_size, GFXBufferUsage::Index); target.current_index_size[target.current_frame] = new_index_size; } diff --git a/engine/renderer/src/renderer.cpp b/engine/renderer/src/renderer.cpp index bb306c4..b9e8e5d 100755 --- a/engine/renderer/src/renderer.cpp +++ b/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 | GFXTextureUsage::Storage; + textureInfo.usage = GFXTextureUsage::Attachment | GFXTextureUsage::Sampled; 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), true, GFXBufferUsage::Storage); + target.sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), 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 = { - {4, GFXBindingType::PushConstant}, + {0, 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, false, GFXBufferUsage::Storage); + histogram_buffer = gfx->create_buffer(nullptr, sizeof(uint32_t) * 256, GFXBufferUsage::Storage); GFXTextureCreateInfo texture_info = {}; texture_info.label = "Average Luminance Store"; diff --git a/engine/renderer/src/scenecapture.cpp b/engine/renderer/src/scenecapture.cpp index f145753..cda63f4 100755 --- a/engine/renderer/src/scenecapture.cpp +++ b/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), true, GFXBufferUsage::Storage); + sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), GFXBufferUsage::Storage); createSkyResources(); createIrradianceResources(); diff --git a/engine/renderer/src/shadowpass.cpp b/engine/renderer/src/shadowpass.cpp index ee9f6da..1dc2cf0 100755 --- a/engine/renderer/src/shadowpass.cpp +++ b/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, false, GFXBufferUsage::Storage); + point_location_buffer = gfx->create_buffer(nullptr, sizeof(prism::float4) * max_point_shadows, GFXBufferUsage::Storage); point_location_map = reinterpret_cast(gfx->get_buffer_contents(point_location_buffer)); } diff --git a/engine/shadercompiler/src/shadercompiler.cpp b/engine/shadercompiler/src/shadercompiler.cpp index 7cf69fe..4cf4ee6 100755 --- a/engine/shadercompiler/src/shadercompiler.cpp +++ b/engine/shadercompiler/src/shadercompiler.cpp @@ -38,7 +38,7 @@ std::vector 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 = 10"); + newString = replace_substring(newString, "push_constant", "binding = 0"); } const char* InputCString = newString.c_str(); diff --git a/example/data/render_options.cfg b/example/data/render_options.cfg index 6c78d4d..1e01c87 100644 --- a/example/data/render_options.cfg +++ b/example/data/render_options.cfg @@ -1 +1,2 @@ -rs_aa false \ No newline at end of file +rs_aa false +rs_ibl false \ No newline at end of file