galileo 0.2.1

Cross-platform general purpose map rendering 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
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

use wgpu::{
    BindGroupLayout, CompareFunction, DepthStencilState, Device, RenderPass, RenderPipeline,
    RenderPipelineDescriptor, StencilFaceState, StencilOperation, StencilState, TextureFormat,
};

use crate::render::render_bundle::world_set::PolyVertex;
use crate::render::wgpu::pipelines::{default_pipeline_descriptor, default_targets};
use crate::render::wgpu::{DisplayInstance, WgpuVertexBuffers, DEPTH_FORMAT};
use crate::render::RenderOptions;

pub struct ClipPipeline {
    wgpu_pipeline: RenderPipeline,
    wgpu_pipeline_antialias: RenderPipeline,
}

impl ClipPipeline {
    const UNCLIP_REFERENCE: u32 = 0;
    const CLIP_STENCIL_VALUE: u32 = 1;

    pub fn create(
        device: &Device,
        format: TextureFormat,
        map_view_layout: &BindGroupLayout,
    ) -> Self {
        let buffers = [PolyVertex::wgpu_desc(), DisplayInstance::wgpu_desc()];
        let shader = device.create_shader_module(wgpu::include_wgsl!("./shaders/map_ref.wgsl"));

        let clip_stencil_state = StencilFaceState {
            compare: CompareFunction::Never,
            fail_op: StencilOperation::Replace,
            depth_fail_op: StencilOperation::Keep,
            pass_op: StencilOperation::Keep,
        };
        let targets = default_targets(format);
        let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: None,
            bind_group_layouts: &[map_view_layout],
            push_constant_ranges: &[],
        });

        let depth_stencil = Some(DepthStencilState {
            format: DEPTH_FORMAT,
            depth_write_enabled: false,
            depth_compare: CompareFunction::Always,
            stencil: StencilState {
                front: clip_stencil_state,
                back: clip_stencil_state,
                read_mask: 0xff,
                write_mask: 0xff,
            },
            bias: Default::default(),
        });

        let wgpu_pipeline_antialias = device.create_render_pipeline(&RenderPipelineDescriptor {
            depth_stencil: depth_stencil.clone(),
            ..default_pipeline_descriptor(&layout, &shader, &targets, &buffers, true)
        });
        let wgpu_pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
            depth_stencil,
            ..default_pipeline_descriptor(&layout, &shader, &targets, &buffers, false)
        });

        Self {
            wgpu_pipeline,
            wgpu_pipeline_antialias,
        }
    }

    pub fn clip<'a>(
        &'a self,
        buffers: &'a WgpuVertexBuffers,
        render_pass: &mut RenderPass<'a>,
        render_options: RenderOptions,
    ) {
        self.render(
            buffers,
            render_pass,
            Self::CLIP_STENCIL_VALUE,
            render_options,
        );
    }

    pub fn unclip<'a>(
        &'a self,
        buffers: &'a WgpuVertexBuffers,
        render_pass: &mut RenderPass<'a>,
        render_options: RenderOptions,
    ) {
        self.render(buffers, render_pass, Self::UNCLIP_REFERENCE, render_options);
    }

    fn render<'a>(
        &'a self,
        buffers: &'a WgpuVertexBuffers,
        render_pass: &mut RenderPass<'a>,
        stencil_reference: u32,
        render_options: RenderOptions,
    ) {
        if render_options.antialias {
            render_pass.set_pipeline(&self.wgpu_pipeline_antialias);
        } else {
            render_pass.set_pipeline(&self.wgpu_pipeline);
        }

        render_pass.set_stencil_reference(stencil_reference);
        render_pass.set_vertex_buffer(0, buffers.vertex.slice(..));
        render_pass.set_index_buffer(buffers.index.slice(..), wgpu::IndexFormat::Uint32);
        render_pass.draw_indexed(0..buffers.index_count, 0, 0..1);
    }
}