birth-software/bloat-buster
1
0
Fork 0
Code Issues Pull Requests 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/image_loader.h>
#include <std/font_provider.h> #include <std/font_provider.h>
STRUCT(Vec4)
{
f32 v[4];
}__attribute__((aligned(16)));
STRUCT(Vertex) STRUCT(Vertex)
{ {
f32 x; f32 x;
@ -43,65 +38,69 @@ fn TextureIndex white_texture_create(Arena* arena, Renderer* renderer)
return white_texture; 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 height = texture_atlas.ascent - texture_atlas.descent;
auto x_offset = width / 2; for (u64 i = 0; i < string.length; i += 1)
auto y_offset = height / 2;
for (u64 i = 0; i < string.length; i += 1, index_offset += 4)
{ {
auto ch = string.pointer[i]; auto ch = string.pointer[i];
auto* character = &texture_atlas.characters[ch]; auto* character = &texture_atlas.characters[ch];
auto pos_x = x_offset; 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_x = character->x;
auto uv_y = character->y; auto uv_y = character->y;
auto uv_width = character->width; auto uv_width = character->width;
auto uv_height = character->height; auto uv_height = character->height;
*vb_add(vertices, 1) = (Vertex) { Vertex vertices[] = {
.x = pos_x, (Vertex) {
.y = pos_y, .x = pos_x,
.uv_x = (f32)uv_x, .y = pos_y,
.uv_y = (f32)uv_y, .uv_x = (f32)uv_x,
.color = color, .uv_y = (f32)uv_y,
.texture_index = texture_index, .color = color,
}; .texture_index = texture_index,
*vb_add(vertices, 1) = (Vertex) { },
.x = pos_x + character->width, (Vertex) {
.y = pos_y, .x = pos_x + character->width,
.uv_x = (f32)(uv_x + uv_width), .y = pos_y,
.uv_y = (f32)uv_y, .uv_x = (f32)(uv_x + uv_width),
.color = color, .uv_y = (f32)uv_y,
.texture_index = texture_index, .color = color,
}; .texture_index = texture_index,
*vb_add(vertices, 1) = (Vertex) { },
.x = pos_x, (Vertex) {
.y = pos_y + character->height, .x = pos_x,
.uv_x = (f32)uv_x, .y = pos_y + character->height,
.uv_y = (f32)(uv_y + uv_height), .uv_x = (f32)uv_x,
.color = color, .uv_y = (f32)(uv_y + uv_height),
.texture_index = texture_index, .color = color,
}; .texture_index = texture_index,
*vb_add(vertices, 1) = (Vertex) { },
.x = pos_x + character->width, (Vertex) {
.y = pos_y + character->height, .x = pos_x + character->width,
.uv_x = (f32)(uv_x + uv_width), .y = pos_y + character->height,
.uv_y = (f32)(uv_y + uv_height), .uv_x = (f32)(uv_x + uv_width),
.color = color, .uv_y = (f32)(uv_y + uv_height),
.texture_index = texture_index, .color = color,
.texture_index = texture_index,
},
}; };
*vb_add(indices, 1) = index_offset + 0; auto vertex_offset = window_pipeline_add_vertices(window, BB_PIPELINE_RECT, (String)array_to_bytes(vertices), array_length(vertices));
*vb_add(indices, 1) = index_offset + 1;
*vb_add(indices, 1) = index_offset + 2; u32 indices[] = {
*vb_add(indices, 1) = index_offset + 1; vertex_offset + 0,
*vb_add(indices, 1) = index_offset + 3; vertex_offset + 1,
*vb_add(indices, 1) = index_offset + 2; 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]]; 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; x_offset += character->advance + kerning;
} }
} }
@ -144,89 +143,30 @@ void run_app()
auto font_path = auto font_path =
#ifdef _WIN32 #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__) #elif defined(__linux__)
strlit("/usr/share/fonts/TTF/FiraSans-Regular.ttf") strlit("/usr/share/fonts/TTF/FiraSans-Regular.ttf");
#else #else
strlit("WRONG_PATH");
#endif #endif
;
window_rect_texture_update_begin(render_window); 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}; auto white_texture = white_texture_create(state.arena, renderer);
// static_assert(sizeof(color) == 4 * sizeof(float)); auto monospace_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
// .font_path = font_path,
// u32 texture_index = 1; .text_height = 50,
// // draw_string(renderer, &vertices, &indices, window_size.width, window_size.height, color, strlit("He"), texture_atlas, texture_index); });
// auto proportional_font = monospace_font;
// // auto proportional_font = font_texture_atlas_create(state.arena, renderer, (TextureAtlasCreate) {
// vb_copy_array(&vertices, box_vertices); // .font_path = font_path,
// vb_copy_array(&indices, box_indices); // .text_height = 36,
// // });
// auto vertex_buffer_size = sizeof(*vertices.pointer) * vertices.length; window_queue_rect_texture_update(render_window, RECT_TEXTURE_SLOT_WHITE, white_texture);
// auto index_buffer_size = sizeof(*indices.pointer) * indices.length; 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);
// auto vertex_buffer = renderer_buffer_create(renderer, vertex_buffer_size, BUFFER_TYPE_VERTEX);
// auto vertex_buffer_device_address = buffer_address(vertex_buffer); window_rect_texture_update_end(renderer, render_window);
// 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,
// },
// })),
// },
// })));
while (!os_window_should_close(os_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); // print("Mouse position: ({f64}, {f64})\n", mouse_position.x, mouse_position.y);
renderer_window_frame_begin(renderer, render_window); 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 }; // u32 box_width = 10;
// u32 box_height = 10;
Vertex box_vertices[] = { // auto box_color = Color4(1, 0, 0, 1);
{ //
.x = box_x, // Vertex box_vertices[] = {
.y = box_y, // {
.color = box_color, // .x = mouse_position.x,
}, // .y = mouse_position.y,
{ // .color = box_color,
.x = box_x + box_width, // },
.y = box_y, // {
.color = box_color, // .x = mouse_position.x + box_width,
}, // .y = mouse_position.y,
{ // .color = box_color,
.x = box_x, // },
.y = box_y + box_height, // {
.color = box_color, // .x = mouse_position.x,
}, // .y = mouse_position.y + box_height,
{ // .color = box_color,
.x = box_x + box_width, // },
.y = box_y + box_height, // {
.color = box_color, // .x = mouse_position.x + box_width,
}, // .y = mouse_position.y + box_height,
}; // .color = box_color,
// },
u32 box_indices[] = { // };
0, 1, 2, //
1, 3, 2, // 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[] = {
window_pipeline_add_vertices(render_window, BB_PIPELINE_RECT, (String)array_to_bytes(box_vertices)); // vertex_offset + 0, vertex_offset + 1, vertex_offset + 2,
window_pipeline_add_indices(render_window, BB_PIPELINE_RECT, (Slice(u32))array_to_slice(box_indices)); // 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); 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 // TODO: deinitialization

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

@ -11,6 +11,13 @@ typedef struct Renderer Renderer;
typedef struct RenderWindow RenderWindow; typedef struct RenderWindow RenderWindow;
typedef struct Pipeline Pipeline; 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 typedef enum BBPipeline
{ {
BB_PIPELINE_RECT, 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_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_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); 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() void main()
{ {
//load vertex data from device address
Vertex v = PushConstants.vertex_buffer.vertices[gl_VertexIndex]; Vertex v = PushConstants.vertex_buffer.vertices[gl_VertexIndex];
float width = PushConstants.width; float width = PushConstants.width;
float height = PushConstants.height; float height = PushConstants.height;
//output data //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_uv = vec2(v.uv_x, v.uv_y);
out_color = v.color; out_color = v.color;
out_texture_index = v.texture_index; out_texture_index = v.texture_index;
//debugPrintfEXT("Position: (%f, %f, %f)\n", v.position.x, v.position.y, v.position.z); //debugPrintfEXT("Position: (%f, %f)\n", v.x, v.y);
//debugPrintfEXT("Color: (%f, %f, %f)\n", v.color.x, v.color.y, v.color.z); //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 max_row_height = 0;
u32 first_character = ' '; u32 first_character = ' ';
u32 last_character = '~'; u32 last_character = '~';
for (auto i = first_character; i <= last_character; ++i) for (auto i = first_character; i <= last_character; ++i)
{ {
u32 width; u32 width;
@ -77,38 +78,20 @@ TextureAtlas font_texture_atlas_create(Arena* arena, Renderer* renderer, Texture
character->width = width; character->width = width;
character->height = height; 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* source = bitmap;
auto* destination = result.pointer; auto* destination = result.pointer;
for (u32 bitmap_y = 0; bitmap_y < height; bitmap_y += 1) for (u32 bitmap_y = 0; bitmap_y < height; bitmap_y += 1)
{ {
for (u32 bitmap_x = 0; bitmap_x < width; bitmap_x += 1) for (u32 bitmap_x = 0; bitmap_x < width; bitmap_x += 1)
{ {
auto source_index = bitmap_y * width + bitmap_x; auto source_index = bitmap_y * width + bitmap_x;
auto destination_index = ((height - bitmap_y - 1) + y) * result.width + bitmap_x + x; auto destination_index = (bitmap_y + y) * result.width + (bitmap_x + x);
destination[destination_index] = ((u32)(source[source_index]) << 24) | 0xffffff; 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; x += width;
stbtt_FreeBitmap(bitmap, 0); stbtt_FreeBitmap(bitmap, 0);

98
bootstrap/std/render.c
View File

@ -40,11 +40,17 @@ STRUCT(VulkanImageCreate)
VkImageUsageFlags usage; VkImageUsageFlags usage;
}; };
STRUCT(GPUMemory)
{
VkDeviceMemory handle;
u64 size;
};
STRUCT(VulkanImage) STRUCT(VulkanImage)
{ {
VkImage handle; VkImage handle;
VkImageView view; VkImageView view;
VkDeviceMemory memory; GPUMemory memory;
VkFormat format; VkFormat format;
}; };
@ -89,7 +95,7 @@ STRUCT(ImmediateContext)
STRUCT(VulkanBuffer) STRUCT(VulkanBuffer)
{ {
VkBuffer handle; VkBuffer handle;
VkDeviceMemory gpu_data; GPUMemory memory;
u64 address; u64 address;
VkDeviceSize size; VkDeviceSize size;
BufferType type; BufferType type;
@ -107,6 +113,7 @@ STRUCT(VertexBuffer)
{ {
VulkanBuffer gpu; VulkanBuffer gpu;
VirtualBuffer(u8) cpu; VirtualBuffer(u8) cpu;
u32 count;
}; };
STRUCT(IndexBuffer) 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) for (u64 i = 0; i < regions.length; i += 1)
{ {
auto region = regions.pointer[i]; 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; 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; u32 memory_type_index;
for (memory_type_index = 0; memory_type_index < memory_properties.memoryTypeCount; memory_type_index += 1) 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 = { VkMemoryAllocateInfo allocate_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.pNext = 0,
.allocationSize = memory_requirements.size, .allocationSize = memory_requirements.size,
.memoryTypeIndex = memory_type_index, .memoryTypeIndex = memory_type_index,
}; };
@ -437,7 +451,7 @@ fn VkDeviceMemory vk_allocate_memory(VkDevice device, const VkAllocationCallback
VkDeviceMemory memory = 0; VkDeviceMemory memory = 0;
vkok(vkAllocateMemory(device, &allocate_info, allocation_callbacks, &memory)); 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) 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); vkGetBufferMemoryRequirements(device, result.handle, &memory_requirements);
u8 use_device_address_bit = !!(create_info.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT); 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; 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); 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)); 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; void* data = 0;
VkDeviceSize offset = 0; VkDeviceSize offset = 0;
VkMemoryMapFlags map_flags = 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; 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); result.memory = vk_allocate_memory(device, allocation_callbacks, memory_properties, memory_requirements, flags, use_device_address_bit);
VkDeviceSize memory_offset = 0; 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 = { VkImageViewCreateInfo view_create_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_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); vkDestroyImageView(renderer->device, image.view, renderer->allocator);
vkDestroyImage(renderer->device, image.handle, 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) 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_descriptor = &renderer->pipelines[pipeline_index];
auto* pipeline_instantiation = &result->pipeline_instantiations[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] = {}; 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]; auto* pipeline_instantiation = &window->pipeline_instantiations[i];
pipeline_instantiation->vertex_buffer.cpu.length = 0; pipeline_instantiation->vertex_buffer.cpu.length = 0;
pipeline_instantiation->vertex_buffer.count = 0;
pipeline_instantiation->index_buffer.cpu.length = 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); vkDestroyBuffer(renderer->device, buffer.handle, renderer->allocator);
} }
if (buffer.gpu_data) if (buffer.memory.handle)
{ {
if (buffer.type == BUFFER_TYPE_STAGING) 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)) if (likely(pipeline_instantiation->vertex_buffer.cpu.length))
{ {
auto old_vertex_buffer = pipeline_instantiation->vertex_buffer.gpu; auto new_vertex_buffer_size = pipeline_instantiation->vertex_buffer.cpu.length * sizeof(*pipeline_instantiation->vertex_buffer.cpu.pointer);
auto old_index_buffer = pipeline_instantiation->index_buffer.gpu; 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; auto new_transient_buffer_size = new_vertex_buffer_size + new_index_buffer_size;
if (unlikely(new_transient_buffer_size)) 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_destroy(renderer, pipeline_instantiation->transient_buffer); buffer_ensure_capacity(renderer, &pipeline_instantiation->index_buffer.gpu, new_index_buffer_size);
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_copy_to_host(pipeline_instantiation->transient_buffer, (Slice(HostBufferCopy)) array_to_slice(((HostBufferCopy[]) { buffer_copy_to_host(pipeline_instantiation->transient_buffer, (Slice(HostBufferCopy)) array_to_slice(((HostBufferCopy[]) {
(HostBufferCopy) { (HostBufferCopy) {
@ -1853,8 +1863,7 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
if (likely(pipeline_instantiation->vertex_buffer.cpu.length)) if (likely(pipeline_instantiation->vertex_buffer.cpu.length))
{ {
auto bind_pipeline = frame->bound_pipeline != i; // Bind pipeline and descriptor sets
// if (unlikely(bind_pipeline))
{ {
vkCmdBindPipeline(frame->command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->handle); vkCmdBindPipeline(frame->command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->handle);
// print("Binding pipeline: 0x{u64}\n", 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; frame->bound_pipeline = i;
} }
auto bind_index_buffer = frame->index_buffer != pipeline_instantiation->index_buffer.gpu.handle; // Bind index buffer
// if (unlikely(bind_index_buffer))
{ {
vkCmdBindIndexBuffer(frame->command_buffer, pipeline_instantiation->index_buffer.gpu.handle, 0, VK_INDEX_TYPE_UINT32); vkCmdBindIndexBuffer(frame->command_buffer, pipeline_instantiation->index_buffer.gpu.handle, 0, VK_INDEX_TYPE_UINT32);
frame->index_buffer = pipeline_instantiation->index_buffer.gpu.handle; frame->index_buffer = pipeline_instantiation->index_buffer.gpu.handle;
// print("Binding descriptor sets: 0x{u64}\n", frame->index_buffer); // print("Binding descriptor sets: 0x{u64}\n", frame->index_buffer);
} }
// Send vertex buffer and screen dimensions to the shader
auto push_constants = (GPUDrawPushConstants) auto push_constants = (GPUDrawPushConstants)
{ {
.vertex_buffer = pipeline_instantiation->vertex_buffer.gpu.address, .vertex_buffer = pipeline_instantiation->vertex_buffer.gpu.address,
@ -1881,9 +1890,6 @@ void renderer_window_frame_end(Renderer* renderer, RenderWindow* window)
.height = window->height, .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]; 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); 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); 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) void window_pipeline_add_indices(RenderWindow* window, BBPipeline pipeline_index, Slice(u32) indices)