birth-software/bloat-buster
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

More engine refactoring

Browse Source
This commit is contained in:
David Gonzalez Martin 2024-12-03 07:23:43 -06:00 committed by David
parent b20395fc1c
commit 4035da283c
5 changed files with 173 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

289
bootstrap/bloat-buster/bb_core.c
View File

@ -8,11 +8,6 @@
#include <std/image_loader.h>
#include <std/font_provider.h>
STRUCT(Vec4)
{
f32 v[4];
}__attribute__((aligned(16)));
STRUCT(Vertex)
{
f32 x;
@ -43,65 +38,69 @@ fn TextureIndex white_texture_create(Arena* arena, Renderer* renderer)
return white_texture;
}
fn void draw_string(Renderer* renderer, VirtualBuffer(Vertex)* vertices, VirtualBuffer(u32)* indices, u32 width, u32 height, Vec4 color, String string, TextureAtlas texture_atlas, u32 texture_index)
fn void draw_string(RenderWindow* window, Vec4 color, String string, TextureAtlas texture_atlas, u32 texture_index, u32 x_offset, u32 y_offset)
{
u32 index_offset = 0;
auto x_offset = width / 2;
auto y_offset = height / 2;
for (u64 i = 0; i < string.length; i += 1, index_offset += 4)
auto height = texture_atlas.ascent - texture_atlas.descent;
for (u64 i = 0; i < string.length; i += 1)
{
auto ch = string.pointer[i];
auto* character = &texture_atlas.characters[ch];
auto pos_x = x_offset;
auto pos_y = y_offset - (character->height + character->y_offset);
auto pos_y = y_offset + character->y_offset + height; // Offset of the height to render the character from the bottom (y + height) up (y)
auto uv_x = character->x;
auto uv_y = character->y;
auto uv_width = character->width;
auto uv_height = character->height;
*vb_add(vertices, 1) = (Vertex) {
.x = pos_x,
.y = pos_y,
.uv_x = (f32)uv_x,
.uv_y = (f32)uv_y,
.color = color,
.texture_index = texture_index,
};
*vb_add(vertices, 1) = (Vertex) {
.x = pos_x + character->width,
.y = pos_y,
.uv_x = (f32)(uv_x + uv_width),
.uv_y = (f32)uv_y,
.color = color,
.texture_index = texture_index,
};
*vb_add(vertices, 1) = (Vertex) {
.x = pos_x,
.y = pos_y + character->height,
.uv_x = (f32)uv_x,
.uv_y = (f32)(uv_y + uv_height),
.color = color,
.texture_index = texture_index,
};
*vb_add(vertices, 1) = (Vertex) {
.x = pos_x + character->width,
.y = pos_y + character->height,
.uv_x = (f32)(uv_x + uv_width),
.uv_y = (f32)(uv_y + uv_height),
.color = color,
.texture_index = texture_index,
Vertex vertices[] = {
(Vertex) {
.x = pos_x,
.y = pos_y,
.uv_x = (f32)uv_x,
.uv_y = (f32)uv_y,
.color = color,
.texture_index = texture_index,
},
(Vertex) {
.x = pos_x + character->width,
.y = pos_y,
.uv_x = (f32)(uv_x + uv_width),
.uv_y = (f32)uv_y,
.color = color,
.texture_index = texture_index,
},
(Vertex) {
.x = pos_x,
.y = pos_y + character->height,
.uv_x = (f32)uv_x,
.uv_y = (f32)(uv_y + uv_height),
.color = color,
.texture_index = texture_index,
},
(Vertex) {
.x = pos_x + character->width,
.y = pos_y + character->height,
.uv_x = (f32)(uv_x + uv_width),
.uv_y = (f32)(uv_y + uv_height),
.color = color,
.texture_index = texture_index,
},
};
*vb_add(indices, 1) = index_offset + 0;
*vb_add(indices, 1) = index_offset + 1;
*vb_add(indices, 1) = index_offset + 2;
*vb_add(indices, 1) = index_offset + 1;
*vb_add(indices, 1) = index_offset + 3;
*vb_add(indices, 1) = index_offset + 2;
auto vertex_offset = window_pipeline_add_vertices(window, BB_PIPELINE_RECT, (String)array_to_bytes(vertices), array_length(vertices));
u32 indices[] = {
vertex_offset + 0,
vertex_offset + 1,
vertex_offset + 2,
vertex_offset + 1,
vertex_offset + 3,
vertex_offset + 2,
};
window_pipeline_add_indices(window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(indices));
auto kerning = (texture_atlas.kerning_tables + ch * 256)[string.pointer[i + 1]];
// print("Advance: {u32}. Kerning: {s32}\n", character->advance, kerning);
x_offset += character->advance + kerning;
}
}
@ -144,89 +143,30 @@ void run_app()
auto font_path =
#ifdef _WIN32
strlit("C:/Users/David/Downloads/Fira_Sans/FiraSans-Regular.ttf")
strlit("C:/Users/David/Downloads/Fira_Sans/FiraSans-Regular.ttf");
#elif defined(__linux__)
strlit("/usr/share/fonts/TTF/FiraSans-Regular.ttf")
strlit("/usr/share/fonts/TTF/FiraSans-Regular.ttf");
#else
strlit("WRONG_PATH");
#endif
;
window_rect_texture_update_begin(render_window);
{
auto white_texture = white_texture_create(state.arena, renderer);
auto monospace_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
.font_path = font_path,
.text_height = 180,
});
auto proportional_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
.font_path = font_path,
.text_height = 180,
});
window_queue_rect_texture_update(render_window, RECT_TEXTURE_SLOT_WHITE, white_texture);
renderer_queue_font_update(renderer, render_window, RENDER_FONT_TYPE_MONOSPACE, monospace_font);
renderer_queue_font_update(renderer, render_window, RENDER_FONT_TYPE_PROPORTIONAL, proportional_font);
}
window_rect_texture_update_end(renderer, render_window);
// Vec4 color = {1, 1, 1, 1};
// static_assert(sizeof(color) == 4 * sizeof(float));
//
// u32 texture_index = 1;
// // draw_string(renderer, &vertices, &indices, window_size.width, window_size.height, color, strlit("He"), texture_atlas, texture_index);
//
//
// vb_copy_array(&vertices, box_vertices);
// vb_copy_array(&indices, box_indices);
//
// auto vertex_buffer_size = sizeof(*vertices.pointer) * vertices.length;
// auto index_buffer_size = sizeof(*indices.pointer) * indices.length;
//
// auto vertex_buffer = renderer_buffer_create(renderer, vertex_buffer_size, BUFFER_TYPE_VERTEX);
// auto vertex_buffer_device_address = buffer_address(vertex_buffer);
// auto index_buffer = renderer_buffer_create(renderer, index_buffer_size, BUFFER_TYPE_INDEX);
// auto staging_buffer = renderer_buffer_create(renderer, vertex_buffer_size + index_buffer_size, BUFFER_TYPE_STAGING);
//
// renderer_copy_to_host(staging_buffer, (Slice(HostBufferCopy)) array_to_slice(((HostBufferCopy[]) {
// {
// .destination_offset = 0,
// .source = {
// .pointer = (u8*)vertices.pointer,
// .length = vertex_buffer_size,
// },
// },
// {
// .destination_offset = vertex_buffer_size,
// .source = {
// .pointer = (u8*)indices.pointer,
// .length = index_buffer_size,
// },
// },
// })));
//
// renderer_copy_to_local(renderer, (Slice(LocalBufferCopy)) array_to_slice(((LocalBufferCopy[]) {
// {
// .destination = vertex_buffer,
// .source = staging_buffer,
// .regions = array_to_slice(((LocalBufferCopyRegion[]) {
// {
// .source_offset = 0,
// .destination_offset = 0,
// .size = vertex_buffer_size,
// },
// })),
// },
// {
// .destination = index_buffer,
// .source = staging_buffer,
// .regions = array_to_slice(((LocalBufferCopyRegion[]) {
// {
// .source_offset = vertex_buffer_size,
// .destination_offset = 0,
// .size = index_buffer_size,
// },
// })),
// },
// })));
auto white_texture = white_texture_create(state.arena, renderer);
auto monospace_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
.font_path = font_path,
.text_height = 50,
});
auto proportional_font = monospace_font;
// auto proportional_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
// .font_path = font_path,
// .text_height = 36,
// });
window_queue_rect_texture_update(render_window, RECT_TEXTURE_SLOT_WHITE, white_texture);
renderer_queue_font_update(renderer, render_window, RENDER_FONT_TYPE_MONOSPACE, monospace_font);
renderer_queue_font_update(renderer, render_window, RENDER_FONT_TYPE_PROPORTIONAL, proportional_font);
window_rect_texture_update_end(renderer, render_window);
while (!os_window_should_close(os_window))
{
@ -236,68 +176,45 @@ strlit("/usr/share/fonts/TTF/FiraSans-Regular.ttf")
// print("Mouse position: ({f64}, {f64})\n", mouse_position.x, mouse_position.y);
renderer_window_frame_begin(renderer, render_window);
u32 box_x = 200;
u32 box_y = 200;
u32 box_width = 100;
u32 box_height = 100;
Vec4 box_color = { 1, 0, 0, 1 };
Vertex box_vertices[] = {
{
.x = box_x,
.y = box_y,
.color = box_color,
},
{
.x = box_x + box_width,
.y = box_y,
.color = box_color,
},
{
.x = box_x,
.y = box_y + box_height,
.color = box_color,
},
{
.x = box_x + box_width,
.y = box_y + box_height,
.color = box_color,
},
};
u32 box_indices[] = {
0, 1, 2,
1, 3, 2,
};
window_pipeline_add_vertices(render_window, BB_PIPELINE_RECT, (String)array_to_bytes(box_vertices));
window_pipeline_add_indices(render_window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(box_indices));
// u32 box_width = 10;
// u32 box_height = 10;
// auto box_color = Color4(1, 0, 0, 1);
//
// Vertex box_vertices[] = {
// {
// .x = mouse_position.x,
// .y = mouse_position.y,
// .color = box_color,
// },
// {
// .x = mouse_position.x + box_width,
// .y = mouse_position.y,
// .color = box_color,
// },
// {
// .x = mouse_position.x,
// .y = mouse_position.y + box_height,
// .color = box_color,
// },
// {
// .x = mouse_position.x + box_width,
// .y = mouse_position.y + box_height,
// .color = box_color,
// },
// };
//
// auto vertex_offset = window_pipeline_add_vertices(render_window, BB_PIPELINE_RECT, (String)array_to_bytes(box_vertices), array_length(box_vertices));
//
// u32 box_indices[] = {
// vertex_offset + 0, vertex_offset + 1, vertex_offset + 2,
// vertex_offset + 1, vertex_offset + 3, vertex_offset + 2,
// };
//
// window_pipeline_add_indices(render_window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(box_indices));
draw_string(render_window, Color4(0, 0, 0, 1), strlit("abcdefghijklmnopqrstuvwxyz!"), monospace_font, RECT_TEXTURE_SLOT_MONOSPACE_FONT, 100, 100);
renderer_window_frame_end(renderer, render_window);
// window_size = os_window_size_get(os_window);
//
// window_command_begin(render_window);
//
// // window_bind_pipeline(render_window, pipeline_index);
// // window_bind_pipeline_descriptor_sets(render_window, pipeline_index);
// // window_bind_index_buffer(render_window, index_buffer, 0, INDEX_TYPE_U32);
// // GPUDrawPushConstants push_constants = {
// // .vertex_buffer = vertex_buffer_device_address,
// // .width = (f32)window_size.width,
// // .height = (f32)window_size.height,
// // };
// // window_push_constants(render_window, pipeline_index, (SliceP(void)) array_to_slice(((void*[]) {&push_constants})));
//
// window_render_begin(render_window);
// {
// // window_draw_indexed(render_window, indices.length, 1, 0, 0, 0);
// }
// window_render_end(render_window);
//
// window_command_end(render_window);
//
// renderer_window_frame_end(renderer, render_window);
}
// TODO: deinitialization

9
bootstrap/include/std/render.h
View File

@ -11,6 +11,13 @@ typedef struct Renderer Renderer;
typedef struct RenderWindow RenderWindow;
typedef struct Pipeline Pipeline;
STRUCT(Vec4)
{
f32 v[4];
}__attribute__((aligned(16)));
#define Color4(r, g, b, a) ((Vec4){ .v = { r, g, b, a } })
typedef enum BBPipeline
{
BB_PIPELINE_RECT,
@ -164,5 +171,5 @@ EXPORT void renderer_queue_font_update(Renderer* renderer, RenderWindow* window,
EXPORT void window_queue_rect_texture_update(RenderWindow* window, RectTextureSlot slot, TextureIndex texture_index);
EXPORT void window_rect_texture_update_end(Renderer* renderer, RenderWindow* window);
EXPORT void window_pipeline_add_vertices(RenderWindow* window, BBPipeline pipeline_index, String vertex_memory);
EXPORT u32 window_pipeline_add_vertices(RenderWindow* window, BBPipeline pipeline_index, String vertex_memory, u32 vertex_count);
EXPORT void window_pipeline_add_indices(RenderWindow* window, BBPipeline pipeline_index, Slice(u32) indices);

7
bootstrap/shaders/font.vert
View File

@ -30,16 +30,15 @@ layout(push_constant) uniform constants
void main()
{
//load vertex data from device address
Vertex v = PushConstants.vertex_buffer.vertices[gl_VertexIndex];
float width = PushConstants.width;
float height = PushConstants.height;
//output data
gl_Position = vec4(2 * v.x / width - 1, 1 - (2 * v.y) / height, 0, 1);
gl_Position = vec4(2 * v.x / width - 1, 2 * v.y / height - 1, 0, 1);
out_uv = vec2(v.uv_x, v.uv_y);
out_color = v.color;
out_texture_index = v.texture_index;
//debugPrintfEXT("Position: (%f, %f, %f)\n", v.position.x, v.position.y, v.position.z);
//debugPrintfEXT("Color: (%f, %f, %f)\n", v.color.x, v.color.y, v.color.z);
//debugPrintfEXT("Position: (%f, %f)\n", v.x, v.y);
//debugPrintfEXT("UV: (%f, %f)\n", v.uv_x, v.uv_y);
}

27
bootstrap/std/font_provider.c
View File

@ -39,6 +39,7 @@ TextureAtlas font_texture_atlas_create(Arena* arena, Renderer* renderer, Texture
u32 max_row_height = 0;
u32 first_character = ' ';
u32 last_character = '~';
for (auto i = first_character; i <= last_character; ++i)
{
u32 width;
@ -77,38 +78,20 @@ TextureAtlas font_texture_atlas_create(Arena* arena, Renderer* renderer, Texture
character->width = width;
character->height = height;
// print("Drawing codepoint '{c}' ({u32}x{u32}) at ({u32}, {u32}). Offsets: ({s32}, {s32})\n", ch, width, height, x, y, character->x_offset, character->y_offset);
auto* source = bitmap;
auto* destination = result.pointer;
for (u32 bitmap_y = 0; bitmap_y < height; bitmap_y += 1)
{
for (u32 bitmap_x = 0; bitmap_x < width; bitmap_x += 1)
{
auto source_index = bitmap_y * width + bitmap_x;
auto destination_index = ((height - bitmap_y - 1) + y) * result.width + bitmap_x + x;
destination[destination_index] = ((u32)(source[source_index]) << 24) | 0xffffff;
auto destination_index = (bitmap_y + y) * result.width + (bitmap_x + x);
auto value = source[source_index];
destination[destination_index] = ((u32)value << 24) | 0xffffff;
}
}
// for (u32 bitmap_y = y; bitmap_y < y + height; bitmap_y += 1)
// {
// for (u32 bitmap_x = x; bitmap_x < x + width; bitmap_x += 1)
// {
// auto x = result.pointer[bitmap_y * result.width + bitmap_x];
// if (x)
// {
// print("[x]");
// }
// else
// {
// print("[ ]");
// }
// }
//
// print("\n");
// }
x += width;
stbtt_FreeBitmap(bitmap, 0);

98
bootstrap/std/render.c
View File

@ -40,11 +40,17 @@ STRUCT(VulkanImageCreate)
VkImageUsageFlags usage;
};
STRUCT(GPUMemory)
{
VkDeviceMemory handle;
u64 size;
};
STRUCT(VulkanImage)
{
VkImage handle;
VkImageView view;
VkDeviceMemory memory;
GPUMemory memory;
VkFormat format;
};
@ -89,7 +95,7 @@ STRUCT(ImmediateContext)
STRUCT(VulkanBuffer)
{
VkBuffer handle;
VkDeviceMemory gpu_data;
GPUMemory memory;
u64 address;
VkDeviceSize size;
BufferType type;
@ -107,6 +113,7 @@ STRUCT(VertexBuffer)
{
VulkanBuffer gpu;
VirtualBuffer(u8) cpu;
u32 count;
};
STRUCT(IndexBuffer)
@ -308,7 +315,13 @@ void buffer_copy_to_host(VulkanBuffer buffer, Slice(HostBufferCopy) regions)
for (u64 i = 0; i < regions.length; i += 1)
{
auto region = regions.pointer[i];
memcpy(buffer_pointer + region.destination_offset, region.source.pointer, region.source.length);
auto* destination = buffer_pointer + region.destination_offset;
assert(destination + region.source.length <= (u8*)buffer.address + buffer.size);
for (u64 i = 0; i < region.source.length; i += 1)
{
destination[i] = region.source.pointer[i];
}
// memcpy(destination, region.source.pointer, region.source.length);
}
}
@ -398,7 +411,7 @@ fn ShaderStage shader_stage_from_path(String shader_source_path)
return shader_stage;
}
fn VkDeviceMemory vk_allocate_memory(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties memory_properties, VkMemoryRequirements memory_requirements, VkMemoryPropertyFlags flags, u8 use_device_address_bit)
fn GPUMemory vk_allocate_memory(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties memory_properties, VkMemoryRequirements memory_requirements, VkMemoryPropertyFlags flags, u8 use_device_address_bit)
{
u32 memory_type_index;
for (memory_type_index = 0; memory_type_index < memory_properties.memoryTypeCount; memory_type_index += 1)
@ -418,6 +431,7 @@ fn VkDeviceMemory vk_allocate_memory(VkDevice device, const VkAllocationCallback
VkMemoryAllocateInfo allocate_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.pNext = 0,
.allocationSize = memory_requirements.size,
.memoryTypeIndex = memory_type_index,
};
@ -437,7 +451,7 @@ fn VkDeviceMemory vk_allocate_memory(VkDevice device, const VkAllocationCallback
VkDeviceMemory memory = 0;
vkok(vkAllocateMemory(device, &allocate_info, allocation_callbacks, &memory));
return memory;
return (GPUMemory) { .handle = memory, .size = allocate_info.allocationSize };
}
fn VulkanBuffer vk_buffer_create(VkDevice device, const VkAllocationCallbacks* allocation_callbacks, VkPhysicalDeviceMemoryProperties physical_device_memory_properties, VkDeviceSize buffer_size, VkBufferUsageFlags usage_flags, VkMemoryPropertyFlags memory_flags)
@ -462,10 +476,10 @@ fn VulkanBuffer vk_buffer_create(VkDevice device, const VkAllocationCallbacks* a
vkGetBufferMemoryRequirements(device, result.handle, &memory_requirements);
u8 use_device_address_bit = !!(create_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT);
result.gpu_data = vk_allocate_memory(device, allocation_callbacks, physical_device_memory_properties, memory_requirements, memory_flags, use_device_address_bit);
result.memory = vk_allocate_memory(device, allocation_callbacks, physical_device_memory_properties, memory_requirements, memory_flags, use_device_address_bit);
VkDeviceSize memory_offset = 0;
vkok(vkBindBufferMemory(device, result.handle, result.gpu_data, memory_offset));
vkok(vkBindBufferMemory(device, result.handle, result.memory.handle, memory_offset));
u8 map_memory = !!(memory_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
assert(((map_memory | use_device_address_bit) == 0) | (map_memory == !use_device_address_bit));
@ -474,7 +488,7 @@ fn VulkanBuffer vk_buffer_create(VkDevice device, const VkAllocationCallbacks* a
void* data = 0;
VkDeviceSize offset = 0;
VkMemoryMapFlags map_flags = 0;
vkok(vkMapMemory(device, result.gpu_data, offset, memory_requirements.size, map_flags, &data));
vkok(vkMapMemory(device, result.memory.handle, offset, memory_requirements.size, map_flags, &data));
result.address = (u64)data;
}
@ -686,7 +700,7 @@ fn VulkanImage vk_image_create(VkDevice device, const VkAllocationCallbacks* all
result.memory = vk_allocate_memory(device, allocation_callbacks, memory_properties, memory_requirements, flags, use_device_address_bit);
VkDeviceSize memory_offset = 0;
vkok(vkBindImageMemory(device, result.handle, result.memory, memory_offset));
vkok(vkBindImageMemory(device, result.handle, result.memory.handle, memory_offset));
VkImageViewCreateInfo view_create_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@ -1388,7 +1402,7 @@ fn void destroy_image(Renderer* renderer, VulkanImage image)
{
vkDestroyImageView(renderer->device, image.view, renderer->allocator);
vkDestroyImage(renderer->device, image.handle, renderer->allocator);
vkFreeMemory(renderer->device, image.memory, renderer->allocator);
vkFreeMemory(renderer->device, image.memory.handle, renderer->allocator);
}
fn void swapchain_recreate(Renderer* renderer, RenderWindow* window, VkSurfaceCapabilitiesKHR surface_capabilities)
@ -1548,6 +1562,9 @@ RenderWindow* renderer_window_initialize(Renderer* renderer, OSWindow window)
{
auto* pipeline_descriptor = &renderer->pipelines[pipeline_index];
auto* pipeline_instantiation = &result->pipeline_instantiations[pipeline_index];
pipeline_instantiation->vertex_buffer.gpu.type = BUFFER_TYPE_VERTEX;
pipeline_instantiation->index_buffer.gpu.type = BUFFER_TYPE_INDEX;
pipeline_instantiation->transient_buffer.type = BUFFER_TYPE_STAGING;
u16 descriptor_type_counter[DESCRIPTOR_TYPE_COUNT] = {};
@ -1680,6 +1697,7 @@ void renderer_window_frame_begin(Renderer* renderer, RenderWindow* window)
{
auto* pipeline_instantiation = &window->pipeline_instantiations[i];
pipeline_instantiation->vertex_buffer.cpu.length = 0;
pipeline_instantiation->vertex_buffer.count = 0;
pipeline_instantiation->index_buffer.cpu.length = 0;
}
}
@ -1691,14 +1709,23 @@ void buffer_destroy(Renderer* renderer, VulkanBuffer buffer)
vkDestroyBuffer(renderer->device, buffer.handle, renderer->allocator);
}
if (buffer.gpu_data)
if (buffer.memory.handle)
{
if (buffer.type == BUFFER_TYPE_STAGING)
{
vkUnmapMemory(renderer->device, buffer.gpu_data);
vkUnmapMemory(renderer->device, buffer.memory.handle);
}
vkFreeMemory(renderer->device, buffer.gpu_data, renderer->allocator);
vkFreeMemory(renderer->device, buffer.memory.handle, renderer->allocator);
}
}
fn void buffer_ensure_capacity(Renderer* renderer, VulkanBuffer* buffer, u64 needed_size)
{
if (unlikely(needed_size > buffer->memory.size))
{
buffer_destroy(renderer, *buffer);
*buffer = buffer_create(renderer, needed_size, buffer->type);
}
}
@ -1719,30 +1746,13 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
if (likely(pipeline_instantiation->vertex_buffer.cpu.length))
{
auto old_vertex_buffer = pipeline_instantiation->vertex_buffer.gpu;
auto old_index_buffer = pipeline_instantiation->index_buffer.gpu;
auto new_vertex_buffer_size = pipeline_instantiation->vertex_buffer.cpu.length * sizeof(pipeline_instantiation->vertex_buffer.cpu.pointer);
auto new_index_buffer_size = pipeline_instantiation->index_buffer.cpu.length * sizeof(pipeline_instantiation->index_buffer.cpu.pointer);
auto new_vertex_buffer_size = pipeline_instantiation->vertex_buffer.cpu.length * sizeof(*pipeline_instantiation->vertex_buffer.cpu.pointer);
auto new_index_buffer_size = pipeline_instantiation->index_buffer.cpu.length * sizeof(*pipeline_instantiation->index_buffer.cpu.pointer);
auto new_transient_buffer_size = new_vertex_buffer_size + new_index_buffer_size;
if (unlikely(new_transient_buffer_size))
{
buffer_destroy(renderer, pipeline_instantiation->transient_buffer);
pipeline_instantiation->transient_buffer = buffer_create(renderer, new_transient_buffer_size, BUFFER_TYPE_STAGING);
}
if (unlikely(new_vertex_buffer_size > old_vertex_buffer.size))
{
buffer_destroy(renderer, pipeline_instantiation->vertex_buffer.gpu);
pipeline_instantiation->vertex_buffer.gpu = buffer_create(renderer, new_vertex_buffer_size, BUFFER_TYPE_VERTEX);
}
if (unlikely(new_index_buffer_size > old_index_buffer.size))
{
buffer_destroy(renderer, pipeline_instantiation->index_buffer.gpu);
pipeline_instantiation->index_buffer.gpu = buffer_create(renderer, new_index_buffer_size, BUFFER_TYPE_INDEX);
}
buffer_ensure_capacity(renderer, &pipeline_instantiation->transient_buffer, new_transient_buffer_size);
buffer_ensure_capacity(renderer, &pipeline_instantiation->vertex_buffer.gpu, new_vertex_buffer_size);
buffer_ensure_capacity(renderer, &pipeline_instantiation->index_buffer.gpu, new_index_buffer_size);
buffer_copy_to_host(pipeline_instantiation->transient_buffer, (Slice(HostBufferCopy)) array_to_slice(((HostBufferCopy[]) {
(HostBufferCopy) {
@ -1853,8 +1863,7 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
if (likely(pipeline_instantiation->vertex_buffer.cpu.length))
{
auto bind_pipeline = frame->bound_pipeline != i;
// if (unlikely(bind_pipeline))
// Bind pipeline and descriptor sets
{
vkCmdBindPipeline(frame->command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->handle);
// print("Binding pipeline: 0x{u64}\n", pipeline->handle);
@ -1866,14 +1875,14 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
frame->bound_pipeline = i;
}
auto bind_index_buffer = frame->index_buffer != pipeline_instantiation->index_buffer.gpu.handle;
// if (unlikely(bind_index_buffer))
// Bind index buffer
{
vkCmdBindIndexBuffer(frame->command_buffer, pipeline_instantiation->index_buffer.gpu.handle, 0, VK_INDEX_TYPE_UINT32);
frame->index_buffer = pipeline_instantiation->index_buffer.gpu.handle;
// print("Binding descriptor sets: 0x{u64}\n", frame->index_buffer);
}
// Send vertex buffer and screen dimensions to the shader
auto push_constants = (GPUDrawPushConstants)
{
.vertex_buffer = pipeline_instantiation->vertex_buffer.gpu.address,
@ -1881,9 +1890,6 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
.height = window->height,
};
static_assert(sizeof(push_constants) == sizeof(frame->push_constants));
// if (unlikely(memcmp(&push_constants, &frame->push_constants, sizeof(push_constants)) != 0))
{
auto push_constant_range = pipeline->push_constant_ranges[0];
vkCmdPushConstants(frame->command_buffer, pipeline->layout, push_constant_range.stageFlags, push_constant_range.offset, push_constant_range.size, &push_constants);
@ -2200,9 +2206,13 @@ void window_rect_texture_update_end(Renderer* renderer, RenderWindow* window)
window_texture_update_end(renderer, window, BB_PIPELINE_RECT);
}
void window_pipeline_add_vertices(RenderWindow* window, BBPipeline pipeline_index, String vertex_memory)
u32 window_pipeline_add_vertices(RenderWindow* window, BBPipeline pipeline_index, String vertex_memory, u32 vertex_count)
{
vb_copy_string(&window->pipeline_instantiations[pipeline_index].vertex_buffer.cpu, vertex_memory);
auto* vertex_buffer = &window->pipeline_instantiations[pipeline_index].vertex_buffer;
vb_copy_string(&vertex_buffer->cpu, vertex_memory);
auto vertex_offset = vertex_buffer->count;
vertex_buffer->count = vertex_offset + vertex_count;
return vertex_offset;
}
void window_pipeline_add_indices(RenderWindow* window, BBPipeline pipeline_index, Slice(u32) indices)