gizmo-renderer 0.1.0

A custom ECS and physics engine aimed for realistic simulations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

struct LightData {
    position:  vec4<f32>,
    color:     vec4<f32>,
    direction: vec4<f32>,
    params:    vec4<f32>,
};

struct SceneUniforms {
    view_proj: mat4x4<f32>,
    camera_pos: vec4<f32>,
    sun_direction: vec4<f32>,
    sun_color: vec4<f32>,
    lights: array<LightData, 10>,
    light_view_proj: array<mat4x4<f32>, 4>,
    cascade_splits: vec4<f32>,
    camera_forward: vec4<f32>,
    cascade_params: vec4<f32>,
    num_lights: u32,
    _pad_scene: vec3<u32>,
};

@group(0) @binding(0)
var<uniform> scene: SceneUniforms;

@group(1) @binding(0)
var t_diffuse: texture_2d<f32>;
@group(1) @binding(1)
var s_diffuse: sampler;

struct SkeletonData {
    joints: array<mat4x4<f32>, 128>, // Maksimum 64 kemik destegi
};
@group(3) @binding(0)
var<uniform> skeleton: SkeletonData;

struct InstanceRaw {
    model_matrix_0: vec4<f32>,
    model_matrix_1: vec4<f32>,
    model_matrix_2: vec4<f32>,
    model_matrix_3: vec4<f32>,
    albedo_color: vec4<f32>,
    pbr: vec4<f32>,
};

@group(4) @binding(0)
var<storage, read> instances: array<InstanceRaw>;

struct VertexInput {
    @location(0) position: vec3<f32>,
    @location(1) color: vec3<f32>,
    @location(2) normal: vec3<f32>,
    @location(3) tex_coords: vec2<f32>,
    @location(4) joint_indices: vec4<u32>,
    @location(5) joint_weights: vec4<f32>,
};

struct VertexOutput {
    @builtin(position) clip_position: vec4<f32>,
    @location(0) color: vec3<f32>,
    @location(1) tex_coords: vec2<f32>,
    @location(2) inst_albedo: vec4<f32>,
    @location(3) world_pos: vec3<f32>,
};

@vertex
fn vs_main(@builtin(instance_index) instance_idx: u32, input: VertexInput) -> VertexOutput {
    var out: VertexOutput;
    out.color = input.color;
    out.tex_coords = input.tex_coords;
    
    let inst = instances[instance_idx];
    let model = mat4x4<f32>(
        inst.model_matrix_0,
        inst.model_matrix_1,
        inst.model_matrix_2,
        inst.model_matrix_3,
    );
    out.inst_albedo = inst.albedo_color;

    let world_pos_4 = model * vec4<f32>(input.position, 1.0);
    out.world_pos = world_pos_4.xyz;
    out.clip_position = scene.view_proj * world_pos_4;
    
    return out;
}

@fragment
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
    let coord = in.world_pos.xz;
    let grid_size = 1.0;
    
    let grid_coord = coord / grid_size;
    let derivative = fwidth(grid_coord);
    let grid_abs = abs(fract(grid_coord - 0.5) - 0.5) / derivative;
    let line_val = min(grid_abs.x, grid_abs.y);
    
    let is_line = 1.0 - min(line_val, 1.0);
    
    let dist_x = abs(coord.x) / derivative.x;
    let dist_y = abs(coord.y) / derivative.y; // coord.y is actually world Z
    
    var color = vec3<f32>(0.5, 0.5, 0.5); // base color
    let axis_width = 1.5;
    
    // Axes: X (red), Z (blue)
    if dist_y < axis_width {
        color = vec3<f32>(1.0, 0.2, 0.2);
    } else if dist_x < axis_width {
        color = vec3<f32>(0.2, 0.2, 1.0);
    }
    
    // Major lines every 10 units
    let major_grid_coord = coord / 10.0;
    let major_derivative = fwidth(major_grid_coord);
    let major_grid_abs = abs(fract(major_grid_coord - 0.5) - 0.5) / major_derivative;
    let major_line_val = min(major_grid_abs.x, major_grid_abs.y);
    let is_major_line = 1.0 - min(major_line_val, 1.0);
    
    if (dist_y >= axis_width && dist_x >= axis_width && is_major_line > 0.0) {
        color = vec3<f32>(0.8, 0.8, 0.8);
    }

    let alpha_multiplier = max(is_line * 0.3, is_major_line * 0.8);

    // Fade out distance
    let dist_to_camera = distance(scene.camera_pos.xz, coord);
    let fade = 1.0 - clamp(dist_to_camera / 150.0, 0.0, 1.0);
    
    let final_alpha = alpha_multiplier * fade;
    if (final_alpha < 0.01) {
        discard;
    }
    
    return vec4<f32>(color, final_alpha * in.inst_albedo.a);
}