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

6
renderer/dx11_renderer.jai
View File

@@ -1432,15 +1432,15 @@ render :: (backend: *D3D11_Backend, command_buffer: *Render_Command_Buffer) {
now := seconds_since_init();
renderer.last_render_time_cpu = cast(float)(now - time) * 1000.0;
engine.renderer.last_render_time_cpu = cast(float)(now - time) * 1000.0;
time = now;
// Present the information rendered to the back buffer to the front buffer (the screen)
before_swap := seconds_since_init();
hr := IDXGISwapChain_Present(swap_chain, xx ifx renderer.vsync then 1 else 0, 0);
hr := IDXGISwapChain_Present(swap_chain, xx ifx engine.renderer.vsync then 1 else 0, 0);
after_swap := seconds_since_init();
//print("RENDERING: It took % sec to present the final image\n", after_swap - before_swap);
renderer.last_render_time_gpu = cast(float)(now - time) * 1000.0;
engine.renderer.last_render_time_gpu = cast(float)(now - time) * 1000.0;
if FAILED(hr) {
log_error("Present failed: %", hr);

20
renderer/engine_buffers.jai
View File

@@ -1,6 +1,6 @@
calc_tight_light_projection :: (camera: Camera, light_direction: Vector3) -> Matrix4 {
// View space camera frustum
aspect_ratio := cast(float)renderer.render_target_height / cast(float)renderer.render_target_width;
aspect_ratio := cast(float)engine.renderer.render_target_height / cast(float)engine.renderer.render_target_width;
frustum := get_frustum(camera.fov, aspect_ratio, camera.z_near, camera.z_far);
// View frustum back to world space
@@ -46,7 +46,7 @@ calc_tight_light_projection :: (camera: Camera, light_direction: Vector3) -> Mat
}
update_light_buffer :: () {
scene := current_scene;
scene := engine.current_scene;
camera := scene.camera;
light_data : Directional_Light_Buffer_Data;
@@ -56,44 +56,44 @@ update_light_buffer :: () {
light_matrix := calc_tight_light_projection(camera, scene.directional_light.direction.xyz);
light_data.light_matrix = light_matrix;
upload_data_to_buffer(renderer, directional_light_buffer, *light_data, size_of(Directional_Light_Buffer_Data));
upload_data_to_buffer(engine.renderer, engine.directional_light_buffer, *light_data, size_of(Directional_Light_Buffer_Data));
}
sync_engine_buffers :: () {
update_light_buffer();
// Camera buffer
camera := *current_scene.camera;
camera := *engine.current_scene.camera;
camera_data : Camera_Data;
camera_data.projection_matrix = camera.projection_matrix;
camera_data.view_matrix = camera.view_matrix;
camera_data.position = to_v4(camera.position);
upload_data_to_buffer(renderer, camera_buffer, *camera_data, size_of(Camera_Data));
upload_data_to_buffer(engine.renderer, engine.camera_buffer, *camera_data, size_of(Camera_Data));
shader_time : Shader_Time;
shader_time.time = time;
upload_data_to_buffer(renderer, time_buffer, *shader_time, size_of(Shader_Time));
upload_data_to_buffer(engine.renderer, engine.time_buffer, *shader_time, size_of(Shader_Time));
// Sync entity transforms
for current_scene.entities {
for engine.current_scene.entities {
if it.flags & .RENDERABLE {
if it.renderable.type == {
case .MODEL; {
for n, i: it.renderable.model.nodes {
if n.meshes.count > 0 {
node_data := *it.renderable.nodes[i];
upload_data_to_buffer(renderer, node_data.transform_buffer, *node_data.transform.world_matrix, size_of(Matrix4));
upload_data_to_buffer(engine.renderer, node_data.transform_buffer, *node_data.transform.world_matrix, size_of(Matrix4));
if node_data.num_bones > 0 {
for handle, mesh_index: n.meshes {
m := parray_get(*renderer.meshes, handle);
m := parray_get(*engine.renderer.meshes, handle);
bones : [MAX_BONES] Matrix4;
for bone_index: 0..m.num_bones-1 {
bone := *it.renderable.nodes[m.bone_indices[bone_index]];
bones[bone_index] = bone.transform.world_matrix * m.bone_matrices[bone_index];
}
upload_data_to_buffer(renderer, node_data.bone_buffers[mesh_index], bones.data, size_of(Matrix4) * m.num_bones);
upload_data_to_buffer(engine.renderer, node_data.bone_buffers[mesh_index], bones.data, size_of(Matrix4) * m.num_bones);
}
}
}

4
renderer/font.jai
View File

@@ -95,8 +95,8 @@ create_font :: (renderer: *Renderer, path: string, pixel_size: u32) -> Font_Hand
x += g.bitmap.width + 1;
}
array_add(*renderer.fonts, font);
return xx renderer.fonts.count;
array_add(*engine.renderer.fonts, font);
return xx engine.renderer.fonts.count;
}
return 0;

26
renderer/material.jai
View File

@@ -217,7 +217,7 @@ create_material_for_passes :: (name: string, material_pass_infos: [] Material_Pa
push_context new_context {
for info: material_pass_infos {
pipeline_state := *renderer.pipeline_states[info.pipeline - 1];
pipeline_state := *engine.renderer.pipeline_states[info.pipeline - 1];
vs := get_shader(pipeline_state.vs);
ps := get_shader(pipeline_state.ps);
@@ -366,23 +366,23 @@ set_material_pass_parameters :: (material: *Material, pass_index: s64, render_pa
param.buffer_info.buffer = transform_buffer;
}
case .CAMERA_DATA; {
//param.buffer_info.buffer = renderer.engine_buffers.camera; // @Incomplete
//param.buffer_info.buffer = engine.renderer.engine_buffers.camera; // @Incomplete
}
case .MATERIAL; {
param.buffer_info.buffer = material_buffer;
}
case .DIRECTIONAL_LIGHT; {
//param.buffer_info.buffer = renderer.engine_buffers.directional_light; // @Incomplete
//param.buffer_info.buffer = engine.renderer.engine_buffers.directional_light; // @Incomplete
}
case .POINT_LIGHTS; {
//param.buffer_info.buffer = renderer.engine_buffers.point_lights; // @Incomplete
//param.buffer_info.buffer = engine.renderer.engine_buffers.point_lights; // @Incomplete
}
case .BONE_MATRICES; {
param.buffer_info.buffer = bone_buffer;
}
case .CUSTOM; {
if renderer.callbacks.get_custom_material_parameter_mapping != null {
success, mapping_info := renderer.callbacks.get_custom_material_parameter_mapping(param.mapping_str);
if engine.renderer.callbacks.get_custom_material_parameter_mapping != null {
success, mapping_info := engine.renderer.callbacks.get_custom_material_parameter_mapping(param.mapping_str);
if success {
param.buffer_info.buffer = mapping_info.buffer;
}
@@ -397,10 +397,10 @@ set_material_pass_parameters :: (material: *Material, pass_index: s64, render_pa
case .SAMPLER;
if param.mapping == {
case .REPEAT_SAMPLER; {
param.sampler = renderer.default_samplers.repeat;
param.sampler = engine.renderer.default_samplers.repeat;
}
case .CLAMP_SAMPLER; {
param.sampler = renderer.default_samplers.clamp;
param.sampler = engine.renderer.default_samplers.clamp;
}
}
if param.sampler != 0 {
@@ -435,8 +435,8 @@ set_material_pass_parameters :: (material: *Material, pass_index: s64, render_pa
input_index = 3;
}
case .CUSTOM; {
if renderer.callbacks.get_custom_material_parameter_mapping != null {
success, mapping_info := renderer.callbacks.get_custom_material_parameter_mapping(param.mapping_str);
if engine.renderer.callbacks.get_custom_material_parameter_mapping != null {
success, mapping_info := engine.renderer.callbacks.get_custom_material_parameter_mapping(param.mapping_str);
if success {
param.texture = mapping_info.texture;
}
@@ -446,12 +446,12 @@ set_material_pass_parameters :: (material: *Material, pass_index: s64, render_pa
if is_texture_input {
input := render_pass.inputs[input_index];
owning_pass := parray_get(*renderer.render_graph.render_passes, input.pass_handle);
owning_pass := parray_get(*engine.renderer.render_graph.render_passes, engine.input.pass_handle);
if input.rt_index == DEPTH_STENCIL_SLOT {
if engine.input.rt_index == DEPTH_STENCIL_SLOT {
push_cmd_set_texture(renderer, param.slot, owning_pass.depth_stencil);
} else {
push_cmd_set_texture(renderer, param.slot, owning_pass.render_targets[input.rt_index]);
push_cmd_set_texture(renderer, param.slot, owning_pass.render_targets[engine.input.rt_index]);
}
} else {
if param.texture > 0 {

12
renderer/mesh.jai
View File

@@ -39,9 +39,9 @@ Mesh :: struct {
}
get_mesh_vb :: (mesh: *Mesh, pipeline_handle: Pipeline_State_Handle = 0) -> Buffer_Handle {
handle := ifx pipeline_handle == 0 then renderer.current_state.last_set_pipeline else pipeline_handle;
handle := ifx pipeline_handle == 0 then engine.renderer.current_state.last_set_pipeline else pipeline_handle;
pipeline_state := *renderer.pipeline_states[handle-1];
pipeline_state := *engine.renderer.pipeline_states[handle-1];
return get_mesh_vb(mesh, pipeline_state.mesh_data_types);
}
@@ -171,7 +171,7 @@ get_mesh_vb :: (mesh: *Mesh, input: [] Mesh_Vertex_Data_Type) -> Buffer_Handle {
}
vb_size := size_of(float)*stride*mesh.positions.count;
vb := create_vertex_buffer(renderer, final_vertices.data, xx vb_size, stride=size_of(float)*stride);
vb := create_vertex_buffer(engine.renderer, final_vertices.data, xx vb_size, stride=size_of(float)*stride);
table_add(*mesh.vbs, hash, vb);
}
@@ -180,12 +180,12 @@ get_mesh_vb :: (mesh: *Mesh, input: [] Mesh_Vertex_Data_Type) -> Buffer_Handle {
}
delete_mesh :: (handle: Mesh_Handle) {
mesh := parray_get(*renderer.meshes, handle);
mesh := parray_get(*engine.renderer.meshes, handle);
for mesh.vbs {
destroy_buffer(renderer, it);
destroy_buffer(engine.renderer, it);
}
deinit(*mesh.vbs);
parray_remove(*renderer.meshes, handle);
parray_remove(*engine.renderer.meshes, handle);
}

14
renderer/model.jai
View File

@@ -79,7 +79,7 @@ get_first_mesh_from_model :: (model: Model) -> Mesh_Handle, bool {
get_mesh_by_name :: (model: Model, name: string) -> Mesh_Handle, bool {
for model.nodes {
for m: it.meshes {
mesh := parray_get(*renderer.meshes, m);
mesh := parray_get(*engine.renderer.meshes, m);
if mesh.name == name {
return m, true;
}
@@ -360,7 +360,7 @@ parse_fbx_node :: (model: *Model, fbx_node: *ufbx_node) {
}
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);
//material : Base_Material;
@@ -377,7 +377,7 @@ parse_fbx_node :: (model: *Model, fbx_node: *ufbx_node) {
// }
//}
array_add(*node.meshes, parray_add(*renderer.meshes, mesh));
array_add(*node.meshes, parray_add(*engine.renderer.meshes, mesh));
array_add(*node.material_defaults, model.materials[mesh_mat.material.typed_id]); // @Incomplete
}
}
@@ -563,7 +563,7 @@ load_fbx_animations_into_existing_model :: (path: string, model: *Model) {
}
get_model_by_path :: (path: string) -> *Model {
for * renderer.model_lib {
for * engine.renderer.model_lib {
if it.path == path {
return it;
}
@@ -574,7 +574,7 @@ get_model_by_path :: (path: string) -> *Model {
load_fbx_texture :: (map: ufbx_material_map, format: Format) -> Texture_Handle {
if map.texture != null && map.texture.content.size > 0 {
return load_texture_from_data(renderer, map.texture.content.data, map.texture.content.size, format=format);
return load_texture_from_data(engine.renderer, map.texture.content.data, map.texture.content.size, format=format);
}
return 0;
@@ -598,7 +598,7 @@ load_fbx :: (path: string) -> *Model, bool {
return null, false;
}
model, locator := find_and_occupy_empty_slot(*renderer.model_lib);
model, locator := find_and_occupy_empty_slot(*engine.renderer.model_lib);
model.path = copy_string(path);
model.name = copy_string(path);
@@ -656,7 +656,7 @@ load_fbx :: (path: string) -> *Model, bool {
}
get_or_load_model :: (path: string) -> *Model {
for * renderer.model_lib {
for * engine.renderer.model_lib {
if it.path == path {
return it;
}

42
renderer/render_graph.jai
View File

@@ -52,12 +52,12 @@ push_material_pass_properties :: (render_pass: Render_Pass, mat_pass: Material_P
if is_texture_input {
input := render_pass.inputs[input_index];
owning_pass := parray_get(*renderer.render_graph.render_passes, input.pass_handle);
owning_pass := parray_get(*engine.renderer.render_graph.render_passes, engine.input.pass_handle);
if input.rt_index == DEPTH_STENCIL_SLOT {
if engine.input.rt_index == DEPTH_STENCIL_SLOT {
push_cmd_set_texture(renderer, it.parameter.slot, owning_pass.depth_stencil);
} else {
push_cmd_set_texture(renderer, it.parameter.slot, owning_pass.render_targets[input.rt_index]);
push_cmd_set_texture(renderer, it.parameter.slot, owning_pass.render_targets[engine.input.rt_index]);
}
} else {
if it.texture > 0 {
@@ -72,40 +72,40 @@ push_material_pass_properties :: (render_pass: Render_Pass, mat_pass: Material_P
setup_pass_inputs :: (render_pass: Render_Pass) {
for input: render_pass.inputs {
owning_pass := parray_get(*renderer.render_graph.render_passes, input.pass_handle);
owning_pass := parray_get(*engine.renderer.render_graph.render_passes, input.pass_handle);
if input.rt_index == DEPTH_STENCIL_SLOT {
push_cmd_set_texture(renderer, xx it_index, owning_pass.depth_stencil);
push_cmd_set_texture(engine.renderer, xx it_index, owning_pass.depth_stencil);
} else {
push_cmd_set_texture(renderer, xx it_index, owning_pass.render_targets[input.rt_index]);
push_cmd_set_texture(engine.renderer, xx it_index, owning_pass.render_targets[input.rt_index]);
}
}
}
set_render_pass_clear_color :: (rp: Render_Pass_Handle, input_index: s32, color: Color) {
pass := parray_get(*renderer.render_graph.render_passes, rp);
pass := parray_get(*engine.renderer.render_graph.render_passes, rp);
pass.clear_colors[input_index] = color;
}
execute_render_pass :: (render_pass: Render_Pass) { // @Incomplete: Add command buffer as parameter
if render_pass.render_targets.count == 0 {
if render_pass.has_depth_stencil {
push_cmd_set_render_targets(renderer, depth_stencil_enabled=render_pass.has_depth_stencil, depth_stencil_buffer=render_pass.depth_stencil);
push_cmd_clear_depth_stencil(renderer, render_pass.depth_stencil, 1.0);
width := ifx render_pass.width == SWAPCHAIN_SIZE then renderer.render_target_width else render_pass.width;
height := ifx render_pass.height == SWAPCHAIN_SIZE then renderer.render_target_height else render_pass.height;
push_cmd_set_viewport(renderer, width, height);
push_cmd_set_render_targets(engine.renderer, depth_stencil_enabled=render_pass.has_depth_stencil, depth_stencil_buffer=render_pass.depth_stencil);
push_cmd_clear_depth_stencil(engine.renderer, render_pass.depth_stencil, 1.0);
width := ifx render_pass.width == SWAPCHAIN_SIZE then engine.renderer.render_target_width else render_pass.width;
height := ifx render_pass.height == SWAPCHAIN_SIZE then engine.renderer.render_target_height else render_pass.height;
push_cmd_set_viewport(engine.renderer, width, height);
} else {
assert(render_pass.uses_backbuffer);
push_cmd_set_backbuffer(renderer);
push_cmd_set_backbuffer(engine.renderer);
color: Vector4;
color.x = 0.0;
color.y = 0.0;
color.z = 0.0;
color.w = 1.0;
push_cmd_clear_backbuffer(renderer, color);
push_cmd_set_viewport(renderer, xx renderer.render_target_width, xx renderer.render_target_height);
push_cmd_clear_backbuffer(engine.renderer, color);
push_cmd_set_viewport(engine.renderer, xx engine.renderer.render_target_width, xx engine.renderer.render_target_height);
}
} else {
@@ -113,21 +113,21 @@ execute_render_pass :: (render_pass: Render_Pass) { // @Incomplete: Add command
height := render_pass.height;
if render_pass.width == SWAPCHAIN_SIZE {
width = renderer.render_target_width;
width = engine.renderer.render_target_width;
}
if render_pass.height == SWAPCHAIN_SIZE {
height = renderer.render_target_height;
height = engine.renderer.render_target_height;
}
push_cmd_set_render_targets(renderer, ..render_pass.render_targets, render_pass.has_depth_stencil, render_pass.depth_stencil);
push_cmd_set_viewport(renderer, width, height);
push_cmd_set_render_targets(engine.renderer, ..render_pass.render_targets, render_pass.has_depth_stencil, render_pass.depth_stencil);
push_cmd_set_viewport(engine.renderer, width, height);
for render_pass.render_targets {
push_cmd_clear_render_target(renderer, it, render_pass.clear_colors[it_index]);
push_cmd_clear_render_target(engine.renderer, it, render_pass.clear_colors[it_index]);
}
if render_pass.has_depth_stencil {
push_cmd_clear_depth_stencil(renderer, render_pass.depth_stencil, 1.0);
push_cmd_clear_depth_stencil(engine.renderer, render_pass.depth_stencil, 1.0);
}
}

4
renderer/render_pass.jai
View File

@@ -86,9 +86,9 @@ add_render_pass_input :: (graph: *Render_Graph, to_pass: Render_Pass_Handle, fro
}
get_texture_from_pass :: (name: string) -> Texture_Handle {
for renderer.render_graph.render_passes {
for engine.renderer.render_graph.render_passes {
if it.name == name {
rt := parray_get(renderer.render_targets, it.render_targets[0]);
rt := parray_get(engine.renderer.render_targets, it.render_targets[0]);
return rt.texture;
}
}

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