pub/prototype1
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Saving progress. Rewrote r0_scene.h, r0_assets.h, vk_ctx struct according to new design. Но потом я отвлёкся от прогресса из-за обязанностей няньки. Anyway. I need to test somrthing really quick. Going back to master

Browse Source
This commit is contained in:
Андреев Григорий 2025-11-30 03:54:02 +03:00
parent 8ec7bff490
commit 438015b842
8 changed files with 487 additions and 631 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

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

3
Makefile
View File

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

15
src/l1/anne/some_tests.h
View File

@ -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 */

5
src/l2/margaret/vulkan_memory_claire.h
View File

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

12
src/l2/margaret/vulkan_utils.h
View File

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

864
src/l2/tests/r0/r0.c
View File

File diff suppressed because it is too large Load Diff

55
src/l2/tests/r0/r0_assets.h
View File

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

160
src/l2/tests/r0/r0_scene.h
View File

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