From 639cae10e85d86c761e5d012d4ebe45fe2fb1951 Mon Sep 17 00:00:00 2001 From: luboslenco Date: Fri, 18 Apr 2025 13:51:24 +0200 Subject: [PATCH] Merge constant buffers --- base/sources/backends/direct3d12_gpu.c | 48 +---- base/sources/backends/direct3d12_gpu.h | 1 - base/sources/backends/metal_gpu.h | 1 - base/sources/backends/metal_gpu.m | 11 +- base/sources/backends/vulkan_gpu.c | 12 -- base/sources/backends/vulkan_gpu.h | 3 - base/sources/backends/webgpu_gpu.c | 5 - base/sources/backends/webgpu_gpu.h | 1 - base/sources/iron.h | 3 +- base/sources/iron_draw.c | 3 - base/sources/iron_gpu.c | 274 +++++++------------------ base/sources/iron_gpu.h | 5 - base/sources/ts/import_envmap.ts | 3 +- base/sources/ts/iron/shader_data.ts | 3 - base/sources/ts/pipes.ts | 1 - 15 files changed, 80 insertions(+), 294 deletions(-) diff --git a/base/sources/backends/direct3d12_gpu.c b/base/sources/backends/direct3d12_gpu.c index 3edb2fc7..cfd5871f 100644 --- a/base/sources/backends/direct3d12_gpu.c +++ b/base/sources/backends/direct3d12_gpu.c @@ -272,7 +272,7 @@ static void create_root_signature() { ID3DBlob *rootBlob; ID3DBlob *errorBlob; - D3D12_ROOT_PARAMETER parameters[4] = {}; + D3D12_ROOT_PARAMETER parameters[3] = {}; D3D12_DESCRIPTOR_RANGE range = { .RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV, @@ -299,49 +299,12 @@ static void create_root_signature() { parameters[1].DescriptorTable.pDescriptorRanges = &range2; parameters[2].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; - parameters[2].ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX; + parameters[2].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; parameters[2].Descriptor.ShaderRegister = 0; parameters[2].Descriptor.RegisterSpace = 0; - parameters[3].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; - parameters[3].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; - parameters[3].Descriptor.ShaderRegister = 0; - parameters[3].Descriptor.RegisterSpace = 0; - - D3D12_STATIC_SAMPLER_DESC samplers[IRON_INTERNAL_G5_TEXTURE_COUNT * 2]; - for (int i = 0; i < IRON_INTERNAL_G5_TEXTURE_COUNT; ++i) { - samplers[i].ShaderRegister = i; - samplers[i].Filter = D3D12_FILTER_MIN_MAG_MIP_POINT; - samplers[i].AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - samplers[i].AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - samplers[i].AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - samplers[i].MipLODBias = 0; - samplers[i].MaxAnisotropy = 16; - samplers[i].ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; - samplers[i].BorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE; - samplers[i].MinLOD = 0.0f; - samplers[i].MaxLOD = D3D12_FLOAT32_MAX; - samplers[i].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; - samplers[i].RegisterSpace = 0; - } - for (int i = IRON_INTERNAL_G5_TEXTURE_COUNT; i < IRON_INTERNAL_G5_TEXTURE_COUNT * 2; ++i) { - samplers[i].ShaderRegister = i; - samplers[i].Filter = D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT; - samplers[i].AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - samplers[i].AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - samplers[i].AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; - samplers[i].MipLODBias = 0; - samplers[i].MaxAnisotropy = 16; - samplers[i].ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; - samplers[i].BorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE; - samplers[i].MinLOD = 0.0f; - samplers[i].MaxLOD = D3D12_FLOAT32_MAX; - samplers[i].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; - samplers[i].RegisterSpace = 0; - } - D3D12_ROOT_SIGNATURE_DESC descRootSignature = { - .NumParameters = 4, + .NumParameters = 3, .pParameters = parameters, .NumStaticSamplers = 0, .pStaticSamplers = NULL, @@ -614,10 +577,6 @@ void iron_gpu_command_list_set_vertex_constant_buffer(struct iron_gpu_command_li list->impl._commandList->lpVtbl->SetGraphicsRootConstantBufferView(list->impl._commandList, 2, buffer->impl.constant_buffer->lpVtbl->GetGPUVirtualAddress(buffer->impl.constant_buffer) + offset); } -void iron_gpu_command_list_set_fragment_constant_buffer(struct iron_gpu_command_list *list, iron_gpu_buffer_t *buffer, int offset, size_t size) { - list->impl._commandList->lpVtbl->SetGraphicsRootConstantBufferView(list->impl._commandList, 3, buffer->impl.constant_buffer->lpVtbl->GetGPUVirtualAddress(buffer->impl.constant_buffer) + offset); -} - void iron_gpu_command_list_draw_indexed_vertices(struct iron_gpu_command_list *list) { iron_gpu_command_list_draw_indexed_vertices_from_to(list, 0, list->impl._indexCount); } @@ -984,7 +943,6 @@ void iron_gpu_command_list_set_texture_from_render_target_depth(iron_gpu_command } void iron_gpu_pipeline_init(iron_gpu_pipeline_t *pipe) { - iron_gpu_internal_pipeline_set_defaults(pipe); iron_gpu_internal_pipeline_init(pipe); } diff --git a/base/sources/backends/direct3d12_gpu.h b/base/sources/backends/direct3d12_gpu.h index 6787de3e..fc8374ab 100644 --- a/base/sources/backends/direct3d12_gpu.h +++ b/base/sources/backends/direct3d12_gpu.h @@ -82,7 +82,6 @@ typedef struct { typedef struct { int vertexOffset; - int fragmentOffset; } gpu_constant_location_impl_t; typedef struct iron_gpu_sampler_impl { diff --git a/base/sources/backends/metal_gpu.h b/base/sources/backends/metal_gpu.h index 65cb0bc2..4022c8a6 100644 --- a/base/sources/backends/metal_gpu.h +++ b/base/sources/backends/metal_gpu.h @@ -23,7 +23,6 @@ typedef struct { typedef struct { int vertexOffset; - int fragmentOffset; } gpu_constant_location_impl_t; typedef struct iron_gpu_sampler_impl { diff --git a/base/sources/backends/metal_gpu.m b/base/sources/backends/metal_gpu.m index 39a1a8ad..990163d0 100644 --- a/base/sources/backends/metal_gpu.m +++ b/base/sources/backends/metal_gpu.m @@ -459,9 +459,7 @@ void iron_gpu_command_list_set_vertex_constant_buffer(iron_gpu_command_list_t *l id buf = (__bridge id)buffer->impl._buffer; id encoder = getMetalEncoder(); [encoder setVertexBuffer:buf offset:offset atIndex:1]; -} -void iron_gpu_command_list_set_fragment_constant_buffer(iron_gpu_command_list_t *list, struct iron_gpu_buffer *buffer, int offset, size_t size) { id buf = (__bridge id)buffer->impl._buffer; id encoder = getMetalEncoder(); [encoder setFragmentBuffer:buf offset:offset atIndex:1]; @@ -601,7 +599,7 @@ static MTLPixelFormat convert_render_target_format(iron_image_format_t format) { void iron_gpu_pipeline_init(iron_gpu_pipeline_t *pipeline) { memset(&pipeline->impl, 0, sizeof(pipeline->impl)); - iron_gpu_internal_pipeline_set_defaults(pipeline); + iron_gpu_internal_pipeline_init(pipeline); } void iron_gpu_pipeline_destroy(iron_gpu_pipeline_t *pipeline) { @@ -776,13 +774,8 @@ void iron_gpu_internal_pipeline_set(iron_gpu_pipeline_t *pipeline) { } iron_gpu_constant_location_t iron_gpu_pipeline_get_constant_location(iron_gpu_pipeline_t *pipeline, const char *name) { - if (strcmp(name, "bias") == 0) { - name = "bias0"; - } - iron_gpu_constant_location_t location; location.impl.vertexOffset = -1; - location.impl.fragmentOffset = -1; MTLRenderPipelineReflection *reflection = (__bridge MTLRenderPipelineReflection *)pipeline->impl._reflection; @@ -807,7 +800,7 @@ iron_gpu_constant_location_t iron_gpu_pipeline_get_constant_location(iron_gpu_pi MTLStructType *structObj = [arg bufferStructType]; for (MTLStructMember *member in structObj.members) { if (strcmp([[member name] UTF8String], name) == 0) { - location.impl.fragmentOffset = (int)[member offset]; + location.impl.vertexOffset = (int)[member offset]; break; } } diff --git a/base/sources/backends/vulkan_gpu.c b/base/sources/backends/vulkan_gpu.c index 53bd69d8..36cd4317 100644 --- a/base/sources/backends/vulkan_gpu.c +++ b/base/sources/backends/vulkan_gpu.c @@ -2014,9 +2014,6 @@ VkDescriptorSet get_descriptor_set() { void iron_gpu_command_list_set_vertex_constant_buffer(iron_gpu_command_list_t *list, struct iron_gpu_buffer *buffer, int offset, size_t size) { last_vertex_constant_buffer_offset = offset; -} - -void iron_gpu_command_list_set_fragment_constant_buffer(iron_gpu_command_list_t *list, struct iron_gpu_buffer *buffer, int offset, size_t size) { last_fragment_constant_buffer_offset = offset; VkDescriptorSet descriptor_set = get_descriptor_set(); @@ -2316,7 +2313,6 @@ static VkFormat convert_image_format(iron_image_format_t format) { void iron_gpu_pipeline_init(iron_gpu_pipeline_t *pipeline) { iron_gpu_internal_pipeline_init(pipeline); - iron_gpu_internal_pipeline_set_defaults(pipeline); } void iron_gpu_pipeline_destroy(iron_gpu_pipeline_t *pipeline) { @@ -2328,13 +2324,9 @@ void iron_gpu_pipeline_destroy(iron_gpu_pipeline_t *pipeline) { iron_gpu_constant_location_t iron_gpu_pipeline_get_constant_location(iron_gpu_pipeline_t *pipeline, const char *name) { iron_gpu_constant_location_t location; location.impl.vertexOffset = -1; - location.impl.fragmentOffset = -1; if (has_number(pipeline->impl.vertexOffsets, name)) { location.impl.vertexOffset = find_number(pipeline->impl.vertexOffsets, name); } - if (has_number(pipeline->impl.fragmentOffsets, name)) { - location.impl.fragmentOffset = find_number(pipeline->impl.fragmentOffsets, name); - } return location; } @@ -2439,14 +2431,10 @@ static VkBlendOp convert_blend_operation(iron_gpu_blending_operation_t op) { void iron_gpu_pipeline_compile(iron_gpu_pipeline_t *pipeline) { memset(pipeline->impl.vertexLocations, 0, sizeof(iron_internal_named_number) * IRON_INTERNAL_NAMED_NUMBER_COUNT); memset(pipeline->impl.vertexOffsets, 0, sizeof(iron_internal_named_number) * IRON_INTERNAL_NAMED_NUMBER_COUNT); - memset(pipeline->impl.fragmentLocations, 0, sizeof(iron_internal_named_number) * IRON_INTERNAL_NAMED_NUMBER_COUNT); - memset(pipeline->impl.fragmentOffsets, 0, sizeof(iron_internal_named_number) * IRON_INTERNAL_NAMED_NUMBER_COUNT); memset(pipeline->impl.vertexTextureBindings, 0, sizeof(iron_internal_named_number) * IRON_INTERNAL_NAMED_NUMBER_COUNT); memset(pipeline->impl.fragmentTextureBindings, 0, sizeof(iron_internal_named_number) * IRON_INTERNAL_NAMED_NUMBER_COUNT); parse_shader((uint32_t *)pipeline->vertex_shader->impl.source, pipeline->vertex_shader->impl.length, pipeline->impl.vertexLocations, pipeline->impl.vertexTextureBindings, pipeline->impl.vertexOffsets); - parse_shader((uint32_t *)pipeline->fragment_shader->impl.source, pipeline->fragment_shader->impl.length, pipeline->impl.fragmentLocations, - pipeline->impl.fragmentTextureBindings, pipeline->impl.fragmentOffsets); VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, diff --git a/base/sources/backends/vulkan_gpu.h b/base/sources/backends/vulkan_gpu.h index 363db677..d8122fa2 100644 --- a/base/sources/backends/vulkan_gpu.h +++ b/base/sources/backends/vulkan_gpu.h @@ -123,18 +123,15 @@ typedef struct gpu_pipeline_impl { VkShaderModule frag_shader_module; iron_internal_named_number vertexLocations[IRON_INTERNAL_NAMED_NUMBER_COUNT]; - iron_internal_named_number fragmentLocations[IRON_INTERNAL_NAMED_NUMBER_COUNT]; iron_internal_named_number vertexTextureBindings[IRON_INTERNAL_NAMED_NUMBER_COUNT]; iron_internal_named_number fragmentTextureBindings[IRON_INTERNAL_NAMED_NUMBER_COUNT]; iron_internal_named_number vertexOffsets[IRON_INTERNAL_NAMED_NUMBER_COUNT]; - iron_internal_named_number fragmentOffsets[IRON_INTERNAL_NAMED_NUMBER_COUNT]; VkPipelineLayout pipeline_layout; } gpu_pipeline_impl_t; typedef struct { int vertexOffset; - int fragmentOffset; } gpu_constant_location_impl_t; typedef struct { diff --git a/base/sources/backends/webgpu_gpu.c b/base/sources/backends/webgpu_gpu.c index 60793ac8..a22a0e75 100644 --- a/base/sources/backends/webgpu_gpu.c +++ b/base/sources/backends/webgpu_gpu.c @@ -232,7 +232,6 @@ extern WGPUDevice device; void iron_gpu_pipeline_init(iron_gpu_pipeline_t *pipe) { iron_gpu_internal_pipeline_init(pipe); - iron_gpu_internal_pipeline_set_defaults(pipe); } iron_gpu_constant_location_t iron_gpu_pipeline_get_constant_location(iron_gpu_pipeline_t *pipe, const char* name) { @@ -473,10 +472,6 @@ void iron_gpu_command_list_set_vertex_constant_buffer(iron_gpu_command_list_t *l } -void iron_gpu_command_list_set_fragment_constant_buffer(iron_gpu_command_list_t *list, struct iron_gpu_buffer *buffer, int offset, size_t size) { - -} - void iron_gpu_command_list_set_texture(iron_gpu_command_list_t *list, iron_gpu_texture_unit_t unit, iron_gpu_texture_t *texture) { } diff --git a/base/sources/backends/webgpu_gpu.h b/base/sources/backends/webgpu_gpu.h index 02c67bcc..2835932e 100644 --- a/base/sources/backends/webgpu_gpu.h +++ b/base/sources/backends/webgpu_gpu.h @@ -20,7 +20,6 @@ typedef struct { typedef struct { int vertexOffset; - int fragmentOffset; } gpu_constant_location_impl_t; typedef struct iron_gpu_sampler_impl { diff --git a/base/sources/iron.h b/base/sources/iron.h index a0220794..0e4e8244 100644 --- a/base/sources/iron.h +++ b/base/sources/iron.h @@ -2288,7 +2288,8 @@ void iron_raytrace_dispatch_rays(iron_gpu_texture_t *render_target, buffer_t *bu float *cb = (float *)buffer->buffer; iron_gpu_constant_buffer_lock_all(&constant_buffer); for (int i = 0; i < constant_buffer_size; ++i) { - iron_gpu_constant_buffer_set_float(&constant_buffer, i * 4, cb[i]); + float *floats = (float *)(&constant_buffer.data[i * 4]); + floats[0] = cb[i]; } iron_gpu_constant_buffer_unlock(&constant_buffer); diff --git a/base/sources/iron_draw.c b/base/sources/iron_draw.c index 95797718..c897eb71 100644 --- a/base/sources/iron_draw.c +++ b/base/sources/iron_draw.c @@ -161,7 +161,6 @@ void draw_init(buffer_t *image_vert, buffer_t *image_frag, buffer_t *colored_ver image_proj_loc = iron_gpu_pipeline_get_constant_location(&image_pipeline, "P"); image_proj_loc.impl.vertexOffset = 0; - image_proj_loc.impl.fragmentOffset = -1; gpu_vertex_buffer_init(&image_vertex_buffer, DRAW_BUFFER_SIZE * 4, &structure, GPU_USAGE_DYNAMIC); image_rect_verts = gpu_vertex_buffer_lock_all(&image_vertex_buffer); @@ -202,7 +201,6 @@ void draw_init(buffer_t *image_vert, buffer_t *image_frag, buffer_t *colored_ver colored_proj_loc = iron_gpu_pipeline_get_constant_location(&colored_pipeline, "P"); colored_proj_loc.impl.vertexOffset = 0; - colored_proj_loc.impl.fragmentOffset = -1; gpu_vertex_buffer_init(&colored_rect_vertex_buffer, DRAW_BUFFER_SIZE * 4, &structure, GPU_USAGE_DYNAMIC); colored_rect_verts = gpu_vertex_buffer_lock_all(&colored_rect_vertex_buffer); @@ -259,7 +257,6 @@ void draw_init(buffer_t *image_vert, buffer_t *image_frag, buffer_t *colored_ver text_proj_loc = iron_gpu_pipeline_get_constant_location(&text_pipeline, "P"); text_proj_loc.impl.vertexOffset = 0; - text_proj_loc.impl.fragmentOffset = -1; iron_gpu_pipeline_init(&text_pipeline_rt); text_pipeline_rt.input_layout = &structure; diff --git a/base/sources/iron_gpu.c b/base/sources/iron_gpu.c index 4d4847a7..6e3955d2 100644 --- a/base/sources/iron_gpu.c +++ b/base/sources/iron_gpu.c @@ -30,7 +30,6 @@ iron_gpu_command_list_t commandList; bool waitAfterNextDraw = false; static iron_gpu_buffer_t vertexConstantBuffer; -static iron_gpu_buffer_t fragmentConstantBuffer; static int constantBufferIndex = 0; static struct { @@ -103,7 +102,6 @@ void gpu_internal_init_window(int depthBufferBits, bool vsync) { IRON_IMAGE_FORMAT_RGBA32, depthBufferBits); } iron_gpu_constant_buffer_init(&vertexConstantBuffer, CONSTANT_BUFFER_SIZE * CONSTANT_BUFFER_MULTIPLY); - iron_gpu_constant_buffer_init(&fragmentConstantBuffer, CONSTANT_BUFFER_SIZE * CONSTANT_BUFFER_MULTIPLY); // to support doing work after gpu_end and before gpu_begin iron_gpu_command_list_begin(&commandList); @@ -128,16 +126,13 @@ void iron_gpu_internal_set_samplers(int count, iron_gpu_texture_unit_t *texture_ static void iron_internal_start_draw(bool compute) { if ((constantBufferIndex + 1) >= CONSTANT_BUFFER_MULTIPLY || waitAfterNextDraw) { memcpy(current_state.vertex_constant_data, vertexConstantBuffer.data, CONSTANT_BUFFER_SIZE); - memcpy(current_state.fragment_constant_data, fragmentConstantBuffer.data, CONSTANT_BUFFER_SIZE); } iron_gpu_constant_buffer_unlock(&vertexConstantBuffer); - iron_gpu_constant_buffer_unlock(&fragmentConstantBuffer); iron_gpu_internal_set_samplers(current_state.texture_count, current_state.texture_units); iron_gpu_internal_set_samplers(current_state.depth_render_target_count, current_state.depth_render_target_units); iron_gpu_command_list_set_vertex_constant_buffer(&commandList, &vertexConstantBuffer, constantBufferIndex * CONSTANT_BUFFER_SIZE, CONSTANT_BUFFER_SIZE); - iron_gpu_command_list_set_fragment_constant_buffer(&commandList, &fragmentConstantBuffer, constantBufferIndex * CONSTANT_BUFFER_SIZE, CONSTANT_BUFFER_SIZE); } static void iron_internal_end_draw(bool compute) { @@ -187,14 +182,11 @@ static void iron_internal_end_draw(bool compute) { waitAfterNextDraw = false; iron_gpu_constant_buffer_lock(&vertexConstantBuffer, 0, CONSTANT_BUFFER_SIZE); - iron_gpu_constant_buffer_lock(&fragmentConstantBuffer, 0, CONSTANT_BUFFER_SIZE); memcpy(vertexConstantBuffer.data, current_state.vertex_constant_data, CONSTANT_BUFFER_SIZE); - memcpy(fragmentConstantBuffer.data, current_state.fragment_constant_data, CONSTANT_BUFFER_SIZE); } else { iron_gpu_constant_buffer_lock(&vertexConstantBuffer, constantBufferIndex * CONSTANT_BUFFER_SIZE, CONSTANT_BUFFER_SIZE); - iron_gpu_constant_buffer_lock(&fragmentConstantBuffer, constantBufferIndex * CONSTANT_BUFFER_SIZE, CONSTANT_BUFFER_SIZE); } } @@ -297,7 +289,6 @@ void gpu_disable_scissor(void) { void gpu_end() { iron_gpu_constant_buffer_unlock(&vertexConstantBuffer); - iron_gpu_constant_buffer_unlock(&fragmentConstantBuffer); iron_gpu_command_list_render_target_to_framebuffer_barrier(&commandList, &windows[0].framebuffers[windows[0].currentBuffer]); iron_gpu_command_list_end(&commandList); @@ -310,94 +301,114 @@ void gpu_end() { } void gpu_set_int(iron_gpu_constant_location_t *location, int value) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_int(&vertexConstantBuffer, location->impl.vertexOffset, value); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_int(&fragmentConstantBuffer, location->impl.fragmentOffset, value); + int *ints = (int *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + ints[0] = value; } void gpu_set_int2(iron_gpu_constant_location_t *location, int value1, int value2) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_int2(&vertexConstantBuffer, location->impl.vertexOffset, value1, value2); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_int2(&fragmentConstantBuffer, location->impl.fragmentOffset, value1, value2); + int *ints = (int *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + ints[0] = value1; + ints[1] = value2; } void gpu_set_int3(iron_gpu_constant_location_t *location, int value1, int value2, int value3) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_int3(&vertexConstantBuffer, location->impl.vertexOffset, value1, value2, value3); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_int3(&fragmentConstantBuffer, location->impl.fragmentOffset, value1, value2, value3); + int *ints = (int *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + ints[0] = value1; + ints[1] = value2; + ints[2] = value3; } void gpu_set_int4(iron_gpu_constant_location_t *location, int value1, int value2, int value3, int value4) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_int4(&vertexConstantBuffer, location->impl.vertexOffset, value1, value2, value3, value4); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_int4(&fragmentConstantBuffer, location->impl.fragmentOffset, value1, value2, value3, value4); + int *ints = (int *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + ints[0] = value1; + ints[1] = value2; + ints[2] = value3; + ints[3] = value4; } void gpu_set_ints(iron_gpu_constant_location_t *location, int *values, int count) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_ints(&vertexConstantBuffer, location->impl.vertexOffset, values, count); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_ints(&fragmentConstantBuffer, location->impl.fragmentOffset, values, count); + int *ints = (int *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + for (int i = 0; i < count; ++i) { + ints[i] = values[i]; + } } void gpu_set_float(iron_gpu_constant_location_t *location, float value) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_float(&vertexConstantBuffer, location->impl.vertexOffset, value); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_float(&fragmentConstantBuffer, location->impl.fragmentOffset, value); + float *floats = (float *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + floats[0] = value; } void gpu_set_float2(iron_gpu_constant_location_t *location, float value1, float value2) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_float2(&vertexConstantBuffer, location->impl.vertexOffset, value1, value2); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_float2(&fragmentConstantBuffer, location->impl.fragmentOffset, value1, value2); + float *floats = (float *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + floats[0] = value1; + floats[1] = value2; } void gpu_set_float3(iron_gpu_constant_location_t *location, float value1, float value2, float value3) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_float3(&vertexConstantBuffer, location->impl.vertexOffset, value1, value2, value3); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_float3(&fragmentConstantBuffer, location->impl.fragmentOffset, value1, value2, value3); + float *floats = (float *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + floats[0] = value1; + floats[1] = value2; + floats[2] = value3; } void gpu_set_float4(iron_gpu_constant_location_t *location, float value1, float value2, float value3, float value4) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_float4(&vertexConstantBuffer, location->impl.vertexOffset, value1, value2, value3, value4); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_float4(&fragmentConstantBuffer, location->impl.fragmentOffset, value1, value2, value3, value4); + float *floats = (float *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + floats[0] = value1; + floats[1] = value2; + floats[2] = value3; + floats[3] = value4; } void gpu_set_floats(iron_gpu_constant_location_t *location, f32_array_t *values) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_floats(&vertexConstantBuffer, location->impl.vertexOffset, values->buffer, values->length); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_floats(&fragmentConstantBuffer, location->impl.fragmentOffset, values->buffer, values->length); + float *floats = (float *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + for (int i = 0; i < values->length; ++i) { + floats[i] = values->buffer[i]; + } } void gpu_set_bool(iron_gpu_constant_location_t *location, bool value) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_bool(&vertexConstantBuffer, location->impl.vertexOffset, value); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_bool(&fragmentConstantBuffer, location->impl.fragmentOffset, value); + int *ints = (int *)(&vertexConstantBuffer.data[location->impl.vertexOffset]); + ints[0] = value ? 1 : 0; +} + +static void iron_internal_set_matrix3(uint8_t *constants, int offset, iron_matrix3x3_t *value) { + float *floats = (float *)(&constants[offset]); + for (int y = 0; y < 3; ++y) { + for (int x = 0; x < 3; ++x) { + floats[x + y * 4] = iron_matrix3x3_get(value, x, y); + } + } +} + +static void iron_internal_set_matrix4(uint8_t *constants, int offset, iron_matrix4x4_t *value) { + float *floats = (float *)(&constants[offset]); + for (int y = 0; y < 4; ++y) { + for (int x = 0; x < 4; ++x) { + floats[x + y * 4] = iron_matrix4x4_get(value, x, y); + } + } } void gpu_set_matrix4(iron_gpu_constant_location_t *location, iron_matrix4x4_t value) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_matrix4(&vertexConstantBuffer, location->impl.vertexOffset, &value); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_matrix4(&fragmentConstantBuffer, location->impl.fragmentOffset, &value); + if (iron_gpu_transpose_mat) { + iron_matrix4x4_t m = value; + iron_matrix4x4_transpose(&m); + iron_internal_set_matrix4(vertexConstantBuffer.data, location->impl.vertexOffset, &m); + } + else { + iron_internal_set_matrix4(vertexConstantBuffer.data, location->impl.vertexOffset, &value); + } } void gpu_set_matrix3(iron_gpu_constant_location_t *location, iron_matrix3x3_t value) { - if (location->impl.vertexOffset >= 0) - iron_gpu_constant_buffer_set_matrix3(&vertexConstantBuffer, location->impl.vertexOffset, &value); - if (location->impl.fragmentOffset >= 0) - iron_gpu_constant_buffer_set_matrix3(&fragmentConstantBuffer, location->impl.fragmentOffset, &value); + if (iron_gpu_transpose_mat) { + iron_matrix3x3_t m = value; + iron_matrix3x3_transpose(&m); + iron_internal_set_matrix3(vertexConstantBuffer.data, location->impl.vertexOffset, &m); + } + else { + iron_internal_set_matrix3(vertexConstantBuffer.data, location->impl.vertexOffset, &value); + } } void gpu_set_texture_addressing(iron_gpu_texture_unit_t unit, gpu_texture_direction_t dir, gpu_texture_addressing_t addressing) { @@ -569,117 +580,6 @@ float *gpu_vertex_buffer_lock(iron_gpu_buffer_t *buffer, int start, int count) { return iron_gpu_vertex_buffer_lock(buffer, start, count); } -void iron_gpu_constant_buffer_set_int(iron_gpu_buffer_t *buffer, int offset, int value) { - int *ints = (int *)(&buffer->data[offset]); - ints[0] = value; -} - -void iron_gpu_constant_buffer_set_int2(iron_gpu_buffer_t *buffer, int offset, int value1, int value2) { - int *ints = (int *)(&buffer->data[offset]); - ints[0] = value1; - ints[1] = value2; -} - -void iron_gpu_constant_buffer_set_int3(iron_gpu_buffer_t *buffer, int offset, int value1, int value2, int value3) { - int *ints = (int *)(&buffer->data[offset]); - ints[0] = value1; - ints[1] = value2; - ints[2] = value3; -} - -void iron_gpu_constant_buffer_set_int4(iron_gpu_buffer_t *buffer, int offset, int value1, int value2, int value3, int value4) { - int *ints = (int *)(&buffer->data[offset]); - ints[0] = value1; - ints[1] = value2; - ints[2] = value3; - ints[3] = value4; -} - -void iron_gpu_constant_buffer_set_ints(iron_gpu_buffer_t *buffer, int offset, int *values, int count) { - int *ints = (int *)(&buffer->data[offset]); - for (int i = 0; i < count; ++i) { - ints[i] = values[i]; - } -} - -void iron_gpu_constant_buffer_set_float(iron_gpu_buffer_t *buffer, int offset, float value) { - float *floats = (float *)(&buffer->data[offset]); - floats[0] = value; -} - -void iron_gpu_constant_buffer_set_float2(iron_gpu_buffer_t *buffer, int offset, float value1, float value2) { - float *floats = (float *)(&buffer->data[offset]); - floats[0] = value1; - floats[1] = value2; -} - -void iron_gpu_constant_buffer_set_float3(iron_gpu_buffer_t *buffer, int offset, float value1, float value2, float value3) { - float *floats = (float *)(&buffer->data[offset]); - floats[0] = value1; - floats[1] = value2; - floats[2] = value3; -} - -void iron_gpu_constant_buffer_set_float4(iron_gpu_buffer_t *buffer, int offset, float value1, float value2, float value3, float value4) { - float *floats = (float *)(&buffer->data[offset]); - floats[0] = value1; - floats[1] = value2; - floats[2] = value3; - floats[3] = value4; -} - -void iron_gpu_constant_buffer_set_floats(iron_gpu_buffer_t *buffer, int offset, float *values, int count) { - float *floats = (float *)(&buffer->data[offset]); - for (int i = 0; i < count; ++i) { - floats[i] = values[i]; - } -} - -void iron_gpu_constant_buffer_set_bool(iron_gpu_buffer_t *buffer, int offset, bool value) { - int *ints = (int *)(&buffer->data[offset]); - ints[0] = value ? 1 : 0; -} - -static void iron_internal_set_matrix3(uint8_t *constants, int offset, iron_matrix3x3_t *value) { - float *floats = (float *)(&constants[offset]); - for (int y = 0; y < 3; ++y) { - for (int x = 0; x < 3; ++x) { - floats[x + y * 4] = iron_matrix3x3_get(value, x, y); - } - } -} - -void iron_gpu_constant_buffer_set_matrix3(iron_gpu_buffer_t *buffer, int offset, iron_matrix3x3_t *value) { - if (iron_gpu_transpose_mat) { - iron_matrix3x3_t m = *value; - iron_matrix3x3_transpose(&m); - iron_internal_set_matrix3(buffer->data, offset, &m); - } - else { - iron_internal_set_matrix3(buffer->data, offset, value); - } -} - -static void iron_internal_set_matrix4(uint8_t *constants, int offset, iron_matrix4x4_t *value) { - float *floats = (float *)(&constants[offset]); - for (int y = 0; y < 4; ++y) { - for (int x = 0; x < 4; ++x) { - floats[x + y * 4] = iron_matrix4x4_get(value, x, y); - } - } -} - -void iron_gpu_constant_buffer_set_matrix4(iron_gpu_buffer_t *buffer, int offset, iron_matrix4x4_t *value) { - if (iron_gpu_transpose_mat) { - iron_matrix4x4_t m = *value; - iron_matrix4x4_transpose(&m); - iron_internal_set_matrix4(buffer->data, offset, &m); - } - else { - iron_internal_set_matrix4(buffer->data, offset, value); - } -} - void iron_gpu_internal_pipeline_init(iron_gpu_pipeline_t *pipe) { pipe->input_layout = NULL; pipe->vertex_shader = NULL; @@ -708,36 +608,6 @@ void iron_gpu_internal_pipeline_init(iron_gpu_pipeline_t *pipe) { pipe->depth_attachment_bits = 0; } -void iron_gpu_internal_pipeline_set_defaults(iron_gpu_pipeline_t *state) { - state->input_layout = NULL; - state->vertex_shader = NULL; - state->fragment_shader = NULL; - - state->cull_mode = IRON_GPU_CULL_MODE_NEVER; - state->depth_write = false; - state->depth_mode = IRON_GPU_COMPARE_MODE_ALWAYS; - - state->blend_source = IRON_GPU_BLEND_ONE; - state->blend_destination = IRON_GPU_BLEND_ZERO; - state->blend_operation = IRON_GPU_BLENDOP_ADD; - state->alpha_blend_source = IRON_GPU_BLEND_ONE; - state->alpha_blend_destination = IRON_GPU_BLEND_ZERO; - state->alpha_blend_operation = IRON_GPU_BLENDOP_ADD; - - for (int i = 0; i < 8; ++i) { - state->color_write_mask_red[i] = true; - state->color_write_mask_green[i] = true; - state->color_write_mask_blue[i] = true; - state->color_write_mask_alpha[i] = true; - state->color_attachment[i] = IRON_IMAGE_FORMAT_RGBA32; - } - - state->color_attachment_count = 1; - state->depth_attachment_bits = 0; - - state->kong = false; -} - void iron_gpu_sampler_options_set_defaults(iron_gpu_sampler_options_t *options) { options->u_addressing = IRON_GPU_TEXTURE_ADDRESSING_CLAMP; options->v_addressing = IRON_GPU_TEXTURE_ADDRESSING_CLAMP; diff --git a/base/sources/iron_gpu.h b/base/sources/iron_gpu.h index cda7e74a..f0940a86 100644 --- a/base/sources/iron_gpu.h +++ b/base/sources/iron_gpu.h @@ -355,8 +355,6 @@ typedef struct iron_gpu_pipeline { int depth_attachment_bits; gpu_pipeline_impl_t impl; - - bool kong; } iron_gpu_pipeline_t; typedef struct iron_gpu_sampler_options { @@ -387,8 +385,6 @@ void iron_gpu_sampler_options_set_defaults(iron_gpu_sampler_options_t *options); void iron_gpu_sampler_init(iron_gpu_sampler_t *sampler, const iron_gpu_sampler_options_t *options); void iron_gpu_sampler_destroy(iron_gpu_sampler_t *sampler); -void iron_gpu_internal_pipeline_set_defaults(iron_gpu_pipeline_t *pipeline); - struct iron_gpu_pipeline; struct iron_gpu_texture; struct iron_gpu_command_list; @@ -420,7 +416,6 @@ void iron_gpu_command_list_upload_index_buffer(iron_gpu_command_list_t *list, ir void iron_gpu_command_list_upload_vertex_buffer(iron_gpu_command_list_t *list, struct iron_gpu_buffer *buffer); void iron_gpu_command_list_upload_texture(iron_gpu_command_list_t *list, struct iron_gpu_texture *texture); void iron_gpu_command_list_set_vertex_constant_buffer(iron_gpu_command_list_t *list, iron_gpu_buffer_t *buffer, int offset, size_t size); -void iron_gpu_command_list_set_fragment_constant_buffer(iron_gpu_command_list_t *list, iron_gpu_buffer_t *buffer, int offset, size_t size); void iron_gpu_command_list_execute(iron_gpu_command_list_t *list); void iron_gpu_command_list_wait_for_execution_to_finish(iron_gpu_command_list_t *list); void iron_gpu_command_list_get_render_target_pixels(iron_gpu_command_list_t *list, struct iron_gpu_texture *render_target, uint8_t *data); diff --git a/base/sources/ts/import_envmap.ts b/base/sources/ts/import_envmap.ts index d4b900c3..7a34cbc4 100644 --- a/base/sources/ts/import_envmap.ts +++ b/base/sources/ts/import_envmap.ts @@ -25,8 +25,7 @@ function import_envmap_run(path: string, image: iron_gpu_texture_t) { import_envmap_params_loc = gpu_get_constant_location(import_envmap_pipeline, "params"); let ptr: gpu_constant_location_impl_t = ADDRESS(import_envmap_params_loc.impl); - ptr.vertexOffset = -1; - ptr.fragmentOffset = 0; + ptr.vertexOffset = 0; import_envmap_radiance_loc = gpu_get_texture_unit(import_envmap_pipeline, "radiance"); ARRAY_ACCESS(import_envmap_radiance_loc.stages, IRON_GPU_SHADER_TYPE_FRAGMENT) = 0; diff --git a/base/sources/ts/iron/shader_data.ts b/base/sources/ts/iron/shader_data.ts index c174c775..531315c5 100644 --- a/base/sources/ts/iron/shader_data.ts +++ b/base/sources/ts/iron/shader_data.ts @@ -371,11 +371,8 @@ function shader_context_get_tex_format(s: string): tex_format_t { function shader_context_add_const(raw: shader_context_t, c: shader_const_t, offset: i32) { let cl: iron_gpu_constant_location_t = gpu_get_constant_location(raw._.pipe_state, c.name); - let ptr: gpu_constant_location_impl_t = ADDRESS(cl.impl); ptr.vertexOffset = offset; - ptr.fragmentOffset = offset; - array_push(raw._.constants, cl); } diff --git a/base/sources/ts/pipes.ts b/base/sources/ts/pipes.ts index 527fdc5e..49d29c5a 100644 --- a/base/sources/ts/pipes.ts +++ b/base/sources/ts/pipes.ts @@ -307,7 +307,6 @@ function pipes_get_constant_location(pipe: iron_gpu_pipeline_t, name: string, ty let size: i32 = shader_context_type_size(type); pipes_offset += shader_context_type_pad(pipes_offset, size); ptr.vertexOffset = pipes_offset; - ptr.fragmentOffset = pipes_offset; pipes_offset += size; return loc; }