brossferatu/coven
Public Access
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Tiny refactor

Browse Source
This commit is contained in:
Daniel Bross
2024-10-18 16:12:24 +02:00
parent 8ee000ab74
commit 1d5b4499a4
38 changed files with 645 additions and 637 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
renderer/renderer.jai
View File

@@ -622,54 +622,54 @@ Renderer :: struct {
}
create_renderer :: (window: *Window) -> *Renderer {
renderer = New(Renderer);
renderer.pool = .{};
engine.renderer = New(Renderer);
engine.renderer.pool = .{};
a : Allocator;
a.proc = flat_pool_allocator_proc;
a.data = *renderer.pool;
renderer.allocator = a;
a.data = *engine.renderer.pool;
engine.renderer.allocator = a;
if !init(*renderer.watcher, file_change_callback, *"Cowabunga", events_to_watch = .MODIFIED) {
if !init(*engine.renderer.watcher, file_change_callback, *"Cowabunga", events_to_watch = .MODIFIED) {
log_error("Could not initialize watcher");
}
// @Incomplete
//if !add_directories(*renderer.watcher, "../assets/shaders") {
//if !add_directories(*engine.renderer.watcher, "../assets/shaders") {
// exit(4);
//}
renderer.backend = create_backend(window);
renderer.render_target_width = window.width;
renderer.render_target_height = window.height;
engine.renderer.backend = create_backend(window);
engine.renderer.render_target_width = engine.window.width;
engine.renderer.render_target_height = engine.window.height;
renderer.pipeline_states.allocator = renderer.allocator;
renderer.fonts.allocator = renderer.allocator;
renderer.textures.data.allocator = renderer.allocator;
renderer.textures.indices.allocator = renderer.allocator;
renderer.buffers.data.allocator = renderer.allocator;
renderer.buffers.indices.allocator = renderer.allocator;
renderer.shaders.allocator = renderer.allocator;
renderer.command_buffer.commands.allocator = renderer.allocator;
renderer.text_render_buffers.allocator = renderer.allocator;
renderer.render_targets.data.allocator = renderer.allocator;
renderer.render_targets.indices.allocator = renderer.allocator;
renderer.depth_stencil_buffers.data.allocator = renderer.allocator;
renderer.depth_stencil_buffers.indices.allocator = renderer.allocator;
engine.renderer.pipeline_states.allocator = engine.renderer.allocator;
engine.renderer.fonts.allocator = engine.renderer.allocator;
engine.renderer.textures.data.allocator = engine.renderer.allocator;
engine.renderer.textures.indices.allocator = engine.renderer.allocator;
engine.renderer.buffers.data.allocator = engine.renderer.allocator;
engine.renderer.buffers.indices.allocator = engine.renderer.allocator;
engine.renderer.shaders.allocator = engine.renderer.allocator;
engine.renderer.command_buffer.commands.allocator = engine.renderer.allocator;
engine.renderer.text_render_buffers.allocator = engine.renderer.allocator;
engine.renderer.render_targets.data.allocator = engine.renderer.allocator;
engine.renderer.render_targets.indices.allocator = engine.renderer.allocator;
engine.renderer.depth_stencil_buffers.data.allocator = engine.renderer.allocator;
engine.renderer.depth_stencil_buffers.indices.allocator = engine.renderer.allocator;
for 0..1024 {
buffer := create_vertex_buffer(renderer, null, size_of(Point) * 6 * renderer.max_characters_per_buffer, stride=size_of(Point), mappable=true);
array_add(*renderer.text_render_buffers, buffer);
buffer := create_vertex_buffer(engine.renderer, null, size_of(Point) * 6 * engine.renderer.max_characters_per_buffer, stride=size_of(Point), mappable=true);
array_add(*engine.renderer.text_render_buffers, buffer);
}
init_freetype();
init_default_meshes();
array_reserve(*renderer.command_buffer.commands, 4096);
array_reserve(*engine.renderer.command_buffer.commands, 4096);
renderer.render_graph = new_render_graph();
engine.renderer.render_graph = new_render_graph();
return renderer;
return engine.renderer;
}
init_default_pipelines :: () {
@@ -694,7 +694,7 @@ init_default_pipelines :: () {
params[1].name = "tex";
params[1].slot = 1;
renderer.default_pipelines.message_text = create_pipeline_state(renderer, vs, ps, layout, params, blend_type=.TRANSPARENT);
engine.renderer.default_pipelines.message_text = create_pipeline_state(renderer, vs, ps, layout, params, blend_type=.TRANSPARENT);
}
}
@@ -732,9 +732,9 @@ init_default_meshes :: () {
ib_size := size_of(u32)*mesh.indices.count;
//mesh.vb = create_vertex_buffer(renderer, vertices.data, xx vb_size, stride=xx stride);
mesh.ib = create_index_buffer(renderer, mesh.indices.data, xx ib_size);
mesh.ib = create_index_buffer(engine.renderer, mesh.indices.data, xx ib_size);
renderer.default_meshes.plane = parray_add(*renderer.meshes, mesh);
engine.renderer.default_meshes.plane = parray_add(*engine.renderer.meshes, mesh);
}
{
// Fullscreeboat_n plane
@@ -759,9 +759,9 @@ init_default_meshes :: () {
ib_size := size_of(u32)*mesh.indices.count;
mesh.ib = create_index_buffer(renderer, mesh.indices.data, xx ib_size);
mesh.ib = create_index_buffer(engine.renderer, mesh.indices.data, xx ib_size);
renderer.default_meshes.fullscreen_plane = parray_add(*renderer.meshes, mesh);
engine.renderer.default_meshes.fullscreen_plane = parray_add(*engine.renderer.meshes, mesh);
}
{
@@ -787,49 +787,49 @@ init_default_meshes :: () {
ib_size := size_of(u32)*mesh.indices.count;
mesh.ib = create_index_buffer(renderer, mesh.indices.data, xx ib_size);
mesh.ib = create_index_buffer(engine.renderer, mesh.indices.data, xx ib_size);
renderer.default_meshes.textured_quad = parray_add(*renderer.meshes, mesh);
engine.renderer.default_meshes.textured_quad = parray_add(*engine.renderer.meshes, mesh);
}
renderer.default_samplers.repeat = create_sampler(renderer, wrap_mode = .REPEAT);
renderer.default_samplers.clamp = create_sampler(renderer, wrap_mode = .CLAMP);
engine.renderer.default_samplers.repeat = create_sampler(engine.renderer, wrap_mode = .REPEAT);
engine.renderer.default_samplers.clamp = create_sampler(engine.renderer, wrap_mode = .CLAMP);
//sphere_model := load_fbx("../modules/Coven/models/sphere.fbx");
//sphere_mesh, success := get_first_mesh_from_model(sphere_model);
//assert(success);
//renderer.default_meshes.sphere = sphere_mesh;
//engine.renderer.default_meshes.sphere = sphere_mesh;
cube_model := load_fbx("../assets/models/cube.fbx");
cube_mesh, success := get_first_mesh_from_model(cube_model);
assert(success);
renderer.default_meshes.cube = cube_mesh;
engine.renderer.default_meshes.cube = cube_mesh;
//translation_arrow_model := load_fbx("../modules/Coven/models/translation_arrow.fbx");
//translation_arrow_mesh :, success = get_first_mesh_from_model(translation_arrow_model);
//assert(success);
//renderer.default_meshes.translation_gizmo = translation_arrow_mesh;
//engine.renderer.default_meshes.translation_gizmo = translation_arrow_mesh;
//scale_gizmo_model := load_fbx("../modules/Coven/models/scale_gizmo.fbx");
//scale_gizmo_mesh :, success = get_first_mesh_from_model(scale_gizmo_model);
//assert(success);
//renderer.default_meshes.scale_gizmo = scale_gizmo_mesh;
//engine.renderer.default_meshes.scale_gizmo = scale_gizmo_mesh;
//rotation_gizmo_model := load_fbx("../modules/Coven/models/rotation_gizmo.fbx");
//rotation_gizmo_mesh :, success = get_first_mesh_from_model(rotation_gizmo_model);
//assert(success);
//renderer.default_meshes.rotation_gizmo = rotation_gizmo_mesh;
//engine.renderer.default_meshes.rotation_gizmo = rotation_gizmo_mesh;
}
deinit_renderer :: (renderer: *Renderer) {
deinit_backend(renderer.backend);
deinit_backend(engine.renderer.backend);
}
get_shader :: (handle: Shader_Handle) -> Shader {
assert(handle - 1 < xx renderer.shaders.count);
return renderer.shaders[handle-1];
assert(handle - 1 < xx engine.renderer.shaders.count);
return engine.renderer.shaders[handle-1];
}
create_shader :: (using renderer: *Renderer, path: string, entry_point: string, shader_type: Shader_Type, defines: [] string = .[], mesh_data_types: [] Mesh_Vertex_Data_Type = .[.POSITION, .NORMAL, .TEXCOORD]) -> Shader_Handle {
@@ -850,7 +850,7 @@ create_shader :: (using renderer: *Renderer, path: string, entry_point: string,
}
}
backend_shader, info, success := create_backend_shader(renderer.backend, path, entry_point, shader_type, defines);
backend_shader, info, success := create_backend_shader(engine.renderer.backend, path, entry_point, shader_type, defines);
if success {
shader.info = info;
@@ -863,7 +863,7 @@ create_shader :: (using renderer: *Renderer, path: string, entry_point: string,
}
reload_shader :: (using renderer: *Renderer, shader: *Shader) {
backend_shader, success := reload_backend_shader(renderer.backend, shader.path, shader.entry_point, shader.type, shader.defines);
backend_shader, success := reload_backend_shader(engine.renderer.backend, shader.path, shader.entry_point, shader.type, shader.defines);
if success {
destroy_shader(shader.*);
@@ -893,7 +893,7 @@ create_shader_from_source :: (using renderer: *Renderer, source: string, entry_p
}
}
backend_shader, info, success := create_backend_shader_from_source(renderer.backend, source, entry_point, shader_type, defines);
backend_shader, info, success := create_backend_shader_from_source(engine.renderer.backend, source, entry_point, shader_type, defines);
if success {
shader.info = info;
@@ -919,7 +919,7 @@ create_buffer :: (using renderer: *Renderer, data: *void, size: u32, type: Buffe
assert(stride > 0);
}
backend_buffer, success := create_backend_buffer(renderer.backend, data, size, stride, type, mappable);
backend_buffer, success := create_backend_buffer(engine.renderer.backend, data, size, stride, type, mappable);
if success {
buffer.backend_buffer = backend_buffer;
@@ -938,7 +938,7 @@ destroy_buffer :: (using renderer: *Renderer, handle: Buffer_Handle) {
assert(handle > 0);
buffer := parray_get(*buffers, handle);
destroy_backend_buffer(renderer.backend, buffer.backend_buffer);
destroy_backend_buffer(engine.renderer.backend, buffer.backend_buffer);
parray_remove(*buffers, handle);
}
@@ -967,7 +967,7 @@ create_texture :: (using renderer: *Renderer, data: *void, width: u32, height: u
texture.width = width;
texture.height = height;
texture.format = format;
backend_texture, success := create_backend_texture(renderer.backend, data, width, height, channels, generate_mips, format);
backend_texture, success := create_backend_texture(engine.renderer.backend, data, width, height, channels, generate_mips, format);
if success {
texture.backend_texture = backend_texture;
@@ -998,7 +998,7 @@ destroy_texture :: (using renderer: *Renderer, handle: Texture_Handle) {
assert(handle > 0);
texture := parray_get(*textures, handle);
destroy_backend_texture(renderer.backend, texture.backend_texture);
destroy_backend_texture(engine.renderer.backend, texture.backend_texture);
parray_remove(*textures, handle);
}
@@ -1018,7 +1018,7 @@ get_texture_path :: (using renderer: *Renderer, handle: Texture_Handle) -> strin
update_texture_region :: (using renderer: *Renderer, handle: Texture_Handle, xoffset: u32, yoffset: u32, width: u32, height: u32, pitch: u32, data: *void) {
assert(handle > 0);
texture := parray_get(*textures, handle);
update_backend_texture_region(renderer.backend, texture.backend_texture, xoffset, yoffset, width, height, pitch, data);
update_backend_texture_region(engine.renderer.backend, texture.backend_texture, xoffset, yoffset, width, height, pitch, data);
}
create_sampler :: (using renderer: *Renderer, filter: Sampling_Filter = .LINEAR, wrap_mode: Wrap_Mode = .CLAMP) -> Sampler_Handle {
@@ -1026,7 +1026,7 @@ create_sampler :: (using renderer: *Renderer, filter: Sampling_Filter = .LINEAR,
sampler.filter = filter;
sampler.wrap_mode = wrap_mode;
backend_sampler, success := create_backend_sampler(renderer.backend, filter, wrap_mode);
backend_sampler, success := create_backend_sampler(engine.renderer.backend, filter, wrap_mode);
if success {
sampler.backend_sampler = backend_sampler;
@@ -1046,12 +1046,12 @@ create_pipeline_state2 :: (using renderer: *Renderer, vs: Shader_Handle, ps: Sha
pipeline_state.blend_type = blend_type;
if pipeline_state.blend_type == .TRANSPARENT {
pipeline_state.blend_state = create_backend_blend_state(renderer.backend, .TRANSPARENT);
pipeline_state.blend_state = create_backend_blend_state(engine.renderer.backend, .TRANSPARENT);
}
shader := *shaders[vs - 1];
pipeline_state.vertex_layout = create_backend_input_layout2(renderer.backend, shader.info.input, shader.backend_shader);
pipeline_state.vertex_layout = create_backend_input_layout2(engine.renderer.backend, shader.info.input, shader.backend_shader);
array_reserve(*pipeline_state.mesh_data_types, shader.mesh_data_types.count);
for type: shader.mesh_data_types {
array_add(*pipeline_state.mesh_data_types, type);
@@ -1075,12 +1075,12 @@ create_pipeline_state :: (using renderer: *Renderer, vs: Shader_Handle, ps: Shad
pipeline_state.blend_type = blend_type;
if pipeline_state.blend_type == .TRANSPARENT {
pipeline_state.blend_state = create_backend_blend_state(renderer.backend, .TRANSPARENT);
pipeline_state.blend_state = create_backend_blend_state(engine.renderer.backend, .TRANSPARENT);
}
shader := *shaders[vs - 1];
if layout.count > 0 {
pipeline_state.vertex_layout = create_backend_input_layout(renderer.backend, layout, shader.backend_shader);
pipeline_state.vertex_layout = create_backend_input_layout(engine.renderer.backend, layout, shader.backend_shader);
}
array_reserve(*pipeline_state.mesh_data_types, shader.mesh_data_types.count);
@@ -1096,7 +1096,7 @@ create_pipeline_state :: (using renderer: *Renderer, vs: Shader_Handle, ps: Shad
push_cmd_set_pipeline_state :: (using renderer: *Renderer, handle: Pipeline_State_Handle) {
assert(handle > 0);
renderer.current_state.last_set_pipeline = handle;
engine.renderer.current_state.last_set_pipeline = handle;
state := *pipeline_states[handle - 1];
vs := *shaders[state.vs - 1];
@@ -1110,7 +1110,7 @@ push_cmd_set_pipeline_state :: (using renderer: *Renderer, handle: Pipeline_Stat
command.set_pipeline_state.blend_type = state.blend_type;
command.set_pipeline_state.blend_state = state.blend_state;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_vertex_buffer :: (using renderer: *Renderer, handle: Buffer_Handle, start_slot: u32 = 0) {
@@ -1124,7 +1124,7 @@ push_cmd_set_vertex_buffer :: (using renderer: *Renderer, handle: Buffer_Handle,
command.set_vertex_buffer.stride = buffer.stride;
command.set_vertex_buffer.start_slot = start_slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_index_buffer :: (using renderer: *Renderer, handle: Buffer_Handle) {
@@ -1136,7 +1136,7 @@ push_cmd_set_index_buffer :: (using renderer: *Renderer, handle: Buffer_Handle)
command.type = .SET_INDEX_BUFFER;
command.set_index_buffer.buffer = buffer.backend_buffer;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_constant_buffer :: (using renderer: *Renderer, slot: u32, handle: Buffer_Handle, shader_type: Shader_Type) {
@@ -1150,7 +1150,7 @@ push_cmd_set_constant_buffer :: (using renderer: *Renderer, slot: u32, handle: B
command.set_constant_buffer.shader_type = shader_type;
command.set_constant_buffer.slot = slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_structured_buffer :: (using renderer: *Renderer, slot: u32, handle: Buffer_Handle, shader_type: Shader_Type) {
@@ -1164,7 +1164,7 @@ push_cmd_set_structured_buffer :: (using renderer: *Renderer, slot: u32, handle:
command.set_structured_buffer.shader_type = shader_type;
command.set_structured_buffer.slot = slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_texture :: (using renderer: *Renderer, slot: u32, handle: Texture_Handle) {
@@ -1177,7 +1177,7 @@ push_cmd_set_texture :: (using renderer: *Renderer, slot: u32, handle: Texture_H
command.set_texture.texture = texture.backend_texture;
command.set_texture.slot = slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_texture :: (using renderer: *Renderer, slot: u32, handle: Render_Target_Handle) {
@@ -1190,7 +1190,7 @@ push_cmd_set_texture :: (using renderer: *Renderer, slot: u32, handle: Render_Ta
command.set_texture_from_rt.rt = rt.backend_render_target;
command.set_texture_from_rt.slot = slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_texture :: (using renderer: *Renderer, slot: u32, handle: Depth_Stencil_Buffer_Handle) {
@@ -1203,7 +1203,7 @@ push_cmd_set_texture :: (using renderer: *Renderer, slot: u32, handle: Depth_Ste
command.set_texture_from_ds.ds = ds.backend_depth_stencil_buffer;
command.set_texture_from_ds.slot = slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_render_targets :: (renderer: *Renderer, render_targets: ..Render_Target_Handle = .[], depth_stencil_enabled: bool = false, depth_stencil_buffer: Depth_Stencil_Buffer_Handle = 0) {
@@ -1215,23 +1215,23 @@ push_cmd_set_render_targets :: (renderer: *Renderer, render_targets: ..Render_Ta
command.set_render_targets.num_render_targets = xx render_targets.count;
for render_targets {
rt := parray_get(*renderer.render_targets, it);
rt := parray_get(*engine.renderer.render_targets, it);
command.set_render_targets.render_targets[it_index] = rt.backend_render_target;
}
command.set_render_targets.depth_stencil_enabled = depth_stencil_enabled;
if depth_stencil_enabled {
ds := parray_get(*renderer.depth_stencil_buffers, depth_stencil_buffer);
ds := parray_get(*engine.renderer.depth_stencil_buffers, depth_stencil_buffer);
command.set_render_targets.depth_stencil_buffer = ds.backend_depth_stencil_buffer;
}
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_backbuffer :: (renderer: *Renderer) {
command : Render_Command;
command.type = .SET_BACKBUFFER;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_sampler :: (using renderer: *Renderer, slot: u32, handle: Sampler_Handle) {
@@ -1244,7 +1244,7 @@ push_cmd_set_sampler :: (using renderer: *Renderer, slot: u32, handle: Sampler_H
command.set_sampler.sampler = sampler.backend_sampler;
command.set_sampler.slot = slot;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_viewport :: (using renderer: *Renderer, width: u32, height: u32, x: u32 = 0, y: u32 = 0, min_depth: float = 0.0, max_depth: float = 1.0) {
@@ -1257,29 +1257,29 @@ push_cmd_set_viewport :: (using renderer: *Renderer, width: u32, height: u32, x:
command.set_viewport.min_depth = min_depth;
command.set_viewport.max_depth = max_depth;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_clear_render_target :: (using renderer: *Renderer, rt: Render_Target_Handle, color: Vector4) {
command : Render_Command;
command.type = .CLEAR_RENDER_TARGET;
render_target := parray_get(*renderer.render_targets, rt);
render_target := parray_get(*engine.renderer.render_targets, rt);
command.clear_render_target.rt = render_target.backend_render_target;
command.clear_render_target.color = color;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_clear_depth_stencil :: (using renderer: *Renderer, handle: Depth_Stencil_Buffer_Handle, depth: float) {
command : Render_Command;
command.type = .CLEAR_DEPTH_STENCIL;
ds := parray_get(*renderer.depth_stencil_buffers, handle);
ds := parray_get(*engine.renderer.depth_stencil_buffers, handle);
command.clear_depth_stencil.ds = ds.backend_depth_stencil_buffer;
command.clear_depth_stencil.depth = depth;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_clear_backbuffer :: (using renderer: *Renderer, color: Vector4) {
@@ -1288,11 +1288,11 @@ push_cmd_clear_backbuffer :: (using renderer: *Renderer, color: Vector4) {
command.clear_backbuffer.color = color;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_draw :: (using renderer: *Renderer, vertex_count: s64, start_vertex_index: s64 = 0, topology: Primitive_Topology = .TRIANGLE_LIST) {
renderer.draw_call_count += 1;
engine.renderer.draw_call_count += 1;
command : Render_Command;
command.type = .DRAW;
@@ -1300,11 +1300,11 @@ push_cmd_draw :: (using renderer: *Renderer, vertex_count: s64, start_vertex_ind
command.draw.vertex_count = vertex_count;
command.draw.start_vertex_index = start_vertex_index;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_draw_instanced :: (using renderer: *Renderer, vertex_count: s64, instance_count: s64, start_vertex_index: s64 = 0, start_instance_index: s64 = 0, topology: Primitive_Topology = .TRIANGLE_LIST) {
renderer.draw_call_count += 1;
engine.renderer.draw_call_count += 1;
command : Render_Command;
command.type = .DRAW_INSTANCED;
@@ -1314,11 +1314,11 @@ push_cmd_draw_instanced :: (using renderer: *Renderer, vertex_count: s64, instan
command.draw_instanced.start_vertex_index = start_vertex_index;
command.draw_instanced.start_instance_index = start_instance_index;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_draw_indexed :: (using renderer: *Renderer, index_count: s64, start_index: s64 = 0, base_vertex: s64 = 0, topology: Primitive_Topology = .TRIANGLE_LIST) {
renderer.draw_call_count += 1;
engine.renderer.draw_call_count += 1;
command : Render_Command;
command.type = .DRAW_INDEXED;
@@ -1327,11 +1327,11 @@ push_cmd_draw_indexed :: (using renderer: *Renderer, index_count: s64, start_ind
command.draw_indexed.start_index = start_index;
command.draw_indexed.base_vertex = base_vertex;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_draw_indexed_instanced :: (using renderer: *Renderer, index_count: s64, instance_count: u32, start_index: s64 = 0, base_vertex: s64 = 0, topology: Primitive_Topology = .TRIANGLE_LIST) {
renderer.draw_call_count += 1;
engine.renderer.draw_call_count += 1;
command : Render_Command;
command.type = .DRAW_INDEXED_INSTANCED;
@@ -1341,7 +1341,7 @@ push_cmd_draw_indexed_instanced :: (using renderer: *Renderer, index_count: s64,
command.draw_indexed_instanced.start_index = start_index;
command.draw_indexed_instanced.base_vertex = base_vertex;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_draw_mode :: (using renderer: *Renderer, draw_mode: Draw_Mode) {
@@ -1349,7 +1349,7 @@ push_cmd_set_draw_mode :: (using renderer: *Renderer, draw_mode: Draw_Mode) {
command.type = .SET_DRAW_MODE;
command.set_draw_mode.draw_mode = draw_mode;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_cull_face :: (using renderer: *Renderer, cull_face: Cull_Face) {
@@ -1357,7 +1357,7 @@ push_cmd_set_cull_face :: (using renderer: *Renderer, cull_face: Cull_Face) {
command.type = .SET_CULL_FACE;
command.set_cull_face.cull_face = cull_face;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
push_cmd_set_depth_write :: (using renderer: *Renderer, enabled: bool) {
@@ -1365,7 +1365,7 @@ push_cmd_set_depth_write :: (using renderer: *Renderer, enabled: bool) {
command.type = .SET_DEPTH_WRITE;
command.set_depth_write.enabled = enabled;
array_add(*renderer.command_buffer.commands, command);
array_add(*engine.renderer.command_buffer.commands, command);
}
map_buffer :: (using renderer: *Renderer, handle: Buffer_Handle) -> *void #must {
@@ -1411,7 +1411,7 @@ make_point :: (x: float, y: float, s: float, t: float, color: Vector4) -> Point
get_text_size :: (using renderer: *Renderer, text: string, font_handle: Font_Handle) -> Vector2 {
size : Vector2;
font := *renderer.fonts[font_handle - 1];
font := *engine.renderer.fonts[font_handle - 1];
characters := font.glyphs;
has_character := false;
@@ -1441,21 +1441,21 @@ get_text_size :: (using renderer: *Renderer, text: string, font_handle: Font_Han
}
bake_text :: (using renderer: *Renderer, x: float, y: float, text: string, font_handle: Font_Handle, color: Vector4 = .{1, 1, 1, 1}) -> Text_Render_Data {
buffer := renderer.text_render_buffers[renderer.used_text_buffers_count];
renderer.used_text_buffers_count += 1;
buffer := engine.renderer.text_render_buffers[engine.renderer.used_text_buffers_count];
engine.renderer.used_text_buffers_count += 1;
x -= (cast(float)renderer.render_target_width) * 0.5;
y -= (cast(float)renderer.render_target_height) * 0.5;
x -= (cast(float)engine.renderer.render_target_width) * 0.5;
y -= (cast(float)engine.renderer.render_target_height) * 0.5;
sx := 2.0 / cast(float)renderer.render_target_width;
sy := 2.0 / cast(float)renderer.render_target_height;
sx := 2.0 / cast(float)engine.renderer.render_target_width;
sy := 2.0 / cast(float)engine.renderer.render_target_height;
render_x := x * sx;
render_y := y * sy;
coords : [..] Point;
coords.allocator = temp;
font := *renderer.fonts[font_handle - 1];
font := *engine.renderer.fonts[font_handle - 1];
characters := font.glyphs;
atlas_width := cast(float)font.atlas_width;
atlas_height := cast(float)font.atlas_height;
@@ -1502,11 +1502,11 @@ bake_text :: (using renderer: *Renderer, x: float, y: float, text: string, font_
}
draw_fullscreen_quad :: () {
plane := parray_get(*renderer.meshes, renderer.default_meshes.fullscreen_plane);
plane := parray_get(*engine.renderer.meshes, engine.renderer.default_meshes.fullscreen_plane);
vb := get_mesh_vb(plane);
push_cmd_set_vertex_buffer(renderer, vb);
push_cmd_set_index_buffer(renderer, plane.ib);
push_cmd_draw_indexed(renderer, plane.indices.count);
push_cmd_set_vertex_buffer(engine.renderer, vb);
push_cmd_set_index_buffer(engine.renderer, plane.ib);
push_cmd_draw_indexed(engine.renderer, plane.indices.count);
}
create_render_target :: (width: u32, height: u32, format: Format) -> Render_Target_Handle {
@@ -1515,8 +1515,8 @@ create_render_target :: (width: u32, height: u32, format: Format) -> Render_Targ
if width == SWAPCHAIN_SIZE || height == SWAPCHAIN_SIZE {
render_target.width = width;
render_target.height = height;
render_target.actual_width = renderer.render_target_width;
render_target.actual_height = renderer.render_target_height;
render_target.actual_width = engine.renderer.render_target_width;
render_target.actual_height = engine.renderer.render_target_height;
} else {
render_target.width = width;
render_target.height = height;
@@ -1525,16 +1525,16 @@ create_render_target :: (width: u32, height: u32, format: Format) -> Render_Targ
}
render_target.format = format;
render_target.backend_render_target = create_backend_render_target(renderer.backend, render_target.actual_width, render_target.actual_height, format);
render_target.backend_render_target = create_backend_render_target(engine.renderer.backend, render_target.actual_width, render_target.actual_height, format);
texture : Texture;
texture.width = render_target.actual_width;
texture.height = render_target.actual_height;
texture.backend_texture = get_backend_texture_from_render_target(renderer.backend, render_target.backend_render_target);
texture.backend_texture = get_backend_texture_from_render_target(engine.renderer.backend, render_target.backend_render_target);
render_target.texture = parray_add(*renderer.textures, texture);
render_target.texture = parray_add(*engine.renderer.textures, texture);
return parray_add(*renderer.render_targets, render_target);
return parray_add(*engine.renderer.render_targets, render_target);
}
create_depth_stencil_buffer :: (width: u32, height: u32, format: Format) -> Depth_Stencil_Buffer_Handle {
@@ -1543,8 +1543,8 @@ create_depth_stencil_buffer :: (width: u32, height: u32, format: Format) -> Dept
if width == SWAPCHAIN_SIZE || height == SWAPCHAIN_SIZE {
depth_stencil_buffer.width = width;
depth_stencil_buffer.height = height;
depth_stencil_buffer.actual_width = renderer.render_target_width;
depth_stencil_buffer.actual_height = renderer.render_target_height;
depth_stencil_buffer.actual_width = engine.renderer.render_target_width;
depth_stencil_buffer.actual_height = engine.renderer.render_target_height;
} else {
depth_stencil_buffer.width = width;
depth_stencil_buffer.height = height;
@@ -1553,9 +1553,9 @@ create_depth_stencil_buffer :: (width: u32, height: u32, format: Format) -> Dept
}
//depth_stencil_buffer.format = format;
depth_stencil_buffer.backend_depth_stencil_buffer = create_backend_depth_stencil_buffer(renderer.backend, depth_stencil_buffer.actual_width, depth_stencil_buffer.actual_height);
depth_stencil_buffer.backend_depth_stencil_buffer = create_backend_depth_stencil_buffer(engine.renderer.backend, depth_stencil_buffer.actual_width, depth_stencil_buffer.actual_height);
return parray_add(*renderer.depth_stencil_buffers, depth_stencil_buffer);
return parray_add(*engine.renderer.depth_stencil_buffers, depth_stencil_buffer);
}
create_material_from_pipeline :: (pipeline: Pipeline_State_Handle) -> Material_Old {
@@ -1563,15 +1563,15 @@ create_material_from_pipeline :: (pipeline: Pipeline_State_Handle) -> Material_O
pass : Material_Pass_Old;
pass.pipeline = pipeline;
pipeline_state := *renderer.pipeline_states[pipeline-1];
pipeline_state := *engine.renderer.pipeline_states[pipeline-1];
for pipeline_state.shader_parameters {
prop : Material_Property_Old;
prop.parameter = it;
if it.mapping == {
case .REPEAT_SAMPLER;
prop.sampler = renderer.default_samplers.repeat;
prop.sampler = engine.renderer.default_samplers.repeat;
case .CLAMP_SAMPLER;
prop.sampler = renderer.default_samplers.clamp;
prop.sampler = engine.renderer.default_samplers.clamp;
case .TIME;
//prop.buffer = engine.time_buffer; // @Incomplete
}
@@ -1584,16 +1584,16 @@ create_material_from_pipeline :: (pipeline: Pipeline_State_Handle) -> Material_O
}
check_for_shader_modifications :: () {
changed, needs_wait, wait_seconds := process_changes(*renderer.watcher);
changed, needs_wait, wait_seconds := process_changes(*engine.renderer.watcher);
}
render :: () {
renderer.command_buffer.commands.count = 0;
renderer.last_draw_call_count = renderer.draw_call_count;
renderer.draw_call_count = 0;
execute_render_graph(renderer.render_graph);
render(renderer.backend, *renderer.command_buffer);
renderer.used_text_buffers_count = 0;
engine.renderer.command_buffer.commands.count = 0;
engine.renderer.last_draw_call_count = engine.renderer.draw_call_count;
engine.renderer.draw_call_count = 0;
execute_render_graph(engine.renderer.render_graph);
render(engine.renderer.backend, *engine.renderer.command_buffer);
engine.renderer.used_text_buffers_count = 0;
}
#load "render_graph.jai";
@@ -1620,9 +1620,9 @@ render :: () {
#import "File_Watcher";
file_change_callback :: (watcher: *File_Watcher(string), change: *File_Change, user_data: *string) {
for *shader: renderer.shaders {
for *shader: engine.renderer.shaders {
if shader.path == change.full_path {
reload_shader(renderer, shader);
reload_shader(engine.renderer, shader);
}
}
}