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

Working on custom physics layers + added default entity rendering

Browse Source
This commit is contained in:
Daniel Bross
2025-07-25 01:36:06 +02:00
parent e0f1dd5e70
commit 9c2f32f5a3
3 changed files with 311 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
renderer/renderer.jai
View File

@@ -624,6 +624,7 @@ Renderer :: struct {
default_pipelines : struct {
message_text : Pipeline_State_Handle;
entity_pipeline : Pipeline_State_Handle;
}
default_samplers : struct {
@@ -684,6 +685,7 @@ create_renderer :: (window: *Window) -> *Renderer {
init_freetype();
init_default_meshes();
init_trigger_line_rendering();
init_default_pipelines();
array_reserve(*engine.renderer.command_buffer.commands, 4096);
@@ -698,35 +700,42 @@ create_renderer :: (window: *Window) -> *Renderer {
}
init_default_pipelines :: () {
{
vs := create_vertex_shader(renderer, "../modules/Coven/shaders/font.hlsl", "VS");
ps := create_pixel_shader(renderer, "../modules/Coven/shaders/font.hlsl", "PS");
//{
// vs := create_vertex_shader(renderer, "../modules/Coven/shaders/font.hlsl", "VS");
// ps := create_pixel_shader(renderer, "../modules/Coven/shaders/font.hlsl", "PS");
layout : [3] Vertex_Data_Info;
layout[0] = .{0,.POSITION2D, 0};
layout[1] = .{0,.TEXCOORD0, 0};
layout[2] = .{0,.COLOR_WITH_ALPHA, 0};
// layout : [3] Vertex_Data_Info;
// layout[0] = .{0,.POSITION2D, 0};
// layout[1] = .{0,.TEXCOORD0, 0};
// layout[2] = .{0,.COLOR_WITH_ALPHA, 0};
params : [2] Shader_Parameter;
params[0].shader = .PIXEL;
params[0].type = .SAMPLER;
params[0].name = "ss";
params[0].slot = 0;
params[0].mapping = .CLAMP_SAMPLER;
// params : [2] Shader_Parameter;
// params[0].shader = .PIXEL;
// params[0].type = .SAMPLER;
// params[0].name = "ss";
// params[0].slot = 0;
// params[0].mapping = .CLAMP_SAMPLER;
params[1].shader = .PIXEL;
params[1].type = .TEXTURE;
params[1].name = "tex";
params[1].slot = 1;
// params[1].shader = .PIXEL;
// params[1].type = .TEXTURE;
// params[1].name = "tex";
// params[1].slot = 1;
engine.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);
//}
//{
// vs := create_vertex_shader_from_source(engine.renderer, "fallback", FALLBACK_SHADER, "VS", mesh_data_types = .[.POSITION]);
// ps := create_pixel_shader_from_source(engine.renderer, "fallback", FALLBACK_SHADER, "PS");
// projectile_pipeline = create_pipeline_state2(engine.renderer, vs, ps, blend_type=.OPAQUE);
//}
{
vs := create_vertex_shader_from_source(engine.renderer, FALLBACK_SHADER, "VS", mesh_data_types = .[.POSITION]);
ps := create_pixel_shader_from_source(engine.renderer, FALLBACK_SHADER, "PS");
vs := create_vertex_shader_from_source(engine.renderer, "default_entity", DEFAULT_ENTITY_SHADER, "VS", mesh_data_types = .[.POSITION, .NORMAL, .TEXCOORD]);
ps := create_pixel_shader_from_source(engine.renderer, "default_entity", DEFAULT_ENTITY_SHADER, "PS");
projectile_pipeline = create_pipeline_state2(engine.renderer, vs, ps, blend_type=.OPAQUE);
engine.renderer.default_pipelines.entity_pipeline = create_pipeline_state(engine.renderer, vs, ps, blend_type=.OPAQUE);
}
}
@@ -1689,6 +1698,55 @@ render :: () {
// #load "ui.jai";
//}
render_default_renderable_entities :: () {
for e: engine.current_scene.entities {
if e.flags & .RENDERABLE && e.renderable.use_default_pipeline {
render_entity(e, engine.renderer.default_pipelines.entity_pipeline);
}
}
}
render_entity :: (e: *Entity, pipeline: Pipeline_State_Handle) {
if e.renderable.type == {
case .MODEL; {
model := get_model_by_handle(e.renderable.model);
if model == null return;
for node, node_index: model.nodes {
render_data := e.renderable.nodes[node_index];
if !render_data.enabled continue;
if node.meshes.count > 0 {
for m, mi: node.meshes {
push_cmd_set_pipeline_state(engine.renderer, pipeline);
push_cmd_set_constant_buffer(engine.renderer, 1, engine.directional_light_buffer, .VERTEX);
push_cmd_set_constant_buffer(engine.renderer, 1, engine.directional_light_buffer, .PIXEL);
push_cmd_set_constant_buffer(engine.renderer, 2, render_data.transform_buffer, .VERTEX);
push_cmd_set_constant_buffer(engine.renderer, 3, render_data.material_buffer, .PIXEL);
if node.num_bones > 0 {
push_cmd_set_constant_buffer(engine.renderer, 4, render_data.bone_buffers[mi], .VERTEX);
}
mesh := parray_get(*engine.renderer.meshes, m);
vb := get_mesh_vb(mesh);
push_cmd_set_vertex_buffer(engine.renderer, vb);
if mesh.ib != 0 {
push_cmd_set_index_buffer(engine.renderer, mesh.ib);
push_cmd_draw_indexed(engine.renderer, mesh.indices.count);
} else {
push_cmd_draw(engine.renderer, mesh.positions.count);
}
}
}
}
}
}
}
#scope_module
#load "dx11_renderer.jai";
@@ -1724,3 +1782,146 @@ float4 PS(PSInput input) : SV_Target {
return float4(1,0,1,1);
}
DONE
DEFAULT_ENTITY_SHADER :: #string DONE
cbuffer CameraData : register(b0)
{
float4x4 projection;
float4x4 view;
float4 camera_position;
};
cbuffer Directional_Light_Data : register(b1)
{
float4 color_and_intensity;
float4 direction;
float4x4 light_matrix;
};
cbuffer Transform : register(b2)
{
float4x4 model;
};
cbuffer Material : register(b3)
{
float4 base_color;
};
#ifdef SKINNING
#define MAX_BONES 128
cbuffer Bone_Matrices : register(b4)
{
float4x4 bone_matrices[MAX_BONES];
};
#endif
struct VSInput {
float3 position : POSITION;
float3 normal : NORMAL;
float2 texcoord : TEXCOORD0;
#ifdef SKINNING
float4 bone_indices : TEXCOORD1;
float4 bone_weights : TEXCOORD2;
#endif
};
struct PSInput {
float4 position : SV_POSITION;
float2 texcoord : TEXCOORD1;
float3 normal : NORMAL;
float2 screen_pos : TEXCOORD0;
float4 light_view_position : TEXCOORD3;
};
struct PSOutput {
float4 color : SV_Target0;
};
sampler samp : register(s0);
Texture2D shadow_map: register(t0);
PSInput VS(VSInput input) {
PSInput output;
float3 position = input.position;
#ifdef SKINNING
float4x4 m = float4x4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
for(int i = 0; i < 4; i++) {
m += bone_matrices[int(input.bone_indices[i])] * input.bone_weights[i];
}
output.position = mul(float4(position, 1.0), m);
#else
output.position = mul(float4(position, 1.0), model);
#endif
output.light_view_position = mul(output.position, light_matrix);
output.position = mul(output.position, view);
output.position = mul(output.position, projection);
output.screen_pos = output.position.xy / output.position.w;
output.screen_pos = output.screen_pos * 0.5 + 0.5;
output.normal = normalize(mul(input.normal, model));
output.texcoord = input.texcoord;
return output;
}
float calculate_shadow(float2 shadow_coord, float bias, float current_depth) {
if(current_depth > 1.0)
return 0.0;
float2 texture_size;
shadow_map.GetDimensions(texture_size.x, texture_size.y);
float2 texel_size = 1.0 / texture_size;
float shadow = 0.0;
for(int x = -1; x <= 1; ++x)
{
for(int y = -1; y <= 1; ++y)
{
float pcf_depth = shadow_map.Sample(samp, shadow_coord + float2(x, y) * texel_size).r;
shadow += current_depth - bias > pcf_depth ? 1.0 : 0.0;
}
}
shadow /= 9.0;
return 1.0 - shadow;
}
PSOutput PS(PSInput input) {
PSOutput output;
float ao = 1.0;//ssao.Sample(samp, float2(input.screen_pos.x, 1.0 - input.screen_pos.y));
//output.color = float4(ao, ao, ao, 1.0);
//return output;
float3 ambient = 0.1;
// Diffuse
float3 light_dir = normalize(-direction);
float diffuse_factor = max(0, dot(input.normal, light_dir));
float3 diffuse = 0.5 * diffuse_factor;
// Specular
float3 view_dir = normalize(-input.position.xyz);
float3 reflect_dir = reflect(-light_dir, input.normal);
float specular_factor = pow(max(dot(view_dir, reflect_dir), 0), 32.0);
float3 specular = 0.3 * specular_factor;
float2 shadow_coord;
shadow_coord.x = input.light_view_position.x / input.light_view_position.w * 0.5 + 0.5;
shadow_coord.y = -input.light_view_position.y / input.light_view_position.w * 0.5 + 0.5;
float current_depth = input.light_view_position.z / input.light_view_position.w;
float shadow_amount = calculate_shadow(shadow_coord, 0.01, current_depth);
output.color = base_color * color_and_intensity.w * float4(ao*(ambient + diffuse + specular), base_color.a);
output.color *= max(0.2, shadow_amount);
return output;
}
DONE