rustial-renderer-wgpu 0.0.1

Pure WGPU renderer for the rustial 2.5D map engine
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

//! View-projection uniform buffer with distance fog, hillshade, and lighting parameters.

use bytemuck::{Pod, Zeroable};

/// GPU-side uniform containing the view-projection matrix, fog parameters,
/// terrain hillshade parameters, and scene lighting.
///
/// Layout (std140-aligned):
/// - `view_proj`:            mat4x4<f32>
/// - `fog_color`:            vec4<f32>
/// - `eye_pos`:              vec4<f32>
/// - `fog_params`:           vec4<f32>
/// - `hillshade_highlight`:  vec4<f32>
/// - `hillshade_shadow`:     vec4<f32>
/// - `hillshade_accent`:     vec4<f32>
/// - `hillshade_light`:      vec4<f32> = (dir_rad, altitude_rad, exaggeration, opacity)
/// - `ambient_color`:        vec4<f32> = (r, g, b, lighting_enabled)
/// - `directional_dir`:      vec4<f32> = (x, y, z, 0)
/// - `directional_color`:    vec4<f32> = (r, g, b, 0)
#[repr(C)]
#[derive(Debug, Clone, Copy, Pod, Zeroable)]
pub struct ViewProjUniform {
    /// Column-major 4x4 view-projection matrix (`projection * view`).
    pub view_proj: [[f32; 4]; 4],
    /// Fog / horizon colour (RGBA, typically the clear colour).
    pub fog_color: [f32; 4],
    /// Camera eye position in camera-relative world coordinates (w = 0).
    pub eye_pos: [f32; 4],
    /// `[fog_start, fog_end, fog_density, 0.0]`
    pub fog_params: [f32; 4],
    /// Hillshade highlight colour.
    pub hillshade_highlight: [f32; 4],
    /// Hillshade shadow colour.
    pub hillshade_shadow: [f32; 4],
    /// Hillshade accent colour.
    pub hillshade_accent: [f32; 4],
    /// `(illumination_direction_rad, illumination_altitude_rad, exaggeration, opacity)`.
    pub hillshade_light: [f32; 4],
    /// Ambient light colour (linear RGB) scaled by intensity.  `w` = lighting enabled (1.0 or 0.0).
    pub ambient_color: [f32; 4],
    /// Unit direction **toward** the directional light source.  `w` = 0.
    pub directional_dir: [f32; 4],
    /// Directional light colour (linear RGB) scaled by intensity.  `w` = 0.
    pub directional_color: [f32; 4],
}

impl ViewProjUniform {
    /// Create from a glam DMat4 (f64 -> f32 truncation) with default fog, hillshade, and lighting.
    pub fn from_dmat4(m: &glam::DMat4) -> Self {
        let m32 = m.as_mat4();
        let default_lighting = rustial_engine::ComputedLighting::default();
        Self {
            view_proj: m32.to_cols_array_2d(),
            fog_color: [1.0, 1.0, 1.0, 1.0],
            eye_pos: [0.0, 0.0, 0.0, 0.0],
            fog_params: [0.0, 1.0, 0.0, 0.0],
            hillshade_highlight: [1.0, 1.0, 1.0, 1.0],
            hillshade_shadow: [0.0, 0.0, 0.0, 1.0],
            hillshade_accent: [0.42, 0.48, 0.42, 1.0],
            hillshade_light: [335.0f32.to_radians(), 45.0f32.to_radians(), 1.0, 0.0],
            ambient_color: [
                default_lighting.ambient_color[0],
                default_lighting.ambient_color[1],
                default_lighting.ambient_color[2],
                default_lighting.lighting_enabled,
            ],
            directional_dir: [
                default_lighting.directional_dir[0],
                default_lighting.directional_dir[1],
                default_lighting.directional_dir[2],
                0.0,
            ],
            directional_color: [
                default_lighting.directional_color[0],
                default_lighting.directional_color[1],
                default_lighting.directional_color[2],
                0.0,
            ],
        }
    }
}