oxihuman-viewer 0.2.1

wgpu/WebGPU rendering adapter for OxiHuman
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

#![allow(dead_code)]

/// Render pipeline state configuration.
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct RenderPipelineState {
    vertex_shader: Option<String>,
    fragment_shader: Option<String>,
    blend_enabled: bool,
    depth_test: bool,
}

#[allow(dead_code)]
pub fn new_pipeline_state() -> RenderPipelineState {
    RenderPipelineState { vertex_shader: None, fragment_shader: None, blend_enabled: false, depth_test: true }
}

#[allow(dead_code)]
pub fn set_vertex_shader(ps: &mut RenderPipelineState, name: &str) { ps.vertex_shader = Some(name.to_string()); }

#[allow(dead_code)]
pub fn set_fragment_shader(ps: &mut RenderPipelineState, name: &str) { ps.fragment_shader = Some(name.to_string()); }

#[allow(dead_code)]
pub fn set_blend_state(ps: &mut RenderPipelineState, enabled: bool) { ps.blend_enabled = enabled; }

#[allow(dead_code)]
pub fn set_depth_state_rps(ps: &mut RenderPipelineState, enabled: bool) { ps.depth_test = enabled; }

#[allow(dead_code)]
pub fn pipeline_to_json(ps: &RenderPipelineState) -> String {
    format!("{{\"vertex\":{},\"fragment\":{},\"blend\":{},\"depth\":{}}}", ps.vertex_shader.is_some(), ps.fragment_shader.is_some(), ps.blend_enabled, ps.depth_test)
}

#[allow(dead_code)]
pub fn pipeline_is_valid(ps: &RenderPipelineState) -> bool {
    ps.vertex_shader.is_some() && ps.fragment_shader.is_some()
}

#[allow(dead_code)]
pub fn pipeline_reset(ps: &mut RenderPipelineState) {
    ps.vertex_shader = None; ps.fragment_shader = None; ps.blend_enabled = false; ps.depth_test = true;
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test] fn test_new() { assert!(!pipeline_is_valid(&new_pipeline_state())); }
    #[test] fn test_set_shaders() {
        let mut p = new_pipeline_state();
        set_vertex_shader(&mut p, "v"); set_fragment_shader(&mut p, "f");
        assert!(pipeline_is_valid(&p));
    }
    #[test] fn test_blend() {
        let mut p = new_pipeline_state();
        set_blend_state(&mut p, true);
        assert!(p.blend_enabled);
    }
    #[test] fn test_depth() {
        let mut p = new_pipeline_state();
        set_depth_state_rps(&mut p, false);
        assert!(!p.depth_test);
    }
    #[test] fn test_to_json() { assert!(pipeline_to_json(&new_pipeline_state()).contains("blend")); }
    #[test] fn test_reset() {
        let mut p = new_pipeline_state();
        set_vertex_shader(&mut p, "v");
        pipeline_reset(&mut p);
        assert!(!pipeline_is_valid(&p));
    }
    #[test] fn test_partial_valid() {
        let mut p = new_pipeline_state();
        set_vertex_shader(&mut p, "v");
        assert!(!pipeline_is_valid(&p));
    }
    #[test] fn test_default_depth() { assert!(new_pipeline_state().depth_test); }
    #[test] fn test_default_blend() { assert!(!new_pipeline_state().blend_enabled); }
    #[test] fn test_set_both_shaders() {
        let mut p = new_pipeline_state();
        set_vertex_shader(&mut p, "main_vs"); set_fragment_shader(&mut p, "main_fs");
        assert!(pipeline_is_valid(&p));
    }
}