redstrate/prism
Archived
1
Fork 0
Code Activity

Revert "Next big changes to make WebGPU work"

Browse source 
This reverts commit 0a95ee2fa8.
This commit is contained in:
Joshua Goins 2022-03-10 10:20:50 -05:00
parent d219f0c85b
commit 71d0eff8dc
14 changed files with 44 additions and 168 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
engine/asset/src/asset.cpp
View file

@ -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,16 +78,16 @@ 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);

15
engine/gfx/public/gfx.hpp
View file

@ -57,19 +57,11 @@ inline GFXTextureUsage operator&(const GFXTextureUsage a, const GFXTextureUsage
}
enum class GFXBufferUsage : int {
Storage = 0,
Vertex = 1,
Index = 2
Storage,
Vertex,
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,

2
engine/gfx/vulkan/include/gfx_vulkan.hpp
View file

@ -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;

2
engine/gfx/vulkan/src/gfx_vulkan.cpp
View file

@ -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);

2
engine/gfx/webgpu/include/gfx_webgpu.hpp
View file

@ -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;

146
engine/gfx/webgpu/src/gfx_webgpu.cpp
View file

@ -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) {
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);
}
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;
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;
}
view_descriptor.arrayLayerCount = info.array_length;
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);
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->bind_group_layout = wgpuDeviceCreateBindGroupLayout(device, &bind_group_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;
if(window != nullptr)
backBufView = wgpuSwapChainGetCurrentTextureView(swapchain);
WGPUTextureView 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,10 +847,8 @@ void GFXWebGPU::submit(GFXCommandBuffer* command_buffer, const platform::window_
wgpuQueueSubmit(queue, 1, &commands);
wgpuCommandBufferRelease(commands);
if(window != nullptr) {
wgpuTextureViewRelease(backBufView);
}
}
uint64_t GFXWebGPU::get_bind_group_hash(GFXWebGPUPipeline *pipeline) {
uint64_t hash = 0;

6
engine/gfx/webgpu/src/gfx_webgpu_pipeline.hpp
View file

@ -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;
};

2
engine/gfx/webgpu/src/gfx_webgpu_renderpass.hpp
View file

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

4
engine/renderer/src/imguipass.cpp
View file

@ -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;
}

8
engine/renderer/src/renderer.cpp
View file

@ -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";

2
engine/renderer/src/scenecapture.cpp
View file

@ -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();

2
engine/renderer/src/shadowpass.cpp
View file

@ -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));
}

2
engine/shadercompiler/src/shadercompiler.cpp
View file

@ -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();

1
example/data/render_options.cfg
View file

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