From 438015b8427ae9982ae88b6e996374fea399d539 Mon Sep 17 00:00:00 2001 From: Andreew Gregory Date: Sun, 30 Nov 2025 03:54:02 +0300 Subject: [PATCH] =?UTF-8?q?Saving=20progress.=20Rewrote=20r0=5Fscene.h,=20?= =?UTF-8?q?r0=5Fassets.h,=20vk=5Fctx=20struct=20according=20to=20new=20des?= =?UTF-8?q?ign.=20=D0=9D=D0=BE=20=D0=BF=D0=BE=D1=82=D0=BE=D0=BC=20=D1=8F?= =?UTF-8?q?=20=D0=BE=D1=82=D0=B2=D0=BB=D1=91=D0=BA=D1=81=D1=8F=20=D0=BE?= =?UTF-8?q?=D1=82=20=D0=BF=D1=80=D0=BE=D0=B3=D1=80=D0=B5=D1=81=D1=81=D0=B0?= =?UTF-8?q?=20=D0=B8=D0=B7-=D0=B7=D0=B0=20=D0=BE=D0=B1=D1=8F=D0=B7=D0=B0?= =?UTF-8?q?=D0=BD=D0=BD=D0=BE=D1=81=D1=82=D0=B5=D0=B9=20=D0=BD=D1=8F=D0=BD?= =?UTF-8?q?=D1=8C=D0=BA=D0=B8.=20Anyway.=20I=20need=20to=20test=20somrthin?= =?UTF-8?q?g=20really=20quick.=20Going=20back=20to=20master?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMakeLists.txt | 4 +- Makefile | 3 + src/l1/anne/some_tests.h | 15 +- src/l2/margaret/vulkan_memory_claire.h | 5 +- src/l2/margaret/vulkan_utils.h | 12 + src/l2/tests/r0/r0.c | 864 +++++++++++-------------- src/l2/tests/r0/r0_assets.h | 55 +- src/l2/tests/r0/r0_scene.h | 160 +++-- 8 files changed, 487 insertions(+), 631 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 157cf5a..b4cfcf2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,8 +38,8 @@ add_compile_options(-fno-trapping-math) add_executable(codegen_l1_5 src/l1_5/anne/codegen.c) -#add_executable(0_render_test src/l2/tests/r0/r0.c gen/l_wl_protocols/xdg-shell-private.c) -#target_link_libraries(0_render_test -lvulkan -lwayland-client -lm -lxkbcommon -lpng) +add_executable(0_render_test src/l2/tests/r0/r0.c gen/l_wl_protocols/xdg-shell-private.c) +target_link_libraries(0_render_test -lvulkan -lwayland-client -lm -lxkbcommon -lpng) #add_executable(0r_tex_init_prep src/l2/tests/r0/r0_tex_init_prep.c) #target_link_libraries(0r_tex_init_prep -lm -lpng) diff --git a/Makefile b/Makefile index e4215fc..cae85c1 100644 --- a/Makefile +++ b/Makefile @@ -53,6 +53,9 @@ gen/l_wl_protocols/xdg-shell-private.c: $(wl_protocols)/stable/xdg-shell/xdg-she xdg_shell_private := gen/l_wl_protocols/xdg-shell-private.c l_wl_protocols := gen/l_wl_protocols/xdg-shell-client.h $(xdg_shell_private) +.PHONY: gen/l_wl_protocols +gen/l_wl_protocols : $(l_wl_protocols) + out/l2/t0: src/l2/tests/data_structures/t0.c $(HEADERS_gen_l1_5) mkdir -p out/l2 diff --git a/src/l1/anne/some_tests.h b/src/l1/anne/some_tests.h index 6088aa1..994daea 100644 --- a/src/l1/anne/some_tests.h +++ b/src/l1/anne/some_tests.h @@ -10,20 +10,19 @@ void generate_headers_for_r0_r1_r2_r3() { SpanU8 ns = cstr("r0"); generate_eve_span_company_for_primitive(l, ns, cstr("GenericMeshVertex"), true, true); generate_eve_span_company_for_non_primitive_clonable(l, ns, cstr("GenericMeshInSceneTemplate"), true, false); - generate_eve_span_company_for_primitive(l, ns, cstr("GenericMeshInstance"), true, false); + // generate_eve_span_company_for_primitive(l, ns, cstr("GenericMeshInstance"), true, false); generate_eve_span_company_for_primitive(l, ns, cstr("ShinyMeshVertex"), true, true); - generate_eve_span_company_for_primitive(l, ns, cstr("ShinyMeshInstance"), true, false); + // generate_eve_span_company_for_primitive(l, ns, cstr("ShinyMeshInstance"), true, false); generate_eve_span_company_for_non_primitive_clonable(l, ns, cstr("ShinyMeshInSceneTemplate"), true, false); - generate_eve_span_company_for_primitive(l, ns, cstr("Pipeline0Spotlight"), true, false); - generate_eve_span_company_for_primitive(l, ns, cstr("Pipeline0PointLight"), true, false); + // generate_eve_span_company_for_primitive(l, ns, cstr("Pipeline0Spotlight"), true, false); + // generate_eve_span_company_for_primitive(l, ns, cstr("Pipeline0PointLight"), true, false); generate_eve_span_company_for_primitive(l, ns, cstr("Wimbzle"), true, false); generate_eve_span_company_for_primitive(l, ns, cstr("Nibzle"), true, false); /* r0_scene.h */ - generate_eve_span_company_for_non_primitive_non_clonable(l, ns, cstr("UsedGenericModelOnScene"), true, false); - generate_eve_span_company_for_non_primitive_non_clonable(l, ns, cstr("UsedShinyModelOnScene"), true, false); + generate_eve_span_company_for_primitive(l, ns, cstr("GenericModelOnSceneMem"), true, false); + generate_eve_span_company_for_primitive(l, ns, cstr("ShinyModelOnSceneMem"), true, false); /* r0 */ - generate_eve_span_company_for_primitive(l, ns, cstr("GenericModelTopAndTexInMemoryInfo"), true, false); - generate_eve_span_company_for_primitive(l, ns, cstr("ShinyModelTopInMemoryInfo"), true, false); + generate_eve_span_company_for_primitive(l, ns, cstr("GenericModelTexVulkPointers"), true, false); } mkdir_nofail("l1/eve/r2"); { /* r2 */ diff --git a/src/l2/margaret/vulkan_memory_claire.h b/src/l2/margaret/vulkan_memory_claire.h index 889e282..6a56a3c 100644 --- a/src/l2/margaret/vulkan_memory_claire.h +++ b/src/l2/margaret/vulkan_memory_claire.h @@ -1313,8 +1313,9 @@ MargaretMemAllocatorDemands MargaretMemAllocator_carry_out_request( return demands; } -char* MargaretMemAllocator_get_host_visible_buffer_ptr( - RBTreeNode_KVPU64ToMargaretMAOccupation* occ_it){ +typedef RBTreeNode_KVPU64ToMargaretMAOccupation* MargaretMAIterator; + +char* MargaretMAIterator_get_mapped(MargaretMAIterator occ_it){ const MargaretMemAllocatorOneBlock* bl = &occ_it->value.block->el; assert(occ_it->value.me.variant == MargaretMemoryOccupation_Buffer); assert(bl->mapped_memory); diff --git a/src/l2/margaret/vulkan_utils.h b/src/l2/margaret/vulkan_utils.h index 819eac5..c9493e1 100644 --- a/src/l2/margaret/vulkan_utils.h +++ b/src/l2/margaret/vulkan_utils.h @@ -1311,4 +1311,16 @@ VkDescriptorSet margaret_allocate_descriptor_set(VkDevice device, VkDescriptorPo return descriptor_set; } +/* Aborts on error */ +void margaret_reset_and_begin_command_buffer(VkCommandBuffer command_buffer){ + check(vkResetCommandBuffer(command_buffer, 0) == VK_SUCCESS); + check(vkBeginCommandBuffer(command_buffer, + &(VkCommandBufferBeginInfo){ .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }) == VK_SUCCESS); +} + +/* Aborts on error */ +void margaret_end_command_buffer(VkCommandBuffer command_buffer){ + check(vkEndCommandBuffer(command_buffer) == VK_SUCCESS); +} + #endif diff --git a/src/l2/tests/r0/r0.c b/src/l2/tests/r0/r0.c index a4ac60f..cea36ce 100644 --- a/src/l2/tests/r0/r0.c +++ b/src/l2/tests/r0/r0.c @@ -557,8 +557,6 @@ PipelineHands create_graphics_pipeline_0_b( } - - // todo: generate this function in l2 VkRenderPass create_render_pass_1(VkDevice logical_device, VkFormat image_format) { // Color attachments array for our render pass @@ -730,7 +728,7 @@ PipelineHands create_graphics_pipeline_1( VkPipelineLayout pipeline_layout; if (vkCreatePipelineLayout(device, &layout_crinfo, NULL, &pipeline_layout) != VK_SUCCESS) abortf("vkCreatePipelineLayout"); - // todo: kill myself (update: still todo (update: still not done )) update: work in progress (update: medium priority) + VkGraphicsPipelineCreateInfo pipeline_crinfo = { .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, .stageCount = ARRAY_SIZE(shader_stages_crinfo), @@ -778,20 +776,12 @@ VkFramebuffer create_IT1_framebuffer(VkDevice device, VkImageView IT1_view, VkIm } void record_cmd_set_viewport_and_scissors(VkCommandBuffer command_buffer, VkExtent2D image_extent) { - VkViewport viewport = { - .x = 0.0f, - .y = 0.0f, - .width = (float)(image_extent.width), - .height = (float)(image_extent.height), - .minDepth = 0.0f, - .maxDepth = 1.0f, - }; - vkCmdSetViewport(command_buffer, 0, 1, &viewport); - VkRect2D scissor = { - .offset = (VkOffset2D){0, 0}, - .extent = image_extent, - }; - vkCmdSetScissor(command_buffer, 0, 1, &scissor); + vkCmdSetViewport(command_buffer, 0, 1, &(VkViewport){ + .x = 0.0f, .y = 0.0f, + .width = (float)(image_extent.width), .height = (float)(image_extent.height), + .minDepth = 0.0f, .maxDepth = 1.0f, + }); + vkCmdSetScissor(command_buffer, 0, 1, &(VkRect2D){ .offset = (VkOffset2D){0, 0}, .extent = image_extent}); } typedef struct { @@ -824,63 +814,37 @@ typedef struct { } UsedVulkanQueues; typedef struct { - MargaretBufferInMemoryInfo vbo; - MargaretBufferInMemoryInfo ebo; - /* We store image in yet another meaningless buffer (will change it later) */ - TextureDataR8G8B8A8 reading_diffuse; - TextureDataR8G8B8A8 reading_normal; - TextureDataR8 reading_specular; - /* Filled during first (and the only) memory init */ - MargaretImageInMemoryInfo diffuse; - MargaretImageInMemoryInfo normal; - MargaretImageInMemoryInfo specular; - /* will be filled in later */ VkImageView diffuse_view; VkImageView normal_view; VkImageView specular_view; - /* Each generic model has ti's own descriptor set - * It's because it has it's own textures. But it also has copies of references to light UBO + /* Each generic model has its own descriptor set + * It's because it has its own textures. But it also has copies of references to light UBO * Because I am to lazy to create two set layouts for generic model pipeline */ VkDescriptorSet p_0a_set_0; -} GenericModelTopAndTexInMemoryInfo; - -#include "../../../../gen/l1/eve/r0/VecGenericModelTopAndTexInMemoryInfo.h" - -typedef struct { - MargaretBufferInMemoryInfo vbo; - MargaretBufferInMemoryInfo ebo; -} ShinyModelTopInMemoryInfo; - -#include "../../../../gen/l1/eve/r0/VecShinyModelTopInMemoryInfo.h" - - +} GenericModelTexVulkPointers; +#include "../../../../gen/l1/eve/r0/VecGenericModelTexVulkPointers.h" void reset_and_record_command_buffer_0( VkCommandBuffer command_buffer, VkRenderPass render_pass_0, const PipelineHands* pipeline_and_layout_0a, const PipelineHands* pipeline_and_layout_0b, VkFramebuffer result_framebuffer, VkExtent2D image_extent, - const Scene* scene, const VecGenericModelTopAndTexInMemoryInfo* generic_models, + const Scene* scene, + /* We need descriptor sets for generic meshes from here */ + const VecGenericModelTexVulkPointers* generic_models, VkDescriptorSet descriptor_set_for_pipeline_0b, mat4 proj_cam_t, vec3 camera_pos ) { - if (vkResetCommandBuffer(command_buffer, 0) != VK_SUCCESS) - abortf("vkResetCommandBuffer"); - VkCommandBufferBeginInfo info_begin = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; - if (vkBeginCommandBuffer(command_buffer, &info_begin) != VK_SUCCESS) - abortf("vkBeginCommandBuffer"); + margaret_reset_and_begin_command_buffer(command_buffer); - VkClearValue clear_values[2] = {{.color = scene->color}, {.depthStencil = {.depth = 1, .stencil = 0}}}; - VkRenderPassBeginInfo renderpass_begin = { + vkCmdBeginRenderPass(command_buffer, &(VkRenderPassBeginInfo){ .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .renderPass = render_pass_0, .framebuffer = result_framebuffer, .renderArea.offset = (VkOffset2D){0, 0}, .renderArea.extent = image_extent, - .clearValueCount = ARRAY_SIZE(clear_values), - .pClearValues = clear_values, - }; - - vkCmdBeginRenderPass(command_buffer, &renderpass_begin, VK_SUBPASS_CONTENTS_INLINE); + .clearValueCount = 2, + .pClearValues = (VkClearValue[]){{.color = scene->color}, {.depthStencil = {.depth = 1, .stencil = 0}}}, + }, VK_SUBPASS_CONTENTS_INLINE); vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_and_layout_0a->pipeline); // We forgot that viewport is not built into our pipeline @@ -891,17 +855,19 @@ void reset_and_record_command_buffer_0( vkCmdPushConstants(command_buffer, pipeline_and_layout_0a->pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(mat4), sizeof(vec3), &camera_pos); for (size_t i = 0; i < scene->generic_models.len; i++) { - const UsedGenericModelOnScene *model = VecUsedGenericModelOnScene_at(&scene->generic_models, i); - VkBuffer attached_buffers[2] = { model->model.vbo, model->model.instance_attr_buf }; - // We use our whole buffer, no need for offset - VkDeviceSize offsets_in_buffers[2] = {0, model->model.instance_attr_buf_offset}; - assert(ARRAY_SIZE(attached_buffers) == 2 && ARRAY_SIZE(offsets_in_buffers) == 2); - vkCmdBindVertexBuffers(command_buffer, 0, 2, attached_buffers, offsets_in_buffers); - vkCmdBindIndexBuffer(command_buffer, model->model.ebo, 0, VK_INDEX_TYPE_UINT32); + const GenericModelOnSceneMem *model = VecGenericModelOnSceneMem_at(&scene->generic_models, i); + VkDescriptorSet model_indiv_descriptor_set_0 = VecGenericModelTexVulkPointers_at(generic_models, i)->p_0a_set_0; + // todo: rewrite using compound literal syntax + VkBuffer attached_buffers[2] = { model->vbo->value.me.buf.buffer, model->instance_attr_buf->value.me.buf.buffer}; + // We use our whole buffers, no need for offset + VkDeviceSize offsets_in_buffers[2] = {0, 0}; + vkCmdBindVertexBuffers(command_buffer, 0, + 2, attached_buffers, offsets_in_buffers); + vkCmdBindIndexBuffer(command_buffer, model->ebo->value.me.buf.buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdBindDescriptorSets( command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_and_layout_0a->pipeline_layout, 0, - 1, &VecGenericModelTopAndTexInMemoryInfo_at(generic_models, i)->p_0a_set_0, 0, NULL); - vkCmdDrawIndexed(command_buffer, model->model.indexes, model->instances.len, 0, 0, 0); + 1, &model_indiv_descriptor_set_0, 0, NULL); + vkCmdDrawIndexed(command_buffer, model->indexes, model->instance_vec_len, 0, 0, 0); } vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_and_layout_0b->pipeline); @@ -914,19 +880,17 @@ void reset_and_record_command_buffer_0( command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_and_layout_0b->pipeline_layout, 0, 1, &descriptor_set_for_pipeline_0b, 0, NULL); for (size_t i = 0; i < scene->shiny_models.len; i++) { - const UsedShinyModelOnScene* model = VecUsedShinyModelOnScene_at(&scene->shiny_models, i); - VkBuffer attached_buffers[2] = { model->model.vbo, model->model.instance_attr_buf }; - // We use our whole buffer, no need for offset - VkDeviceSize offsets_in_buffers[2] = {0, model->model.instance_attr_buf_offset}; - assert(ARRAY_SIZE(attached_buffers) == 2 && ARRAY_SIZE(offsets_in_buffers) == 2); + const ShinyModelOnSceneMem* model = VecShinyModelOnSceneMem_at(&scene->shiny_models, i); + VkBuffer attached_buffers[2] = { model->vbo->value.me.buf.buffer, model->instance_attr_buf->value.me.buf.buffer }; + // Same. We use our whole buffer, no need for offset + VkDeviceSize offsets_in_buffers[2] = {0, 0}; vkCmdBindVertexBuffers(command_buffer, 0, 2, attached_buffers, offsets_in_buffers); - vkCmdBindIndexBuffer(command_buffer, model->model.ebo, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(command_buffer, model->model.indexes, model->instances.len, 0, 0, 0); + vkCmdBindIndexBuffer(command_buffer, model->ebo->value.me.buf.buffer, 0, VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(command_buffer, model->indexes, model->instance_vec_len, 0, 0, 0); } vkCmdEndRenderPass(command_buffer); - if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) - abortf("vkEndCommandBuffer"); + margaret_end_command_buffer(command_buffer); } void reset_and_record_command_buffer_1( @@ -936,21 +900,15 @@ void reset_and_record_command_buffer_1( VkExtent2D max_win_size, const Scene* scene, VkDescriptorSet descriptor_set_for_pipeline_1 ) { - if (vkResetCommandBuffer(command_buffer, 0) != VK_SUCCESS) - abortf("vkResetCommandBuffer"); - VkCommandBufferBeginInfo info_begin = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; - if (vkBeginCommandBuffer(command_buffer, &info_begin) != VK_SUCCESS) - abortf("vkBeginCommandBuffer"); + margaret_reset_and_begin_command_buffer(command_buffer); - VkRenderPassBeginInfo renderpass_begin = { + vkCmdBeginRenderPass(command_buffer, &(VkRenderPassBeginInfo){ .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .renderPass = render_pass_1, .framebuffer = swapchain_image_framebuffer, .renderArea.offset = (VkOffset2D){0, 0}, .renderArea.extent = image_extent, - }; - - vkCmdBeginRenderPass(command_buffer, &renderpass_begin, VK_SUBPASS_CONTENTS_INLINE); + }, VK_SUBPASS_CONTENTS_INLINE); vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_and_layout_1->pipeline); record_cmd_set_viewport_and_scissors(command_buffer, image_extent); @@ -975,92 +933,67 @@ void reset_and_record_command_buffer_1( vkCmdDraw(command_buffer, 3, 1, 0, 0); vkCmdEndRenderPass(command_buffer); - if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) - abortf("vkEndCommandBuffer"); + margaret_end_command_buffer(command_buffer); } -// todo: kill myself -/* First, we copy our scene information to void* host_mem_buffer_mem. - * Then, we record a command buffer that would copy these specific regions to corresponding device buffers - * It's up to you to submit command_buffer +/* This function records a command buffer that copies EVERYTHING. You won't normally need to copy every single thing, + * but here you have the most bold solution. Resets + starts + ends command buffer * */ -void copy_scene_info_to_buffer_and_rerecord_full_copy_command_buffer( - VkCommandBuffer command_buffer, VkBuffer host_memory_buffer, char* host_mem_buffer_mem, const Scene* scene, - VkBuffer device_lighting_ubo, VkBuffer device_instance_attrs_for_models - ) { - - if (vkResetCommandBuffer(command_buffer, 0) != VK_SUCCESS) - abortf("vkResetCommandBuffer"); - VkCommandBufferBeginInfo info_begin = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; - if (vkBeginCommandBuffer(command_buffer, &info_begin) != VK_SUCCESS) - abortf("vkBeginCommandBuffer"); - - // todo: rewrite this entire fucking shit - size_t offset_here = 0; - { - size_t offset_in_mesh_instance_buf = 0; - VecVkBufferCopy regions_to_copy_A = VecVkBufferCopy_new(); - for (size_t mi = 0; mi < scene->generic_models.len; mi++) { - const UsedGenericModelOnScene* model = VecUsedGenericModelOnScene_at(&scene->generic_models, mi); - assert(model->instances.len <= model->model.limit_max_instance_count); - size_t all = model->instances.len * sizeof(GenericMeshInstance); - memcpy(host_mem_buffer_mem + offset_here, model->instances.buf, all); - /* Right now we don't combine multiple vkCmdCopyBuffer commands with same src and dst buffers into one, but later we should do it */ - VecVkBufferCopy_append(®ions_to_copy_A, (VkBufferCopy){.srcOffset = offset_here, .dstOffset = offset_in_mesh_instance_buf, .size = all}); - offset_here += all; - offset_in_mesh_instance_buf += model->model.limit_max_instance_count * sizeof(GenericMeshInstance); - } - for (size_t mi = 0; mi < scene->shiny_models.len; mi++) { - const UsedShinyModelOnScene* model = VecUsedShinyModelOnScene_at(&scene->shiny_models, mi); - assert(model->instances.len <= model->model.limit_max_instance_count); - size_t all = model->instances.len * sizeof(ShinyMeshInstance); - memcpy(host_mem_buffer_mem + offset_here, model->instances.buf, all); - /* Right now we don't combine multiple vkCmdCopyBuffer commands with same src and dst buffers into one, but later we should do it */ - VecVkBufferCopy_append(®ions_to_copy_A, (VkBufferCopy){.srcOffset = offset_here, .dstOffset = offset_in_mesh_instance_buf, .size = all}); - offset_here += all; - offset_in_mesh_instance_buf += model->model.limit_max_instance_count * sizeof(ShinyMeshInstance); - } - vkCmdCopyBuffer(command_buffer, host_memory_buffer, device_instance_attrs_for_models, regions_to_copy_A.len, regions_to_copy_A.buf); - VecVkBufferCopy_drop(regions_to_copy_A); +void record_copying_entire_scene_from_staging_to_device_local(VkCommandBuffer command_buffer, const Scene* scene) { + margaret_reset_and_begin_command_buffer(command_buffer); + for (size_t mi = 0; mi < scene->generic_models.len; mi++) { + const GenericModelOnSceneMem* model = VecGenericModelOnSceneMem_at(&scene->generic_models, mi); + assert(model->instance_vec_len <= model->instance_vec_capacity); + assert(model->instance_vec_capacity * sizeof(GenericMeshInstance) == model->instance_attr_buf->value.me.buf.capacity); + vkCmdCopyBuffer(command_buffer, + model->staging_instance_attr_buf->value.me.buf.buffer, model->instance_attr_buf->value.me.buf.buffer, + 1, &(VkBufferCopy){.srcOffset = 0, .dstOffset = 0, + .size = model->instance_vec_len * sizeof(GenericMeshInstance)}); } - { - assert(scene->point_lights.len <= pipeline_0_ubo_point_light_max_count); - assert(scene->spotlights.len <= pipeline_0_ubo_spotlight_max_count); - int point_lights = (int)scene->point_lights.len; - int spotlights = (int)scene->spotlights.len; - memcpy(host_mem_buffer_mem + offset_here, &point_lights, sizeof(int)); - memcpy(host_mem_buffer_mem + offset_here + sizeof(int), &spotlights, sizeof(int)); - memcpy(host_mem_buffer_mem + offset_here + sizeof(int) * 2, scene->point_lights.buf, sizeof(Pipeline0PointLight) * point_lights); - memcpy(host_mem_buffer_mem + offset_here + sizeof(int) * 2 + sizeof(Pipeline0PointLight) * point_lights, - scene->spotlights.buf, sizeof(Pipeline0Spotlight) * spotlights); - VkBufferCopy regions_to_copy_B[] = { - { - .srcOffset = offset_here, .dstOffset = offsetof(Pipeline0UBO, point_light_count), - .size = sizeof(int), - }, - { - .srcOffset = offset_here + sizeof(int), .dstOffset = offsetof(Pipeline0UBO, spotlight_count), - .size = sizeof(int), - }, - { - .srcOffset = offset_here + 2 * sizeof(int), .dstOffset = offsetof(Pipeline0UBO, point_light_arr), - .size = sizeof(Pipeline0PointLight) * point_lights, - }, - { - .srcOffset = offset_here + 2 * sizeof(int) + sizeof(Pipeline0PointLight) * point_lights, - .dstOffset = offsetof(Pipeline0UBO, spotlight_arr), - .size = sizeof(Pipeline0Spotlight) * spotlights, - }, + for (size_t mi = 0; mi < scene->shiny_models.len; mi++) { + const ShinyModelOnSceneMem* model = VecShinyModelOnSceneMem_at(&scene->shiny_models, mi); + assert(model->instance_vec_len <= model->instance_vec_capacity); + assert(model->instance_vec_capacity * sizeof(ShinyMeshInstance) == model->instance_attr_buf->value.me.buf.capacity); + vkCmdCopyBuffer(command_buffer, + model->staging_instance_attr_buf->value.me.buf.buffer, model->instance_attr_buf->value.me.buf.buffer, + 1, &(VkBufferCopy){.srcOffset = 0, .dstOffset = 0, + .size = model->instance_vec_len * sizeof(ShinyMeshInstance)}); + } + Pipeline0UBO* pipeline_0_ubo = (Pipeline0UBO*)MargaretMAIterator_get_mapped(scene->pipeline0_ubo); + assert(pipeline_0_ubo->point_light_count <= pipeline_0_ubo_point_light_max_count); + assert(pipeline_0_ubo->spotlight_count <= pipeline_0_ubo_spotlight_max_count); + + VkBufferCopy regions_to_copy[4] = { + { + .srcOffset = offsetof(Pipeline0UBO, point_light_arr), .dstOffset = offsetof(Pipeline0UBO, point_light_arr), + .size = sizeof(int) + }, + { + .srcOffset = offsetof(Pipeline0UBO, spotlight_count), .dstOffset = offsetof(Pipeline0UBO, spotlight_count), + .size = sizeof(int) + } + }; + int regions_to_copy_c = 2; + if (pipeline_0_ubo->point_light_count) { + regions_to_copy[regions_to_copy_c] = (VkBufferCopy){ + .srcOffset = offsetof(Pipeline0UBO, point_light_arr), .dstOffset = offsetof(Pipeline0UBO, point_light_arr), + .size = sizeof(Pipeline0PointLight) * pipeline_0_ubo->point_light_count, }; - vkCmdCopyBuffer(command_buffer, host_memory_buffer, device_lighting_ubo, ARRAY_SIZE(regions_to_copy_B), regions_to_copy_B); + regions_to_copy_c++; + } + if (pipeline_0_ubo->spotlight_count) { + regions_to_copy[regions_to_copy_c] = (VkBufferCopy){ + .srcOffset = offsetof(Pipeline0UBO, spotlight_arr), .dstOffset = offsetof(Pipeline0UBO, spotlight_arr), + .size = sizeof(Pipeline0Spotlight) * pipeline_0_ubo->spotlight_count, + }; + regions_to_copy_c++; } - if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) - abortf("vkEndCommandBuffer"); + vkCmdCopyBuffer(command_buffer, scene->pipeline0_staging_ubo->value.me.buf.buffer, + scene->pipeline0_ubo->value.me.buf.buffer, regions_to_copy_c, regions_to_copy); + margaret_end_command_buffer(command_buffer); } - - typedef struct { MargaretInstanceAndItsDebug instance_and_debug; VkSurfaceKHR surface; @@ -1075,44 +1008,32 @@ typedef struct { PipelineHands pipeline_hands_0b; VkRenderPass render_pass_1; PipelineHands pipeline_hands_1; - Jane_r0 jane; - MargaretSwapchainBundle swfb; + VkSampler linear_sampler; + VkSampler nearest_sampler; + + VkDescriptorPool descriptor_pool; // todo: write dynamic allocator wrapper for descriptor pools SceneTemplate scene_template; - VecGenericModelTopAndTexInMemoryInfo device_generic_models_top_and_tex; - VecShinyModelTopInMemoryInfo device_shiny_models_top; - MargaretBufferInMemoryInfo host_mem_buffer; - VkDeviceMemory host_mem; - MargaretBufferInMemoryInfo device_lighting_ubo; - MargaretBufferInMemoryInfo device_instance_attrs_for_models; - MargaretImageInMemoryInfo device_IT1_image; - MargaretImageInMemoryInfo device_zbuffer_image; - VkDeviceMemory device_mem; - - VkCommandPool command_pool; - VkCommandBuffer rendering_command_buffer_0; - VkCommandBuffer rendering_command_buffer_1; - VkCommandBuffer transfer_command_buffer; + MargaretMemAllocator host_visible_coherent_mem; + MargaretMemAllocator device_local_mem; Scene scene; - void* host_mem_buffer_mem; - + MargaretMAIterator device_IT1_image; + MargaretMAIterator device_zbuffer_image; + VecGenericModelTexVulkPointers generic_model_tex_vulk_pointers; VkImageView zbuffer_view; VkImageView IT1_view; VkFramebuffer IT1_framebuffer; - VkSampler linear_sampler; - VkSampler nearest_sampler; - VkDescriptorPool descriptor_pool; /* Descriptor sets */ - // Descriptor sets for pipeline_0a are stored in device_generic_models_top_and_tex VkDescriptorSet descriptor_set_for_pipeline_0b; VkDescriptorSet descriptor_set_for_pipeline_1; + // Descriptor sets for pipeline_0a are stored in generic_model_tex_vulk_pointers - CamControlInfo my_cam_control_info; - vec3 Buba_control_info; + Jane_r0 jane; // todo: figure out my own design + MargaretSwapchainBundle swfb; bool dt_transfer_required; } vulkan_ctx_r0; @@ -1132,7 +1053,7 @@ typedef struct { struct xdg_surface *xdg_surface; struct xdg_toplevel *xdg_toplevel; /* vulkan objects */ - vulkan_ctx_r0 vk_ctx; + vulkan_ctx_r0 vk; /* inputs */ struct wl_pointer* pointer; struct wl_keyboard* keyboard; @@ -1154,78 +1075,79 @@ typedef struct { } state_r0; void recreate_swapchain(state_r0 *state) { - // We are about stop program and rebuild our sem+sem+fence synchronization mechanism - vkDeviceWaitIdle(state->vk_ctx.device); - Jane_r0_destroy(state->vk_ctx.device, state->vk_ctx.jane); - state->vk_ctx.jane = Jane_r0_create(state->vk_ctx.device); + // We are stopping program and rebuilding our sem+sem+fence synchronization mechanism + vkDeviceWaitIdle(state->vk.device); + Jane_r0_destroy(state->vk.device, state->vk.jane); + state->vk.jane = Jane_r0_create(state->vk.device); VkSwapchainKHR old_swapchain = MargaretSwapchainBundle_pop_swapchain_drop_rest( - state->vk_ctx.device, state->vk_ctx.swfb); + state->vk.device, state->vk.swfb); // old swfb is 83% dropped VkExtent2D extent = state->width_confirmed <= 0 || state->height_confirmed <= 0 ? state->sane_image_extent_limit : (VkExtent2D){ state->width_confirmed, state->height_confirmed }; ResultMargaretChosenSwapchainDetailsOrSpanU8 swapchain_details_res = margaret_choose_swapchain_details( - state->vk_ctx.physical_device, state->vk_ctx.surface, extent); + state->vk.physical_device, state->vk.surface, extent); if (swapchain_details_res.variant != Result_Ok) abortf("swapchain_details_res.variant != Result_Ok"); MargaretChosenSwapchainDetails swapchain_details = swapchain_details_res.ok; - MargaretSwapchainBundle new_swfb = MargaretSwapchainBundle_new(state->vk_ctx.device, state->vk_ctx.queue_fam, - swapchain_details, state->vk_ctx.surface, state->vk_ctx.render_pass_1, state->vk_ctx.swfb.swapchain); - vkDestroySwapchainKHR(state->vk_ctx.device, old_swapchain, NULL); + MargaretSwapchainBundle new_swfb = MargaretSwapchainBundle_new(state->vk.device, state->vk.queue_fam, + swapchain_details, state->vk.surface, state->vk.render_pass_1, state->vk.swfb.swapchain); + vkDestroySwapchainKHR(state->vk.device, old_swapchain, NULL); // Now old swfb is 100% dropped - state->vk_ctx.swfb = new_swfb; + state->vk.swfb = new_swfb; } void update_state(state_r0* state, uint32_t dur) { float fl = (float)dur / 1000; - state->vk_ctx.scene.anim_time += fl; + state->vk.scene.anim_time += fl; if (state->first_0x80_keys[XKB_KEY_w]) - CamControlInfo_forward(&state->vk_ctx.my_cam_control_info, fl); + CamControlInfo_forward(&state->vk.scene.cam, fl); if (state->first_0x80_keys[XKB_KEY_s]) - CamControlInfo_backward(&state->vk_ctx.my_cam_control_info, fl); + CamControlInfo_backward(&state->vk.scene.cam, fl); if (state->first_0x80_keys[XKB_KEY_a]) - CamControlInfo_left(&state->vk_ctx.my_cam_control_info, fl); + CamControlInfo_left(&state->vk.scene.cam, fl); if (state->first_0x80_keys[XKB_KEY_d]) - CamControlInfo_right(&state->vk_ctx.my_cam_control_info, fl); + CamControlInfo_right(&state->vk.scene.cam, fl); if (state->first_0x80_keys[XKB_KEY_q]) - CamControlInfo_down(&state->vk_ctx.my_cam_control_info, fl); + CamControlInfo_down(&state->vk.scene.cam, fl); if (state->first_0x80_keys[XKB_KEY_e]) - CamControlInfo_up(&state->vk_ctx.my_cam_control_info, fl); + CamControlInfo_up(&state->vk.scene.cam, fl); - if (state->first_0x80_keys[XKB_KEY_j]) { - state->vk_ctx.Buba_control_info.x -= fl; - VecGenericMeshInstance_mat(&VecUsedGenericModelOnScene_mat(&state->vk_ctx.scene.generic_models, 1)->instances, 0)->model_t = - marie_translation_mat4(state->vk_ctx.Buba_control_info); - state->vk_ctx.dt_transfer_required = true; - } - if (state->first_0x80_keys[XKB_KEY_k]) { - state->vk_ctx.Buba_control_info.z -= fl; - VecGenericMeshInstance_mat(&VecUsedGenericModelOnScene_mat(&state->vk_ctx.scene.generic_models, 1)->instances, 0)->model_t = - marie_translation_mat4(state->vk_ctx.Buba_control_info); - state->vk_ctx.dt_transfer_required = true; - } - if (state->first_0x80_keys[XKB_KEY_l]) { - state->vk_ctx.Buba_control_info.z += fl; - VecGenericMeshInstance_mat(&VecUsedGenericModelOnScene_mat(&state->vk_ctx.scene.generic_models, 1)->instances, 0)->model_t = - marie_translation_mat4(state->vk_ctx.Buba_control_info); - state->vk_ctx.dt_transfer_required = true; - } - if (state->first_0x80_keys[XKB_KEY_semicolon]) { - state->vk_ctx.Buba_control_info.x += fl; - VecGenericMeshInstance_mat(&VecUsedGenericModelOnScene_mat(&state->vk_ctx.scene.generic_models, 1)->instances, 0)->model_t = - marie_translation_mat4(state->vk_ctx.Buba_control_info); - state->vk_ctx.dt_transfer_required = true; + { + GenericModelOnSceneMem* model = VecGenericModelOnSceneMem_mat(&state->vk.scene.generic_models, 0); + assert(model->instance_vec_len >= 1); + GenericMeshInstance* instances = (GenericMeshInstance*)MargaretMAIterator_get_mapped(model->instance_attr_buf); + if (state->first_0x80_keys[XKB_KEY_j]) { + state->vk.scene.funny_vector.x -= fl; + instances[0].model_t = marie_translation_mat4(state->vk.scene.funny_vector); + state->vk.dt_transfer_required = true; + } + if (state->first_0x80_keys[XKB_KEY_k]) { + state->vk.scene.funny_vector.z -= fl; + instances[0].model_t = marie_translation_mat4(state->vk.scene.funny_vector); + state->vk.dt_transfer_required = true; + } + if (state->first_0x80_keys[XKB_KEY_l]) { + state->vk.scene.funny_vector.z += fl; + instances[0].model_t = marie_translation_mat4(state->vk.scene.funny_vector); + state->vk.dt_transfer_required = true; + } + if (state->first_0x80_keys[XKB_KEY_semicolon]) { + state->vk.scene.funny_vector.x += fl; + instances[0].model_t = marie_translation_mat4(state->vk.scene.funny_vector); + state->vk.dt_transfer_required = true; + } } } -void vulkano_frame_drawing(state_r0* state) { +void vulkan_frame_drawing(state_r0* state) { and_again: - vkWaitForFences(state->vk_ctx.device, 1, &state->vk_ctx.jane.in_flight_fence, VK_TRUE, UINT64_MAX); + vkWaitForFences(state->vk.device, 1, &state->vk.jane.in_flight_fence, VK_TRUE, UINT64_MAX); uint32_t ij; VkResult aq_ret = vkAcquireNextImageKHR( - state->vk_ctx.device, state->vk_ctx.swfb.swapchain, - UINT64_MAX, state->vk_ctx.jane.image_available_semaphore, VK_NULL_HANDLE, &ij + state->vk.device, state->vk.swfb.swapchain, + UINT64_MAX, state->vk.jane.image_available_semaphore, VK_NULL_HANDLE, &ij ); if (aq_ret == VK_ERROR_OUT_OF_DATE_KHR) { fprintf(stderr, "vkAcquireNextImageKHR: VK_ERROR_OUT_OF_DATE_KHR\n"); @@ -1239,25 +1161,25 @@ void vulkano_frame_drawing(state_r0* state) { abortf("vkAcquireNextImageKHR"); } - vkResetFences(state->vk_ctx.device, 1, &state->vk_ctx.jane.in_flight_fence); + vkResetFences(state->vk.device, 1, &state->vk.jane.in_flight_fence); - state->vk_ctx.scene.color = (VkClearColorValue){{0, 0.5f, 0.9f, 1}}; + state->vk.scene.color = (VkClearColorValue){{0, 0.5f, 0.9f, 1}}; mat4 projection_matrix = marie_perspective_projection_fov_mat4( (float)state->width_confirmed, (float)state->height_confirmed, - state->vk_ctx.my_cam_control_info.fov, 0.01f, 1000); - mat4 camera_rotation_matrix = marie_mat3_to_mat4_transposed(state->vk_ctx.my_cam_control_info.cam_basis); - mat4 camera_translation_matrix = marie_translation_mat4(vec3_minus(state->vk_ctx.my_cam_control_info.pos)); + state->vk.scene.cam.fov, 0.01f, 1000); + mat4 camera_rotation_matrix = marie_mat3_to_mat4_transposed(state->vk.scene.cam.cam_basis); + mat4 camera_translation_matrix = marie_translation_mat4(vec3_minus(state->vk.scene.cam.pos)); mat4 t_mat = mat4_mul_mat4(projection_matrix, mat4_mul_mat4(camera_rotation_matrix, camera_translation_matrix)); - if (state->vk_ctx.dt_transfer_required){ - assert(state->vk_ctx.scene.spotlights.len < pipeline_0_ubo_spotlight_max_count); - assert(state->vk_ctx.scene.point_lights.len < pipeline_0_ubo_point_light_max_count); + if (state->vk.dt_transfer_required){ + assert(state->vk.scene.spotlights.len < pipeline_0_ubo_spotlight_max_count); + assert(state->vk.scene.point_lights.len < pipeline_0_ubo_point_light_max_count); copy_scene_info_to_buffer_and_rerecord_full_copy_command_buffer( - state->vk_ctx.transfer_command_buffer, state->vk_ctx.host_mem_buffer.buffer, - state->vk_ctx.host_mem_buffer_mem, &state->vk_ctx.scene, state->vk_ctx.device_lighting_ubo.buffer, - state->vk_ctx.device_instance_attrs_for_models.buffer); - VkCommandBuffer command_buffers[1] = { state->vk_ctx.transfer_command_buffer }; - VkSemaphore signaling_semaphores[1] = { state->vk_ctx.jane.in_frame_transfer_complete }; + state->vk.transfer_command_buffer, state->vk.host_mem_buffer.buffer, + state->vk.host_mem_buffer_mem, &state->vk.scene, state->vk.device_lighting_ubo.buffer, + state->vk.device_instance_attrs_for_models.buffer); + VkCommandBuffer command_buffers[1] = { state->vk.transfer_command_buffer }; + VkSemaphore signaling_semaphores[1] = { state->vk.jane.in_frame_transfer_complete }; VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .commandBufferCount = ARRAY_SIZE(command_buffers), @@ -1265,46 +1187,46 @@ void vulkano_frame_drawing(state_r0* state) { .signalSemaphoreCount = ARRAY_SIZE(signaling_semaphores), .pSignalSemaphores = signaling_semaphores, }; - if (vkQueueSubmit(state->vk_ctx.queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) + if (vkQueueSubmit(state->vk.queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) abortf("vkQueueSubmit\n"); } reset_and_record_command_buffer_0( - state->vk_ctx.rendering_command_buffer_0, state->vk_ctx.render_pass_0, - &state->vk_ctx.pipeline_hands_0a, &state->vk_ctx.pipeline_hands_0b, - state->vk_ctx.IT1_framebuffer, state->vk_ctx.swfb.extent, - &state->vk_ctx.scene, - &state->vk_ctx.device_generic_models_top_and_tex, /* Needed just to get descriptor sets for generic models */ - state->vk_ctx.descriptor_set_for_pipeline_0b, - t_mat, state->vk_ctx.my_cam_control_info.pos); + state->vk.rendering_command_buffer_0, state->vk.render_pass_0, + &state->vk.pipeline_hands_0a, &state->vk.pipeline_hands_0b, + state->vk.IT1_framebuffer, state->vk.swfb.extent, + &state->vk.scene, + &state->vk.device_generic_models_top_and_tex, /* Needed just to get descriptor sets for generic models */ + state->vk.descriptor_set_for_pipeline_0b, + t_mat, state->vk.scene.cam.pos); - reset_and_record_command_buffer_1(state->vk_ctx.rendering_command_buffer_1, state->vk_ctx.render_pass_1, - &state->vk_ctx.pipeline_hands_1, - *VecVkFramebuffer_at(&state->vk_ctx.swfb.framebuffers, ij), - state->vk_ctx.swfb.extent, - state->sane_image_extent_limit, &state->vk_ctx.scene, state->vk_ctx.descriptor_set_for_pipeline_1); + reset_and_record_command_buffer_1(state->vk.rendering_command_buffer_1, state->vk.render_pass_1, + &state->vk.pipeline_hands_1, + *VecVkFramebuffer_at(&state->vk.swfb.framebuffers, ij), + state->vk.swfb.extent, + state->sane_image_extent_limit, &state->vk.scene, state->vk.descriptor_set_for_pipeline_1); { VkSemaphore waiting_for_semaphores_if_dt_transfer_required[1] = { - state->vk_ctx.jane.in_frame_transfer_complete + state->vk.jane.in_frame_transfer_complete }; VkPipelineStageFlags waiting_stages_if_dt_transfer_required[1] = { VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT }; assert(ARRAY_SIZE(waiting_for_semaphores_if_dt_transfer_required) == ARRAY_SIZE(waiting_stages_if_dt_transfer_required)); - VkCommandBuffer command_buffers[1] = {state->vk_ctx.rendering_command_buffer_0}; - VkSemaphore signaling_semaphores[1] = { state->vk_ctx.jane.rendered_to_IT1_semaphore }; + VkCommandBuffer command_buffers[1] = {state->vk.rendering_command_buffer_0}; + VkSemaphore signaling_semaphores[1] = { state->vk.jane.rendered_to_IT1_semaphore }; VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, // We wait for `waiting_for_semaphores` before THESE stages // waitSemaphoreCount specifies size for both pWaitSemaphores and pWaitDstStageMask - .waitSemaphoreCount = state->vk_ctx.dt_transfer_required ? + .waitSemaphoreCount = state->vk.dt_transfer_required ? ARRAY_SIZE(waiting_for_semaphores_if_dt_transfer_required) : 0, - .pWaitSemaphores = state->vk_ctx.dt_transfer_required ? + .pWaitSemaphores = state->vk.dt_transfer_required ? waiting_for_semaphores_if_dt_transfer_required : NULL, - .pWaitDstStageMask = state->vk_ctx.dt_transfer_required ? + .pWaitDstStageMask = state->vk.dt_transfer_required ? waiting_stages_if_dt_transfer_required : NULL, .commandBufferCount = ARRAY_SIZE(command_buffers), @@ -1313,22 +1235,22 @@ void vulkano_frame_drawing(state_r0* state) { .signalSemaphoreCount = ARRAY_SIZE(signaling_semaphores), .pSignalSemaphores = signaling_semaphores, }; - if (vkQueueSubmit(state->vk_ctx.queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) + if (vkQueueSubmit(state->vk.queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) abortf("vkQueueSubmit"); } { VkSemaphore waiting_for_semaphores[2] = { - state->vk_ctx.jane.image_available_semaphore, - state->vk_ctx.jane.rendered_to_IT1_semaphore }; + state->vk.jane.image_available_semaphore, + state->vk.jane.rendered_to_IT1_semaphore }; VkPipelineStageFlags waiting_stages[2] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, // VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT }; assert(ARRAY_SIZE(waiting_for_semaphores) == ARRAY_SIZE(waiting_stages)); - VkCommandBuffer command_buffers[1] = { state->vk_ctx.rendering_command_buffer_1 }; + VkCommandBuffer command_buffers[1] = { state->vk.rendering_command_buffer_1 }; VkSemaphore signaling_semaphores[1] = { - *VecVkSemaphore_at(&state->vk_ctx.swfb.rendering_finished_here_semaphores, ij) + *VecVkSemaphore_at(&state->vk.swfb.rendering_finished_here_semaphores, ij) }; VkSubmitInfo cmd_submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, @@ -1344,15 +1266,15 @@ void vulkano_frame_drawing(state_r0* state) { .pSignalSemaphores = signaling_semaphores, }; - if (vkQueueSubmit(state->vk_ctx.queues.graphics_queue, 1, &cmd_submit_info, state->vk_ctx.jane.in_flight_fence) != VK_SUCCESS) + if (vkQueueSubmit(state->vk.queues.graphics_queue, 1, &cmd_submit_info, state->vk.jane.in_flight_fence) != VK_SUCCESS) abortf("vkQueueSubmit"); } { VkSemaphore waiting_for_semaphores[] = { - *VecVkSemaphore_at(&state->vk_ctx.swfb.rendering_finished_here_semaphores, ij) + *VecVkSemaphore_at(&state->vk.swfb.rendering_finished_here_semaphores, ij) }; - VkSwapchainKHR swapchains[] = { state->vk_ctx.swfb.swapchain }; + VkSwapchainKHR swapchains[] = { state->vk.swfb.swapchain }; uint32_t image_indices[] = { ij }; assert( ARRAY_SIZE(swapchains) == ARRAY_SIZE(image_indices) ); @@ -1367,7 +1289,7 @@ void vulkano_frame_drawing(state_r0* state) { .pResults = NULL, }; - VkResult pres_ret = vkQueuePresentKHR(state->vk_ctx.queues.presentation_queue, &present_info); + VkResult pres_ret = vkQueuePresentKHR(state->vk.queues.presentation_queue, &present_info); // todo: ponder more over this if (pres_ret == VK_ERROR_OUT_OF_DATE_KHR) { fprintf(stderr, "vkQueuePresentKHR: VK_ERROR_OUT_OF_DATE_KHR\n"); @@ -1381,7 +1303,7 @@ void vulkano_frame_drawing(state_r0* state) { abortf("vkQueuePresentKHR"); } } - state->vk_ctx.dt_transfer_required = false; + state->vk.dt_transfer_required = false; margaret_ns_time frame_B0 = margaret_clock_gettime_monotonic_raw(); state->frame_count_since_key++; if (margaret_ns_time_sec_diff(state->prev_key_frame_time, frame_B0) > 1.0) { @@ -1498,16 +1420,16 @@ static void main_h_wl_keyboard_key( } if (key_action == WL_KEYBOARD_KEY_STATE_RELEASED) { if (keysym == XKB_KEY_1) { - vec3 p = state->vk_ctx.my_cam_control_info.pos; - VecPipeline0PointLight_mat(&state->vk_ctx.scene.point_lights, 0)->pos = p; + vec3 p = state->vk.scene.cam.pos; + VecPipeline0PointLight_mat(&state->vk.scene.point_lights, 0)->pos = p; printf("Point light source pos set to %f %f %f\n", p.x, p.y, p.z); - state->vk_ctx.dt_transfer_required = true; + state->vk.dt_transfer_required = true; } else if (keysym == XKB_KEY_2) { - state->vk_ctx.scene.hdr_factor /= 1.05f; - printf("hdr factor decreased to %f\n", state->vk_ctx.scene.hdr_factor); + state->vk.scene.hdr_factor /= 1.05f; + printf("hdr factor decreased to %f\n", state->vk.scene.hdr_factor); } else if (keysym == XKB_KEY_3) { - state->vk_ctx.scene.hdr_factor *= 1.05f; - printf("hdr factor increased to %f\n", state->vk_ctx.scene.hdr_factor); + state->vk.scene.hdr_factor *= 1.05f; + printf("hdr factor increased to %f\n", state->vk.scene.hdr_factor); } } } @@ -1551,7 +1473,7 @@ static void main_h_wl_pointer_motion( void *data,struct wl_pointer *wl_pointer, uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y ) { state_r0 *state = data; - CamControlInfo_update_direction(&state->vk_ctx.my_cam_control_info, + CamControlInfo_update_direction(&state->vk.scene.cam, state->width_confirmed, state->height_confirmed, (float)surface_x / 256.f, (float)surface_y / 256.f); } @@ -1691,7 +1613,7 @@ int main() { state_r0 state = {0}; state.sane_image_extent_limit = (VkExtent2D){1000, 700}; - vulkan_ctx_r0 *vk_ctx = &state.vk_ctx; + vulkan_ctx_r0 *vk = &state.vk; state.wl_display = wl_display_connect(NULL); if (!state.wl_display) @@ -1729,87 +1651,87 @@ int main() { abortf("wl_surface_frame\n"); wl_callback_add_listener(state.wl_callback, &main_h_wl_surface_frame_listener, &state); - vk_ctx->instance_and_debug = MargaretInstanceAndItsDebug_new(ENABLE_VALIDATION_LAYERS); - VkInstance instance = vk_ctx->instance_and_debug.instance; + vk->instance_and_debug = MargaretInstanceAndItsDebug_new(ENABLE_VALIDATION_LAYERS); + VkInstance instance = vk->instance_and_debug.instance; // print_instance_available_extensions(instance); // print_instance_available_layers(instance); - vk_ctx->surface = margaret_create_surface(instance, state.wl_display, state.wl_surface); + vk->surface = margaret_create_surface(instance, state.wl_display, state.wl_surface); - vk_ctx->physical_device = margaret_select_one_physical_device( - instance, vk_ctx->surface, GPU, bugged_GPU, sane_image_extent_limit); + vk->physical_device = margaret_select_one_physical_device( + instance, vk->surface, GPU, bugged_GPU, sane_image_extent_limit); { /* Funny vibe check */ - VecU8 txt = margaret_stringify_device_memory_properties_2(vk_ctx->physical_device); + VecU8 txt = margaret_stringify_device_memory_properties_2(vk->physical_device); SpanU8_print(VecU8_to_span(&txt)); } // print_physical_device_available_extensions(physical_device); ResultMargaretChosenQueueFamiliesOrSpanU8 queue_fam_res = margaret_choose_good_queue_families( - vk_ctx->physical_device, vk_ctx->surface); + vk->physical_device, vk->surface); if (queue_fam_res.variant != Result_Ok) abortf("queue_fam_res.variant != Result_Ok"); - vk_ctx->queue_fam = queue_fam_res.ok; + vk->queue_fam = queue_fam_res.ok; - vk_ctx->device = margaret_create_logical_device(vk_ctx->physical_device, vk_ctx->queue_fam); + vk->device = margaret_create_logical_device(vk->physical_device, vk->queue_fam); - vkGetDeviceQueue(vk_ctx->device, vk_ctx->queue_fam.for_graphics, 0, &vk_ctx->queues.graphics_queue); - vkGetDeviceQueue(vk_ctx->device, vk_ctx->queue_fam.for_presentation, 0, &vk_ctx->queues.presentation_queue); + vkGetDeviceQueue(vk->device, vk->queue_fam.for_graphics, 0, &vk->queues.graphics_queue); + vkGetDeviceQueue(vk->device, vk->queue_fam.for_presentation, 0, &vk->queues.presentation_queue); ResultMargaretChosenSwapchainDetailsOrSpanU8 swapchain_details_res = margaret_choose_swapchain_details( - vk_ctx->physical_device, vk_ctx->surface, sane_image_extent_limit); + vk->physical_device, vk->surface, sane_image_extent_limit); if (swapchain_details_res.variant != Result_Ok) abortf("swapchain_details_res.variant != Result_Ok"); - OptionVkFormat zbuffer_format = margaret_find_supported_zbuffer_format(vk_ctx->physical_device); + OptionVkFormat zbuffer_format = margaret_find_supported_zbuffer_format(vk->physical_device); if (zbuffer_format.variant != Option_Some) abortf("Could not find supported zbuffer format\n"); - vk_ctx->zbuffer_format = zbuffer_format.some; - OptionVkFormat IT1_format = margaret_find_supported_hdr_buffer_format(vk_ctx->physical_device); + vk->zbuffer_format = zbuffer_format.some; + OptionVkFormat IT1_format = margaret_find_supported_hdr_buffer_format(vk->physical_device); if (IT1_format.variant != Option_Some) abortf("Could not find supported hdr buffer format\n"); - vk_ctx->IT1_format = IT1_format.some; + vk->IT1_format = IT1_format.some; - vk_ctx->render_pass_0 = create_render_pass_0(vk_ctx->device, IT1_format.some, zbuffer_format.some); - vk_ctx->pipeline_hands_0a = create_graphics_pipeline_0(vk_ctx->device, vk_ctx->render_pass_0, 0); - vk_ctx->pipeline_hands_0b = create_graphics_pipeline_0_b(vk_ctx->device, vk_ctx->render_pass_0, 0); + vk->render_pass_0 = create_render_pass_0(vk->device, IT1_format.some, zbuffer_format.some); + vk->pipeline_hands_0a = create_graphics_pipeline_0(vk->device, vk->render_pass_0, 0); + vk->pipeline_hands_0b = create_graphics_pipeline_0_b(vk->device, vk->render_pass_0, 0); - vk_ctx->render_pass_1 = create_render_pass_1(vk_ctx->device, swapchain_details_res.ok.surface_format.format); - vk_ctx->pipeline_hands_1 = create_graphics_pipeline_1(vk_ctx->device, vk_ctx->render_pass_1, 0); + vk->render_pass_1 = create_render_pass_1(vk->device, swapchain_details_res.ok.surface_format.format); + vk->pipeline_hands_1 = create_graphics_pipeline_1(vk->device, vk->render_pass_1, 0); - vk_ctx->swfb = MargaretSwapchainBundle_new( - vk_ctx->device, vk_ctx->queue_fam, swapchain_details_res.ok, - vk_ctx->surface, vk_ctx->render_pass_1, NULL); + vk->swfb = MargaretSwapchainBundle_new( + vk->device, vk->queue_fam, swapchain_details_res.ok, + vk->surface, vk->render_pass_1, NULL); - vk_ctx->scene_template = (SceneTemplate){ + vk->scene_template = (SceneTemplate){ .generic_models = VecGenericMeshInSceneTemplate_new(), .shiny_models = VecShinyMeshInSceneTemplate_new(), .point_lights_max_count = pipeline_0_ubo_point_light_max_count, .spotlights_max_count = pipeline_0_ubo_spotlight_max_count}; - VecGenericMeshInSceneTemplate_append(&vk_ctx->scene_template.generic_models, + VecGenericMeshInSceneTemplate_append(&vk->scene_template.generic_models, GenericMeshInSceneTemplate_for_log(10, 2, 6, 100)); - VecGenericMeshInSceneTemplate_append(&vk_ctx->scene_template.generic_models, + VecGenericMeshInSceneTemplate_append(&vk->scene_template.generic_models, GenericMeshInSceneTemplate_for_log(5, 5, 10, 1)); - VecGenericMeshInSceneTemplate_append(&vk_ctx->scene_template.generic_models, + VecGenericMeshInSceneTemplate_append(&vk->scene_template.generic_models, GenericMeshInSceneTemplate_for_log(1, 10, 4, 2)); - VecGenericMeshInSceneTemplate_append(&vk_ctx->scene_template.generic_models, + VecGenericMeshInSceneTemplate_append(&vk->scene_template.generic_models, GenericMeshInSceneTemplate_for_log(2, 1, 6, 2)); - VecShinyMeshInSceneTemplate_append(&vk_ctx->scene_template.shiny_models, (ShinyMeshInSceneTemplate){ + VecShinyMeshInSceneTemplate_append(&vk->scene_template.shiny_models, (ShinyMeshInSceneTemplate){ .topology = generate_shiny_rhombicuboctahedron(0.5f), .max_instance_count = 5 }); - VecShinyMeshInSceneTemplate_append(&vk_ctx->scene_template.shiny_models, (ShinyMeshInSceneTemplate){ + VecShinyMeshInSceneTemplate_append(&vk->scene_template.shiny_models, (ShinyMeshInSceneTemplate){ .topology = generate_shiny_cube(0.5f), .max_instance_count = 5 }); - vk_ctx->device_generic_models_top_and_tex = VecGenericModelTopAndTexInMemoryInfo_new_reserved(vk_ctx->scene_template.generic_models.len); - for (size_t i = 0; i < vk_ctx->scene_template.generic_models.len; i++) { - const GenericMeshInSceneTemplate* M = VecGenericMeshInSceneTemplate_at(&vk_ctx->scene_template.generic_models, i); + vk->device_generic_models_top_and_tex = VecGenericModelTopAndTexInMemoryInfo_new_reserved(vk->scene_template.generic_models.len); + for (size_t i = 0; i < vk->scene_template.generic_models.len; i++) { + const GenericMeshInSceneTemplate* M = VecGenericMeshInSceneTemplate_at(&vk->scene_template.generic_models, i); TextureDataR8G8B8A8 reading_diffuse = TextureDataR8G8B8A8_read_from_png_nofail(VecU8_to_span(&M->diffuse_texture_path)); TextureDataR8G8B8A8 reading_normal = TextureDataR8G8B8A8_read_from_png_nofail(VecU8_to_span(&M->normal_texture_path)); TextureDataR8 reading_specular = TextureDataR8_read_from_png_nofail(VecU8_to_span(&M->specular_texture_path)); - VecGenericModelTopAndTexInMemoryInfo_append(&vk_ctx->device_generic_models_top_and_tex, + VecGenericModelTopAndTexInMemoryInfo_append(&vk->device_generic_models_top_and_tex, (GenericModelTopAndTexInMemoryInfo){ .vbo = GenericMeshVertex_buffer_crinfo_of_gpu_vbo(M->topology.vertices.len), .ebo = margaret_prep_buffer_mem_info_of_gpu_ebo(M->topology.indexes.len), @@ -1823,25 +1745,25 @@ int main() { } - VecU64 offset_of_image_in_host_mem_buff_during_init = VecU64_new_zeroinit(vk_ctx->device_generic_models_top_and_tex.len * 3); + VecU64 offset_of_image_in_host_mem_buff_during_init = VecU64_new_zeroinit(vk->device_generic_models_top_and_tex.len * 3); U64 grand_total_texture_size_in_host_mem = 0; { U64 offset = 0; - for (size_t i = 0; i < vk_ctx->device_generic_models_top_and_tex.len; i++) { + for (size_t i = 0; i < vk->device_generic_models_top_and_tex.len; i++) { offset_of_image_in_host_mem_buff_during_init.buf[3 * i + 0] = offset; - offset += TextureDataR8G8B8A8_get_size_in_bytes(&vk_ctx->device_generic_models_top_and_tex.buf[i].reading_diffuse); + offset += TextureDataR8G8B8A8_get_size_in_bytes(&vk->device_generic_models_top_and_tex.buf[i].reading_diffuse); offset_of_image_in_host_mem_buff_during_init.buf[3 * i + 1] = offset; - offset += TextureDataR8G8B8A8_get_size_in_bytes(&vk_ctx->device_generic_models_top_and_tex.buf[i].reading_normal); + offset += TextureDataR8G8B8A8_get_size_in_bytes(&vk->device_generic_models_top_and_tex.buf[i].reading_normal); offset_of_image_in_host_mem_buff_during_init.buf[3 * i + 2] = offset; - offset += TextureDataR8_get_size_in_bytes(&vk_ctx->device_generic_models_top_and_tex.buf[i].reading_specular); + offset += TextureDataR8_get_size_in_bytes(&vk->device_generic_models_top_and_tex.buf[i].reading_specular); } grand_total_texture_size_in_host_mem = offset; } - vk_ctx->device_shiny_models_top = VecShinyModelTopInMemoryInfo_new_reserved(vk_ctx->scene_template.shiny_models.len); - for (size_t i = 0; i < vk_ctx->scene_template.shiny_models.len; i++) { - const ShinyMeshInSceneTemplate* M = VecShinyMeshInSceneTemplate_at(&vk_ctx->scene_template.shiny_models, i); - VecShinyModelTopInMemoryInfo_append(&vk_ctx->device_shiny_models_top, + vk->device_shiny_models_top = VecShinyModelTopInMemoryInfo_new_reserved(vk->scene_template.shiny_models.len); + for (size_t i = 0; i < vk->scene_template.shiny_models.len; i++) { + const ShinyMeshInSceneTemplate* M = VecShinyMeshInSceneTemplate_at(&vk->scene_template.shiny_models, i); + VecShinyModelTopInMemoryInfo_append(&vk->device_shiny_models_top, (ShinyModelTopInMemoryInfo){ .vbo = ShinyMeshVertex_buffer_crinfo_of_gpu_vbo(M->topology.vertices.len), .ebo = margaret_prep_buffer_mem_info_of_gpu_ebo(M->topology.indexes.len), @@ -1852,41 +1774,41 @@ int main() { // todo: commit suicide // We have only one staging buffer in host memory (because we don't really need more) - vk_ctx->host_mem_buffer = (MargaretBufferInMemoryInfo){ .sz = - MAX_U64(SceneTemplate_get_space_for_initial_model_topology_transfer(&vk_ctx->scene_template), - MAX_U64(SceneTemplate_get_space_needed_for_widest_state_transfer(&vk_ctx->scene_template), + vk->host_mem_buffer = (MargaretBufferInMemoryInfo){ .sz = + MAX_U64(SceneTemplate_get_space_for_initial_model_topology_transfer(&vk->scene_template), + MAX_U64(SceneTemplate_get_space_needed_for_widest_state_transfer(&vk->scene_template), MAX_U64(grand_total_texture_size_in_host_mem, 0))) , .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT }; - PtrMargaretBufferInMemoryInfo host_mem_buffer_SPAN[1] = {&vk_ctx->host_mem_buffer}; - vk_ctx->host_mem = margaret_initialize_buffers_and_images(vk_ctx->physical_device, vk_ctx->device, + PtrMargaretBufferInMemoryInfo host_mem_buffer_SPAN[1] = {&vk->host_mem_buffer}; + vk->host_mem = margaret_initialize_buffers_and_images(vk->physical_device, vk->device, (MutSpanPtrMargaretBufferInMemoryInfo){.data = host_mem_buffer_SPAN, .len = 1}, (MutSpanPtrMargaretImageInMemoryInfo){ 0 }, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); - vk_ctx->device_lighting_ubo = margaret_prep_buffer_mem_info_of_gpu_ubo(sizeof(Pipeline0UBO)); - vk_ctx->device_instance_attrs_for_models = (MargaretBufferInMemoryInfo){ - .sz = SceneTemplate_get_space_needed_for_all_instance_attributes(&vk_ctx->scene_template), + vk->device_lighting_ubo = margaret_prep_buffer_mem_info_of_gpu_ubo(sizeof(Pipeline0UBO)); + vk->device_instance_attrs_for_models = (MargaretBufferInMemoryInfo){ + .sz = SceneTemplate_get_space_needed_for_all_instance_attributes(&vk->scene_template), .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT }; VecPtrMargaretBufferInMemoryInfo device_mem_buffers_SPAN = VecPtrMargaretBufferInMemoryInfo_new_reserved( - vk_ctx->device_generic_models_top_and_tex.len + vk_ctx->device_shiny_models_top.len); + vk->device_generic_models_top_and_tex.len + vk->device_shiny_models_top.len); - VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &vk_ctx->device_lighting_ubo); - VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &vk_ctx->device_instance_attrs_for_models); + VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &vk->device_lighting_ubo); + VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &vk->device_instance_attrs_for_models); - vk_ctx->device_IT1_image = margaret_prep_image_mem_info_of_colorbuffer( + vk->device_IT1_image = margaret_prep_image_mem_info_of_colorbuffer( MAX_WIN_WIDTH, MAX_WIN_HEIGHT, IT1_format.some); - vk_ctx->device_zbuffer_image = margaret_prep_image_mem_info_of_zbuffer( + vk->device_zbuffer_image = margaret_prep_image_mem_info_of_zbuffer( MAX_WIN_WIDTH, MAX_WIN_HEIGHT, zbuffer_format.some); VecPtrMargaretImageInMemoryInfo device_mem_images_SPAN = - VecPtrMargaretImageInMemoryInfo_new_reserved(2 + 3 * vk_ctx->scene_template.generic_models.len); - VecPtrMargaretImageInMemoryInfo_append(&device_mem_images_SPAN, &vk_ctx->device_IT1_image); - VecPtrMargaretImageInMemoryInfo_append(&device_mem_images_SPAN, &vk_ctx->device_zbuffer_image); + VecPtrMargaretImageInMemoryInfo_new_reserved(2 + 3 * vk->scene_template.generic_models.len); + VecPtrMargaretImageInMemoryInfo_append(&device_mem_images_SPAN, &vk->device_IT1_image); + VecPtrMargaretImageInMemoryInfo_append(&device_mem_images_SPAN, &vk->device_zbuffer_image); - for (size_t i = 0; i < vk_ctx->device_generic_models_top_and_tex.len; i++) { - GenericModelTopAndTexInMemoryInfo* M = &vk_ctx->device_generic_models_top_and_tex.buf[i]; + for (size_t i = 0; i < vk->device_generic_models_top_and_tex.len; i++) { + GenericModelTopAndTexInMemoryInfo* M = &vk->device_generic_models_top_and_tex.buf[i]; VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &M->vbo); VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &M->ebo); VecPtrMargaretImageInMemoryInfo_append(&device_mem_images_SPAN, &M->diffuse); @@ -1894,13 +1816,13 @@ int main() { VecPtrMargaretImageInMemoryInfo_append(&device_mem_images_SPAN, &M->specular); } - for (size_t i = 0; i < vk_ctx->device_shiny_models_top.len; i++) { - ShinyModelTopInMemoryInfo* M = &vk_ctx->device_shiny_models_top.buf[i]; + for (size_t i = 0; i < vk->device_shiny_models_top.len; i++) { + ShinyModelTopInMemoryInfo* M = &vk->device_shiny_models_top.buf[i]; VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &M->vbo); VecPtrMargaretBufferInMemoryInfo_append(&device_mem_buffers_SPAN, &M->ebo); } - vk_ctx->device_mem = margaret_initialize_buffers_and_images(vk_ctx->physical_device, vk_ctx->device, + vk->device_mem = margaret_initialize_buffers_and_images(vk->physical_device, vk->device, VecPtrMargaretBufferInMemoryInfo_to_mspan(&device_mem_buffers_SPAN), VecPtrMargaretImageInMemoryInfo_to_mspan(&device_mem_images_SPAN), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); @@ -1909,26 +1831,26 @@ int main() { VecPtrMargaretBufferInMemoryInfo_drop(device_mem_buffers_SPAN); VecPtrMargaretImageInMemoryInfo_drop(device_mem_images_SPAN); - vk_ctx->command_pool = margaret_create_resettable_command_pool(vk_ctx->device, vk_ctx->queue_fam.for_graphics); - vk_ctx->rendering_command_buffer_0 = margaret_allocate_command_buffer(vk_ctx->device, vk_ctx->command_pool); - vk_ctx->rendering_command_buffer_1 = margaret_allocate_command_buffer(vk_ctx->device, vk_ctx->command_pool); - vk_ctx->transfer_command_buffer = margaret_allocate_command_buffer(vk_ctx->device, vk_ctx->command_pool); + vk->command_pool = margaret_create_resettable_command_pool(vk->device, vk->queue_fam.for_graphics); + vk->rendering_command_buffer_0 = margaret_allocate_command_buffer(vk->device, vk->command_pool); + vk->rendering_command_buffer_1 = margaret_allocate_command_buffer(vk->device, vk->command_pool); + vk->transfer_command_buffer = margaret_allocate_command_buffer(vk->device, vk->command_pool); - vk_ctx->my_cam_control_info = CamControlInfo_new(); - vk_ctx->Buba_control_info = (vec3){0}; + vk->my_cam_control_info = CamControlInfo_new(); + vk->Buba_control_info = (vec3){0}; - vk_ctx->scene = Scene_new(); + vk->scene = Scene_new(); { size_t offset_in_attr_buffer = 0; - for (size_t mi = 0; mi < vk_ctx->scene_template.generic_models.len; mi++) { - const GenericMeshInSceneTemplate* M = VecGenericMeshInSceneTemplate_at(&vk_ctx->scene_template.generic_models, mi); - const GenericModelTopAndTexInMemoryInfo* MM = VecGenericModelTopAndTexInMemoryInfo_at(&vk_ctx->device_generic_models_top_and_tex, mi); - VecUsedGenericModelOnScene_append(&vk_ctx->scene.generic_models, (UsedGenericModelOnScene){ + for (size_t mi = 0; mi < vk->scene_template.generic_models.len; mi++) { + const GenericMeshInSceneTemplate* M = VecGenericMeshInSceneTemplate_at(&vk->scene_template.generic_models, mi); + const GenericModelTopAndTexInMemoryInfo* MM = VecGenericModelTopAndTexInMemoryInfo_at(&vk->device_generic_models_top_and_tex, mi); + VecUsedGenericModelOnScene_append(&vk->scene.generic_models, (UsedGenericModelOnScene){ .model = (GenericModelOnSceneMem){ .vbo = MM->vbo.buffer, .ebo = MM->ebo.buffer, .indexes = M->topology.indexes.len, - .instance_attr_buf = vk_ctx->device_instance_attrs_for_models.buffer, + .instance_attr_buf = vk->device_instance_attrs_for_models.buffer, .instance_attr_buf_offset = offset_in_attr_buffer, .limit_max_instance_count = M->max_instance_count // todo: remove vbo, ebo from here (we don't need it here). @@ -1938,15 +1860,15 @@ int main() { }); offset_in_attr_buffer += M->max_instance_count * sizeof(GenericMeshInstance); } - for (size_t mi = 0; mi < vk_ctx->scene_template.shiny_models.len; mi++) { - const ShinyMeshInSceneTemplate* M = VecShinyMeshInSceneTemplate_at(&vk_ctx->scene_template.shiny_models, mi); - const ShinyModelTopInMemoryInfo* MM = VecShinyModelTopInMemoryInfo_at(&vk_ctx->device_shiny_models_top, mi); - VecUsedShinyModelOnScene_append(&vk_ctx->scene.shiny_models, (UsedShinyModelOnScene){ + for (size_t mi = 0; mi < vk->scene_template.shiny_models.len; mi++) { + const ShinyMeshInSceneTemplate* M = VecShinyMeshInSceneTemplate_at(&vk->scene_template.shiny_models, mi); + const ShinyModelTopInMemoryInfo* MM = VecShinyModelTopInMemoryInfo_at(&vk->device_shiny_models_top, mi); + VecUsedShinyModelOnScene_append(&vk->scene.shiny_models, (UsedShinyModelOnScene){ .model = (ShinyModelOnSceneMem){ .vbo = MM->vbo.buffer, .ebo = MM->ebo.buffer, .indexes = M->topology.indexes.len, - .instance_attr_buf = vk_ctx->device_instance_attrs_for_models.buffer, + .instance_attr_buf = vk->device_instance_attrs_for_models.buffer, .instance_attr_buf_offset = offset_in_attr_buffer, .limit_max_instance_count = M->max_instance_count }, @@ -1958,62 +1880,62 @@ int main() { for (int X = 0; X < 10; X++) { for (int Z = 0; Z < 10; Z++) { - VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk_ctx->scene.generic_models, 0)->instances, + VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk->scene.generic_models, 0)->instances, (GenericMeshInstance){ .model_t = marie_translation_mat4((vec3){11.f * (float)X, -6, 4.f * (float)Z}) }); } } - VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk_ctx->scene.generic_models, 1)->instances, - (GenericMeshInstance){ .model_t = marie_translation_mat4(vk_ctx->Buba_control_info) + VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk->scene.generic_models, 1)->instances, + (GenericMeshInstance){ .model_t = marie_translation_mat4(vk->Buba_control_info) }); - VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk_ctx->scene.generic_models, 2)->instances, + VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk->scene.generic_models, 2)->instances, (GenericMeshInstance){ .model_t = marie_translation_mat4((vec3){5, -7, 6})}); - VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk_ctx->scene.generic_models, 3)->instances, + VecGenericMeshInstance_append(&VecUsedGenericModelOnScene_mat(&vk->scene.generic_models, 3)->instances, (GenericMeshInstance){ .model_t = marie_translation_mat4((vec3){5, -7, -6})}); for (U64 i = 0; i < 5; i++) { - VecShinyMeshInstance_append(&VecUsedShinyModelOnScene_mat(&vk_ctx->scene.shiny_models, 0)->instances, + VecShinyMeshInstance_append(&VecUsedShinyModelOnScene_mat(&vk->scene.shiny_models, 0)->instances, (ShinyMeshInstance){ .model_t = marie_translation_mat4((vec3){ (float)((i * i * 10 + i * 4 + 1) % 13) + 2, (float)((i * i * 11 + i * 2 + 2) % 13), (float)((i * i * 9 + i * 1 + 4) % 13) + 3}), .color_off = (vec3){0.6f, 0.2f, 0.2f}}); } - VecShinyMeshInstance_append(&VecUsedShinyModelOnScene_mat(&vk_ctx->scene.shiny_models, 1)->instances, + VecShinyMeshInstance_append(&VecUsedShinyModelOnScene_mat(&vk->scene.shiny_models, 1)->instances, (ShinyMeshInstance){ .model_t = marie_translation_mat4((vec3){-5, 0, 3}), .color_off = (vec3){0.3f, 0.5f, 0.5f}}); // todo: synchronize them with my cool light sources) - if (vkMapMemory(vk_ctx->device, vk_ctx->host_mem, 0, VK_WHOLE_SIZE, 0, &vk_ctx->host_mem_buffer_mem) != VK_SUCCESS) + if (vkMapMemory(vk->device, vk->host_mem, 0, VK_WHOLE_SIZE, 0, &vk->host_mem_buffer_mem) != VK_SUCCESS) abortf("vkMapMemory"); { SceneTemplate_copy_initial_model_topology_and_rerecord_transfer_cmd( - &vk_ctx->scene_template, &vk_ctx->scene, vk_ctx->host_mem_buffer_mem, - vk_ctx->transfer_command_buffer, vk_ctx->host_mem_buffer.buffer); + &vk->scene_template, &vk->scene, vk->host_mem_buffer_mem, + vk->transfer_command_buffer, vk->host_mem_buffer.buffer); VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, - .commandBufferCount = 1, .pCommandBuffers = &vk_ctx->transfer_command_buffer, + .commandBufferCount = 1, .pCommandBuffers = &vk->transfer_command_buffer, }; - if (vkQueueSubmit(vk_ctx->queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) + if (vkQueueSubmit(vk->queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) abortf("vkQueueSubmit\n"); } - vkDeviceWaitIdle(vk_ctx->device); + vkDeviceWaitIdle(vk->device); { VecMargaretCommandForImageCopying commands = - VecMargaretCommandForImageCopying_new_reserved(vk_ctx->device_generic_models_top_and_tex.len); - for (size_t i = 0; i < vk_ctx->device_generic_models_top_and_tex.len; i++) { + VecMargaretCommandForImageCopying_new_reserved(vk->device_generic_models_top_and_tex.len); + for (size_t i = 0; i < vk->device_generic_models_top_and_tex.len; i++) { const GenericModelTopAndTexInMemoryInfo* M = - VecGenericModelTopAndTexInMemoryInfo_at(&vk_ctx->device_generic_models_top_and_tex, i); + VecGenericModelTopAndTexInMemoryInfo_at(&vk->device_generic_models_top_and_tex, i); U64 diffuse_offset = *VecU64_at(&offset_of_image_in_host_mem_buff_during_init, 3 * i + 0); U64 normal_offset = *VecU64_at(&offset_of_image_in_host_mem_buff_during_init, 3 * i + 1); U64 specular_offset = *VecU64_at(&offset_of_image_in_host_mem_buff_during_init, 3 * i + 2); - memcpy(vk_ctx->host_mem_buffer_mem + diffuse_offset, + memcpy(vk->host_mem_buffer_mem + diffuse_offset, M->reading_diffuse.pixels.buf, TextureDataR8G8B8A8_get_size_in_bytes(&M->reading_diffuse)); - memcpy(vk_ctx->host_mem_buffer_mem + normal_offset, + memcpy(vk->host_mem_buffer_mem + normal_offset, M->reading_normal.pixels.buf, TextureDataR8G8B8A8_get_size_in_bytes(&M->reading_normal)); - memcpy(vk_ctx->host_mem_buffer_mem + specular_offset, + memcpy(vk->host_mem_buffer_mem + specular_offset, M->reading_specular.pixels.buf, TextureDataR8_get_size_in_bytes(&M->reading_specular)); VecMargaretCommandForImageCopying_append(&commands, (MargaretCommandForImageCopying){ .dst_image = &M->diffuse, .host_mem_buff_offset = diffuse_offset}); @@ -2022,82 +1944,82 @@ int main() { VecMargaretCommandForImageCopying_append(&commands, (MargaretCommandForImageCopying){ .dst_image = &M->specular, .host_mem_buff_offset = specular_offset}); } - margaret_rerecord_cmd_buff_for_texture_init(vk_ctx->transfer_command_buffer, vk_ctx->host_mem_buffer.buffer, + margaret_rerecord_cmd_buff_for_texture_init(vk->transfer_command_buffer, vk->host_mem_buffer.buffer, VecMargaretCommandForImageCopying_to_span(&commands), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_SHADER_READ_BIT); VecMargaretCommandForImageCopying_drop(commands); VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, - .commandBufferCount = 1, .pCommandBuffers = &vk_ctx->transfer_command_buffer, + .commandBufferCount = 1, .pCommandBuffers = &vk->transfer_command_buffer, }; - if (vkQueueSubmit(vk_ctx->queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) + if (vkQueueSubmit(vk->queues.graphics_queue, 1, &submit_info, NULL) != VK_SUCCESS) abortf("vkQueueSubmit\n"); } - vkDeviceWaitIdle(vk_ctx->device); + vkDeviceWaitIdle(vk->device); // We sent everything we needed. but host_mem_buffer_mem may be used later // My zbuffer also needs a view - vk_ctx->zbuffer_view = margaret_create_view_for_image(vk_ctx->device, - &vk_ctx->device_zbuffer_image, VK_IMAGE_ASPECT_DEPTH_BIT); + vk->zbuffer_view = margaret_create_view_for_image(vk->device, + &vk->device_zbuffer_image, VK_IMAGE_ASPECT_DEPTH_BIT); /* Here we create an image view into a temporary IT1 texture and a framebuffer for scene rendering */ - vk_ctx->IT1_view = margaret_create_view_for_image(vk_ctx->device, - &vk_ctx->device_IT1_image, VK_IMAGE_ASPECT_COLOR_BIT); + vk->IT1_view = margaret_create_view_for_image(vk->device, + &vk->device_IT1_image, VK_IMAGE_ASPECT_COLOR_BIT); /* Busy creating views for all my textures */ - for (size_t i = 0; i < vk_ctx->device_generic_models_top_and_tex.len; i++) { - GenericModelTopAndTexInMemoryInfo* M = VecGenericModelTopAndTexInMemoryInfo_mat(&vk_ctx->device_generic_models_top_and_tex, i); - M->diffuse_view = margaret_create_view_for_image(vk_ctx->device, &M->diffuse, VK_IMAGE_ASPECT_COLOR_BIT); - M->normal_view = margaret_create_view_for_image(vk_ctx->device, &M->normal, VK_IMAGE_ASPECT_COLOR_BIT); - M->specular_view = margaret_create_view_for_image(vk_ctx->device, &M->specular, VK_IMAGE_ASPECT_COLOR_BIT); + for (size_t i = 0; i < vk->device_generic_models_top_and_tex.len; i++) { + GenericModelTopAndTexInMemoryInfo* M = VecGenericModelTopAndTexInMemoryInfo_mat(&vk->device_generic_models_top_and_tex, i); + M->diffuse_view = margaret_create_view_for_image(vk->device, &M->diffuse, VK_IMAGE_ASPECT_COLOR_BIT); + M->normal_view = margaret_create_view_for_image(vk->device, &M->normal, VK_IMAGE_ASPECT_COLOR_BIT); + M->specular_view = margaret_create_view_for_image(vk->device, &M->specular, VK_IMAGE_ASPECT_COLOR_BIT); } - vk_ctx->IT1_framebuffer = create_IT1_framebuffer(vk_ctx->device, - vk_ctx->IT1_view, vk_ctx->zbuffer_view, vk_ctx->render_pass_0, MAX_WIN_WIDTH, MAX_WIN_HEIGHT); + vk->IT1_framebuffer = create_IT1_framebuffer(vk->device, + vk->IT1_view, vk->zbuffer_view, vk->render_pass_0, MAX_WIN_WIDTH, MAX_WIN_HEIGHT); // Right now I only have one light source - VecPipeline0PointLight_append(&vk_ctx->scene.point_lights, (Pipeline0PointLight){.pos = {0}, .color = {100, 100, 100}}); + VecPipeline0PointLight_append(&vk->scene.point_lights, (Pipeline0PointLight){.pos = {0}, .color = {100, 100, 100}}); // These samplers are global for a lot of my future textures - vk_ctx->linear_sampler = margaret_create_sampler(vk_ctx->physical_device, vk_ctx->device, true); - vk_ctx->nearest_sampler = margaret_create_sampler(vk_ctx->physical_device, vk_ctx->device, false); + vk->linear_sampler = margaret_create_sampler(vk->physical_device, vk->device, true); + vk->nearest_sampler = margaret_create_sampler(vk->physical_device, vk->device, false); - vk_ctx->descriptor_pool = margaret_create_descriptor_set_pool(vk_ctx->device, - 1 + 1 * vk_ctx->device_generic_models_top_and_tex.len, - 1 + 3 * vk_ctx->device_generic_models_top_and_tex.len, - 2 + 1 * vk_ctx->device_generic_models_top_and_tex.len); - for (size_t i = 0; i < vk_ctx->device_generic_models_top_and_tex.len; i++) { - GenericModelTopAndTexInMemoryInfo* M = &vk_ctx->device_generic_models_top_and_tex.buf[i]; + vk->descriptor_pool = margaret_create_descriptor_set_pool(vk->device, + 1 + 1 * vk->device_generic_models_top_and_tex.len, + 1 + 3 * vk->device_generic_models_top_and_tex.len, + 2 + 1 * vk->device_generic_models_top_and_tex.len); + for (size_t i = 0; i < vk->device_generic_models_top_and_tex.len; i++) { + GenericModelTopAndTexInMemoryInfo* M = &vk->device_generic_models_top_and_tex.buf[i]; M->p_0a_set_0 = margaret_allocate_descriptor_set( - vk_ctx->device, vk_ctx->descriptor_pool, vk_ctx->pipeline_hands_0a.descriptor_set_layout); + vk->device, vk->descriptor_pool, vk->pipeline_hands_0a.descriptor_set_layout); } - vk_ctx->descriptor_set_for_pipeline_0b = margaret_allocate_descriptor_set( - vk_ctx->device, vk_ctx->descriptor_pool, vk_ctx->pipeline_hands_0b.descriptor_set_layout); - vk_ctx->descriptor_set_for_pipeline_1 = margaret_allocate_descriptor_set( - vk_ctx->device, vk_ctx->descriptor_pool, vk_ctx->pipeline_hands_1.descriptor_set_layout); + vk->descriptor_set_for_pipeline_0b = margaret_allocate_descriptor_set( + vk->device, vk->descriptor_pool, vk->pipeline_hands_0b.descriptor_set_layout); + vk->descriptor_set_for_pipeline_1 = margaret_allocate_descriptor_set( + vk->device, vk->descriptor_pool, vk->pipeline_hands_1.descriptor_set_layout); // Configuring my descriptor sets, that I just allocated - for (size_t i = 0; i < vk_ctx->device_generic_models_top_and_tex.len; i++) { - GenericModelTopAndTexInMemoryInfo* M = &vk_ctx->device_generic_models_top_and_tex.buf[i]; + for (size_t i = 0; i < vk->device_generic_models_top_and_tex.len; i++) { + GenericModelTopAndTexInMemoryInfo* M = &vk->device_generic_models_top_and_tex.buf[i]; VkDescriptorBufferInfo buffer_info_for_descriptor_0_in_set_0a = { - .buffer = vk_ctx->device_lighting_ubo.buffer, + .buffer = vk->device_lighting_ubo.buffer, .offset = 0, .range = sizeof(Pipeline0UBO), }; VkDescriptorImageInfo image_info_for_descriptor_1_in_set_0a = { - .sampler = vk_ctx->linear_sampler, + .sampler = vk->linear_sampler, .imageView = M->diffuse_view, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }; VkDescriptorImageInfo image_info_for_descriptor_2_in_set_0a = { - .sampler = vk_ctx->nearest_sampler, + .sampler = vk->nearest_sampler, .imageView = M->normal_view, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }; VkDescriptorImageInfo image_info_for_descriptor_3_in_set_0a = { - .sampler = vk_ctx->nearest_sampler, + .sampler = vk->nearest_sampler, .imageView = M->specular_view, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }; @@ -2139,24 +2061,24 @@ int main() { .pImageInfo = &image_info_for_descriptor_3_in_set_0a, }, }; - vkUpdateDescriptorSets(vk_ctx->device, ARRAY_SIZE(writes_in_descriptor_set), writes_in_descriptor_set, 0, NULL); + vkUpdateDescriptorSets(vk->device, ARRAY_SIZE(writes_in_descriptor_set), writes_in_descriptor_set, 0, NULL); } VkDescriptorBufferInfo buffer_info_for_descriptor_0_in_set_0b = { - .buffer = vk_ctx->device_lighting_ubo.buffer, + .buffer = vk->device_lighting_ubo.buffer, .offset = 0, .range = sizeof(Pipeline0UBO), }; VkDescriptorImageInfo image_info_for_descriptor_0_in_set_1 = { - .sampler = vk_ctx->nearest_sampler, - .imageView = vk_ctx->IT1_view, + .sampler = vk->nearest_sampler, + .imageView = vk->IT1_view, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, }; VkWriteDescriptorSet writes_in_descriptor_sets[] = { { .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = vk_ctx->descriptor_set_for_pipeline_0b, + .dstSet = vk->descriptor_set_for_pipeline_0b, .dstBinding = 0, .dstArrayElement = 0, .descriptorCount = 1, @@ -2166,7 +2088,7 @@ int main() { { .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = vk_ctx->descriptor_set_for_pipeline_1, + .dstSet = vk->descriptor_set_for_pipeline_1, .dstBinding = 0, .dstArrayElement = 0, .descriptorCount = 1, @@ -2174,91 +2096,65 @@ int main() { .pImageInfo = &image_info_for_descriptor_0_in_set_1, }, }; - vkUpdateDescriptorSets(vk_ctx->device, ARRAY_SIZE(writes_in_descriptor_sets), writes_in_descriptor_sets, 0, NULL); + vkUpdateDescriptorSets(vk->device, ARRAY_SIZE(writes_in_descriptor_sets), writes_in_descriptor_sets, 0, NULL); - vk_ctx->jane = Jane_r0_create(vk_ctx->device); + vk->jane = Jane_r0_create(vk->device); state.prev_key_frame_time = margaret_clock_gettime_monotonic_raw(); state.frame_count_since_key = 0; /* Will happen mid-frame */ - vk_ctx->dt_transfer_required = true; + vk->dt_transfer_required = true; while (wl_display_dispatch(state.wl_display) >= 0) { if (state.closed) break; } - vkDeviceWaitIdle(vk_ctx->device); + vkDeviceWaitIdle(vk->device); // The End - vkDestroyDescriptorPool(vk_ctx->device, vk_ctx->descriptor_pool, NULL); - vkDestroySampler(vk_ctx->device, vk_ctx->linear_sampler, NULL); - vkDestroySampler(vk_ctx->device, vk_ctx->nearest_sampler, NULL); + vkDestroyDescriptorPool(vk->device, vk->descriptor_pool, NULL); + vkDestroySampler(vk->device, vk->linear_sampler, NULL); + vkDestroySampler(vk->device, vk->nearest_sampler, NULL); - // vkDestroyImageView(vk_ctx->device, vk_ctx->cyl_1_normal_texture_view, NULL); - // vkDestroyImageView(vk_ctx->device, vk_ctx->cyl_1_diffuse_texture_view, NULL); - vkDestroyFramebuffer(vk_ctx->device, vk_ctx->IT1_framebuffer, NULL); - vkDestroyImageView(vk_ctx->device, vk_ctx->IT1_view, NULL); - vkDestroyImageView(vk_ctx->device, vk_ctx->zbuffer_view, NULL); + // vkDestroyImageView(vk->device, vk->cyl_1_normal_texture_view, NULL); + // vkDestroyImageView(vk->device, vk->cyl_1_diffuse_texture_view, NULL); + vkDestroyFramebuffer(vk->device, vk->IT1_framebuffer, NULL); + vkDestroyImageView(vk->device, vk->IT1_view, NULL); + vkDestroyImageView(vk->device, vk->zbuffer_view, NULL); - Scene_drop(vk_ctx->scene); + Scene_drop(vk->scene); - vkDestroyCommandPool(vk_ctx->device, vk_ctx->command_pool, NULL); + vkDestroyCommandPool(vk->device, vk->command_pool, NULL); - vkUnmapMemory(vk_ctx->device, vk_ctx->host_mem); - vkFreeMemory(vk_ctx->device, vk_ctx->host_mem, NULL); - vkFreeMemory(vk_ctx->device, vk_ctx->device_mem, NULL); + vkUnmapMemory(vk->device, vk->host_mem); + vkFreeMemory(vk->device, vk->host_mem, NULL); + vkFreeMemory(vk->device, vk->device_mem, NULL); // todo: delete all the crap - // vkDestroyImage(vk_ctx->device, vk_ctx->device_cyl_1_diffuse_texture.image, NULL); - // vkDestroyImage(vk_ctx->device, vk_ctx->device_cyl_1_normal_texture.image, NULL); - vkDestroyImage(vk_ctx->device, vk_ctx->device_IT1_image.image, NULL); - vkDestroyImage(vk_ctx->device, vk_ctx->device_zbuffer_image.image, NULL); - vkDestroyBuffer(vk_ctx->device, vk_ctx->device_lighting_ubo.buffer, NULL); + // vkDestroyImage(vk->device, vk->device_cyl_1_diffuse_texture.image, NULL); + // vkDestroyImage(vk->device, vk->device_cyl_1_normal_texture.image, NULL); + vkDestroyImage(vk->device, vk->device_IT1_image.image, NULL); + vkDestroyImage(vk->device, vk->device_zbuffer_image.image, NULL); + vkDestroyBuffer(vk->device, vk->device_lighting_ubo.buffer, NULL); - vkDestroyBuffer(vk_ctx->device, vk_ctx->device_instance_attrs_for_models.buffer, NULL); + vkDestroyBuffer(vk->device, vk->device_instance_attrs_for_models.buffer, NULL); - // for (size_t i = 0; i < vk_ctx->device_ebo_buffers_for_generic_meshes.len; i++) - // vkDestroyBuffer(vk_ctx->device, - // VecMargaretBufferInMemoryInfo_at(&vk_ctx->device_ebo_buffers_for_generic_meshes, i)->buffer, - // NULL); - // VecMargaretBufferInMemoryInfo_drop(vk_ctx->device_ebo_buffers_for_generic_meshes); - // - // for (size_t i = 0; i < vk_ctx->device_vbo_buffers_for_generic_meshes.len; i++) - // vkDestroyBuffer(vk_ctx->device, - // VecMargaretBufferInMemoryInfo_at(&vk_ctx->device_vbo_buffers_for_generic_meshes, i)->buffer, - // NULL); - // VecMargaretBufferInMemoryInfo_drop(vk_ctx->device_vbo_buffers_for_generic_meshes); - // - // for (size_t i = 0; i < vk_ctx->device_ebo_buffers_for_shiny_meshes.len; i++) - // vkDestroyBuffer(vk_ctx->device, - // VecMargaretBufferInMemoryInfo_at(&vk_ctx->device_ebo_buffers_for_shiny_meshes, i)->buffer, - // NULL); - // VecMargaretBufferInMemoryInfo_drop(vk_ctx->device_ebo_buffers_for_shiny_meshes); - // - // for (size_t i = 0; i < vk_ctx->device_vbo_buffers_for_shiny_meshes.len; i++) - // vkDestroyBuffer(vk_ctx->device, - // VecMargaretBufferInMemoryInfo_at(&vk_ctx->device_vbo_buffers_for_shiny_meshes, i)->buffer, - // NULL); - // VecMargaretBufferInMemoryInfo_drop(vk_ctx->device_vbo_buffers_for_shiny_meshes); + vkDestroyBuffer(vk->device, vk->host_mem_buffer.buffer, NULL); + // TextureDataR8G8B8A8_drop(vk->cyl_1_normal_tex); + // TextureDataR8G8B8A8_drop(vk->cyl_1_diffuse_tex); + SceneTemplate_drop(vk->scene_template); - - vkDestroyBuffer(vk_ctx->device, vk_ctx->host_mem_buffer.buffer, NULL); - - // TextureDataR8G8B8A8_drop(vk_ctx->cyl_1_normal_tex); - // TextureDataR8G8B8A8_drop(vk_ctx->cyl_1_diffuse_tex); - SceneTemplate_drop(vk_ctx->scene_template); - - MargaretSwapchainBundle_drop_with_device(vk_ctx->device, vk_ctx->swfb); - Jane_r0_destroy(vk_ctx->device, vk_ctx->jane); - destroy_graphics_pipeline_hands(vk_ctx->device, vk_ctx->pipeline_hands_1); - vkDestroyRenderPass(vk_ctx->device, vk_ctx->render_pass_1, NULL); - destroy_graphics_pipeline_hands(vk_ctx->device, vk_ctx->pipeline_hands_0b); - destroy_graphics_pipeline_hands(vk_ctx->device, vk_ctx->pipeline_hands_0a); - vkDestroyRenderPass(vk_ctx->device, vk_ctx->render_pass_0, NULL); - vkDestroyDevice(vk_ctx->device, NULL); - vkDestroySurfaceKHR(instance, vk_ctx->surface, NULL); - MargaretInstanceAndItsDebug_drop(vk_ctx->instance_and_debug); + MargaretSwapchainBundle_drop_with_device(vk->device, vk->swfb); + Jane_r0_destroy(vk->device, vk->jane); + destroy_graphics_pipeline_hands(vk->device, vk->pipeline_hands_1); + vkDestroyRenderPass(vk->device, vk->render_pass_1, NULL); + destroy_graphics_pipeline_hands(vk->device, vk->pipeline_hands_0b); + destroy_graphics_pipeline_hands(vk->device, vk->pipeline_hands_0a); + vkDestroyRenderPass(vk->device, vk->render_pass_0, NULL); + vkDestroyDevice(vk->device, NULL); + vkDestroySurfaceKHR(instance, vk->surface, NULL); + MargaretInstanceAndItsDebug_drop(vk->instance_and_debug); if (state.wl_callback) wl_callback_destroy(state.wl_callback); diff --git a/src/l2/tests/r0/r0_assets.h b/src/l2/tests/r0/r0_assets.h index 3f5e629..842ee45 100644 --- a/src/l2/tests/r0/r0_assets.h +++ b/src/l2/tests/r0/r0_assets.h @@ -32,7 +32,6 @@ GenericMeshTopology GenericMeshTopology_clone(const GenericMeshTopology* self) { typedef struct { GenericMeshTopology topology; - U32 max_instance_count; VecU8 diffuse_texture_path; VecU8 normal_texture_path; VecU8 specular_texture_path; @@ -46,7 +45,10 @@ void GenericMeshInSceneTemplate_drop(GenericMeshInSceneTemplate self) { } GenericMeshInSceneTemplate GenericMeshInSceneTemplate_clone(const GenericMeshInSceneTemplate* self) { - return (GenericMeshInSceneTemplate){.topology = GenericMeshTopology_clone(&self->topology), .max_instance_count = self->max_instance_count}; + return (GenericMeshInSceneTemplate){.topology = GenericMeshTopology_clone(&self->topology), + .diffuse_texture_path = VecU8_clone(&self->diffuse_texture_path), + .normal_texture_path = VecU8_clone(&self->normal_texture_path), + .specular_texture_path = VecU8_clone(&self->specular_texture_path)}; } #include "../../../../gen/l1/eve/r0/VecGenericMeshInSceneTemplate.h" @@ -54,8 +56,6 @@ GenericMeshInSceneTemplate GenericMeshInSceneTemplate_clone(const GenericMeshInS typedef struct { mat4 model_t; } GenericMeshInstance; -#include "../../../../gen/l1/eve/r0/VecGenericMeshInstance.h" - typedef struct { @@ -99,9 +99,6 @@ typedef struct { vec3 color_off; vec3 color_on; } ShinyMeshInstance; -#include "../../../../gen/l1/eve/r0/VecShinyMeshInstance.h" - - typedef struct { vec2 win_scale; @@ -124,7 +121,6 @@ typedef struct { float d; char _padding_3[12]; } Pipeline0Spotlight; -#include "../../../../gen/l1/eve/r0/VecPipeline0Spotlight.h" typedef struct { vec3 pos; @@ -132,52 +128,16 @@ typedef struct { vec3 color; char _padding_1[4]; } Pipeline0PointLight; -#include "../../../../gen/l1/eve/r0/VecPipeline0PointLight.h" typedef struct { VecGenericMeshInSceneTemplate generic_models; VecShinyMeshInSceneTemplate shiny_models; - size_t point_lights_max_count; - size_t spotlights_max_count; } SceneTemplate; void SceneTemplate_drop(SceneTemplate self) { VecGenericMeshInSceneTemplate_drop(self.generic_models); } -size_t SceneTemplate_get_space_needed_for_all_instance_attributes(const SceneTemplate* self) { - size_t s = 0; - for (size_t mi = 0; mi < self->generic_models.len; mi++) { - const GenericMeshInSceneTemplate* M = VecGenericMeshInSceneTemplate_at(&self->generic_models, mi); - s += M->max_instance_count * sizeof(GenericMeshInstance); - } - for (size_t mi = 0; mi < self->shiny_models.len; mi++) { - const ShinyMeshInSceneTemplate* M = VecShinyMeshInSceneTemplate_at(&self->shiny_models, mi); - s += M->max_instance_count * sizeof(ShinyMeshInstance); - } - return s; -} - -size_t SceneTemplate_get_space_needed_for_widest_state_transfer(const SceneTemplate* self) { - return self->point_lights_max_count * sizeof(Pipeline0PointLight) + - self->spotlights_max_count * sizeof(Pipeline0Spotlight) + - SceneTemplate_get_space_needed_for_all_instance_attributes(self); - -} - -size_t SceneTemplate_get_space_for_initial_model_topology_transfer(const SceneTemplate* self) { - size_t s = 0; - for (size_t mi = 0; mi < self->generic_models.len; mi++) { - const GenericMeshInSceneTemplate* M = VecGenericMeshInSceneTemplate_at(&self->generic_models, mi); - s += M->topology.vertices.len * sizeof(GenericMeshVertex) + M->topology.indexes.len * sizeof(U32); - } - for (size_t mi = 0; mi < self->shiny_models.len; mi++) { - const ShinyMeshInSceneTemplate* M = VecShinyMeshInSceneTemplate_at(&self->shiny_models, mi); - s += M->topology.vertices.len * sizeof(ShinyMeshVertex) + M->topology.indexes.len * sizeof(U32); - } - return s; -} - #define pipeline_0_ubo_point_light_max_count 20 #define pipeline_0_ubo_spotlight_max_count 120 @@ -189,9 +149,7 @@ typedef struct { Pipeline0Spotlight spotlight_arr[pipeline_0_ubo_spotlight_max_count]; } Pipeline0UBO; -size_t GenericMeshTopology_get_space_needed_for_staging_buffer(const GenericMeshTopology* self) { - return MAX_U64(self->vertices.len * sizeof(GenericMeshVertex), self->indexes.len * sizeof(U32)); -} +/* generating my cool textures2 */ void TextureDataR8_pixel_maxing(TextureDataR8* self, S32 x, S32 y, U8 val) { if (x < 0 || y < 0 || (size_t)x >= self->width) @@ -866,9 +824,8 @@ ShinyMeshTopology generate_shiny_rhombicuboctahedron(float r) { return res; } -GenericMeshInSceneTemplate GenericMeshInSceneTemplate_for_log(U32 w, U32 r, U32 k, U32 max_instance_count) { +GenericMeshInSceneTemplate GenericMeshInSceneTemplate_for_log(U32 w, U32 r, U32 k) { return (GenericMeshInSceneTemplate){.topology = generate_one_fourth_of_a_cylinder((float)w, (float)r, k), - .max_instance_count = max_instance_count, .diffuse_texture_path = VecU8_format("textures/log_%u_%u_%u_diffuse.png", w, r, k), .normal_texture_path = VecU8_format("textures/log_%u_%u_%u_NORMAL.png", w, r, k), .specular_texture_path = VecU8_format("textures/log_%u_%u_%u_specular.png", w, r, k), diff --git a/src/l2/tests/r0/r0_scene.h b/src/l2/tests/r0/r0_scene.h index b8e077e..976789e 100644 --- a/src/l2/tests/r0/r0_scene.h +++ b/src/l2/tests/r0/r0_scene.h @@ -3,52 +3,42 @@ #include "r0_assets.h" -/* No offset yet. - * Contains references to vulkan handlers for buffers */ +#include "../../margaret/vulkan_utils.h" +#include "../../margaret/vulkan_memory_claire.h" + typedef struct { - VkBuffer vbo; - VkBuffer ebo; + MargaretMAIterator staging_vbo; + MargaretMAIterator staging_ebo; + MargaretMAIterator vbo; + MargaretMAIterator ebo; size_t indexes; - VkBuffer instance_attr_buf; - VkDeviceSize instance_attr_buf_offset; - U32 limit_max_instance_count; - VkImage diffuse_texture; - VkImage normal_texture; - VkImage specular_texture; + MargaretMAIterator staging_instance_attr_buf; + MargaretMAIterator instance_attr_buf; + U64 instance_vec_len; + U64 instance_vec_capacity; + MargaretMAIterator staging_diffuse_tex_buf; + MargaretMAIterator staging_normal_tex_buf; + MargaretMAIterator staging_specular_tex_buf; + MargaretMAIterator diffuse_texture; + MargaretMAIterator normal_texture; + MargaretMAIterator specular_texture; } GenericModelOnSceneMem; -/* Contains both data for model instances attributes and buffer (+offset) where it is stored */ -/* Also, I made it non-clonable. Thus */ -typedef struct { - GenericModelOnSceneMem model; - VecGenericMeshInstance instances; -} UsedGenericModelOnScene; - -void UsedGenericModelOnScene_drop(UsedGenericModelOnScene self) { - VecGenericMeshInstance_drop(self.instances); -} - -#include "../../../../gen/l1/eve/r0/VecUsedGenericModelOnScene.h" +#include "../../../../gen/l1/eve/r0/VecGenericModelOnSceneMem.h" typedef struct { - VkBuffer vbo; - VkBuffer ebo; + MargaretMAIterator vbo; + MargaretMAIterator ebo; + MargaretMAIterator staging_vbo; + MargaretMAIterator staging_ebo; size_t indexes; - VkBuffer instance_attr_buf; - VkDeviceSize instance_attr_buf_offset; - U32 limit_max_instance_count; + MargaretMAIterator instance_attr_buf; + MargaretMAIterator staging_instance_attr_buf; + U64 instance_vec_capacity; + U64 instance_vec_len; } ShinyModelOnSceneMem; -typedef struct { - ShinyModelOnSceneMem model; - VecShinyMeshInstance instances; -} UsedShinyModelOnScene; - -void UsedShinyModelOnScene_drop(UsedShinyModelOnScene self) { - VecShinyMeshInstance_drop(self.instances); -} - -#include "../../../../gen/l1/eve/r0/VecUsedShinyModelOnScene.h" +#include "../../../../gen/l1/eve/r0/VecShinyModelOnSceneMem.h" typedef struct { float fov; @@ -102,79 +92,77 @@ void CamControlInfo_update_direction(CamControlInfo* self, int win_width, int wi /* Non copyable */ typedef struct { - VecUsedGenericModelOnScene generic_models; - VecUsedShinyModelOnScene shiny_models; + VecGenericModelOnSceneMem generic_models; + VecShinyModelOnSceneMem shiny_models; VkClearColorValue color; float gamma_correction_factor; float hdr_factor; float lsd_factor; float anim_time; // A timer, passed to functions that push push constants - VecPipeline0Spotlight spotlights; - VecPipeline0PointLight point_lights; + MargaretMAIterator pipeline0_staging_ubo; + MargaretMAIterator pipeline0_ubo; + /* point_light_vec_len and spotlight_vec_len are stored in staging (and also device local) buffers */ + + CamControlInfo cam; + vec3 funny_vector; } Scene; -Scene Scene_new() { - return (Scene){.generic_models = VecUsedGenericModelOnScene_new(), .shiny_models = VecUsedShinyModelOnScene_new(), +Scene Scene_new(VecGenericModelOnSceneMem generic_models, VecShinyModelOnSceneMem shiny_models, + MargaretMAIterator pipeline0_staging_ubo, MargaretMAIterator pipeline0_ubo) { + return (Scene){.generic_models = generic_models, .shiny_models = shiny_models, .color = {.float32 = {0, 0, 0, 1}}, .gamma_correction_factor = 2.2f, .hdr_factor = 1, .lsd_factor = 0, .anim_time = 0, - .spotlights = VecPipeline0Spotlight_new(), .point_lights = VecPipeline0PointLight_new() + .pipeline0_staging_ubo = pipeline0_staging_ubo, .pipeline0_ubo = pipeline0_ubo }; } void Scene_drop(Scene self) { - VecUsedGenericModelOnScene_drop(self.generic_models); - VecUsedShinyModelOnScene_drop(self.shiny_models); - VecPipeline0Spotlight_drop(self.spotlights); - VecPipeline0PointLight_drop(self.point_lights); + VecGenericModelOnSceneMem_drop(self.generic_models); + VecShinyModelOnSceneMem_drop(self.shiny_models); } -void SceneTemplate_copy_initial_model_topology_and_rerecord_transfer_cmd( - const SceneTemplate* scene_template, const Scene* scene, char* host_mem_buffer_mem, - VkCommandBuffer command_buffer, VkBuffer host_memory_buffer - ) { +/* Does not reset, does not begin, does not end command_buffer */ +void SceneTemplate_copy_initial_model_topology_and_record_transfer_cmd( + const SceneTemplate* scene_template, const Scene* scene, VkCommandBuffer command_buffer ) { assert(scene_template->generic_models.len == scene->generic_models.len); assert(scene_template->shiny_models.len == scene->shiny_models.len); - if (vkResetCommandBuffer(command_buffer, 0) != VK_SUCCESS) - abortf("vkResetCommandBuffer"); - VkCommandBufferBeginInfo info_begin = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; - if (vkBeginCommandBuffer(command_buffer, &info_begin) != VK_SUCCESS) - abortf("vkBeginCommandBuffer"); - - size_t offset = 0; - // todo: use BufferCopyCmd 2 (to perform all the copying in one command) - // todo: ot use one buffer per all the data + assert(scene_template->generic_models.len == scene->generic_models.len); for (size_t mi = 0; mi < scene_template->generic_models.len; mi++) { const GenericMeshInSceneTemplate* mt = VecGenericMeshInSceneTemplate_at(&scene_template->generic_models, mi); - const GenericModelOnSceneMem *m_buf = &VecUsedGenericModelOnScene_at(&scene->generic_models, mi)->model; + const GenericModelOnSceneMem *mm = VecGenericModelOnSceneMem_at(&scene->generic_models, mi); + size_t vbo_len = mt->topology.vertices.len * sizeof(GenericMeshVertex); - memcpy(host_mem_buffer_mem + offset, mt->topology.vertices.buf, vbo_len); - VkBufferCopy ra = {.srcOffset = offset, .dstOffset = 0, .size = vbo_len}; - vkCmdCopyBuffer(command_buffer, host_memory_buffer, m_buf->vbo, 1, &ra); - offset += vbo_len; + GenericMeshVertex* staging_vbo = (GenericMeshVertex*)MargaretMAIterator_get_mapped(mm->staging_vbo); + memcpy(staging_vbo, mt->topology.vertices.buf, vbo_len); + vkCmdCopyBuffer(command_buffer, mm->staging_vbo->value.me.buf.buffer, mm->vbo->value.me.buf.buffer, + 1, &(VkBufferCopy){ .srcOffset = 0, .dstOffset = 0, .size = vbo_len}); + + assert(mt->topology.indexes.len == mm->indexes); size_t ebo_len = mt->topology.indexes.len * sizeof(U32); - memcpy(host_mem_buffer_mem + offset, mt->topology.indexes.buf, ebo_len); - VkBufferCopy rb = {.srcOffset = offset, .dstOffset = 0, .size = ebo_len}; - vkCmdCopyBuffer(command_buffer, host_memory_buffer, m_buf->ebo, 1, &rb); - offset += ebo_len; - } - for (size_t mi = 0; mi < scene_template->shiny_models.len; mi++) { - const ShinyMeshInSceneTemplate* mt = VecShinyMeshInSceneTemplate_at(&scene_template->shiny_models, mi); - const ShinyModelOnSceneMem *m_buf = &VecUsedShinyModelOnScene_at(&scene->shiny_models, mi)->model; - size_t vbo_len = mt->topology.vertices.len * sizeof(ShinyMeshVertex); - memcpy(host_mem_buffer_mem + offset, mt->topology.vertices.buf, vbo_len); - VkBufferCopy ra = {.srcOffset = offset, .dstOffset = 0, .size = vbo_len}; - vkCmdCopyBuffer(command_buffer, host_memory_buffer, m_buf->vbo, 1, &ra); - offset += vbo_len; - size_t ebo_len = mt->topology.indexes.len * sizeof(U32); - memcpy(host_mem_buffer_mem + offset, mt->topology.indexes.buf, ebo_len); - VkBufferCopy rb = {.srcOffset = offset, .dstOffset = 0, .size = ebo_len}; - vkCmdCopyBuffer(command_buffer, host_memory_buffer, m_buf->ebo, 1, &rb); - offset += ebo_len; + U32* staging_ebo = (U32*)MargaretMAIterator_get_mapped(mm->staging_ebo); + memcpy(staging_ebo, mt->topology.indexes.buf, ebo_len); + vkCmdCopyBuffer(command_buffer, mm->staging_ebo->value.me.buf.buffer, mm->ebo->value.me.buf.buffer, + 1, &(VkBufferCopy){.srcOffset = 0, .dstOffset = 0, .size = ebo_len}); } - if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) - abortf("vkEndCommandBuffer"); + for (size_t mi = 0; mi < scene_template->shiny_models.len; mi++) { + const ShinyMeshInSceneTemplate* mt = VecShinyMeshInSceneTemplate_at(&scene_template->shiny_models, mi); + const ShinyModelOnSceneMem *mm = VecShinyModelOnSceneMem_at(&scene->shiny_models, mi); + + size_t vbo_len = mt->topology.vertices.len * sizeof(ShinyMeshVertex); + ShinyMeshVertex* staging_vbo = (ShinyMeshVertex*)MargaretMAIterator_get_mapped(mm->staging_vbo); + memcpy(staging_vbo, mt->topology.vertices.buf, vbo_len); + vkCmdCopyBuffer(command_buffer, mm->staging_vbo->value.me.buf.buffer, mm->vbo->value.me.buf.buffer, + 1, &(VkBufferCopy){ .srcOffset = 0, .dstOffset = 0, .size = vbo_len}); + + assert(mt->topology.indexes.len == mm->indexes); + size_t ebo_len = mt->topology.indexes.len * sizeof(U32); + U32* staging_ebo = (U32*)MargaretMAIterator_get_mapped(mm->staging_ebo); + memcpy(staging_ebo, mt->topology.indexes.buf, ebo_len); + vkCmdCopyBuffer(command_buffer, mm->staging_ebo->value.me.buf.buffer, mm->ebo->value.me.buf.buffer, + 1, &(VkBufferCopy){.srcOffset = 0, .dstOffset = 0, .size = ebo_len}); + } } #endif