sailor 0.1.0

A sailing navigation application.
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

use crate::drawing::vertex::VertexType;
use crate::drawing::vertex::{
    Vertex,
    LayerVertexCtor
};
use lyon::{
    path::{
        Index,
        VertexId,
    },
    tessellation::{
        VertexBuffers,
        GeometryBuilder,
        FillVertex,
        StrokeVertex,
        VertexConstructor,
        geometry_builder::{
            GeometryBuilderError,
            MaxIndex,
            Count,
        },
    },
};

pub struct MeshBuilder<'l> {
    pub buffers: &'l mut VertexBuffers<Vertex, u32>,
    vertex_offset: Index,
    index_offset: Index,
    vertex_constructor: LayerVertexCtor,
}

impl<'l> MeshBuilder<'l> {
    pub fn new(buffers: &'l mut VertexBuffers<Vertex, u32>, vertex_constructor: LayerVertexCtor) -> Self {
        let vertex_offset = buffers.vertices.len() as Index;
        let index_offset = buffers.indices.len() as Index;
        Self {
            buffers,
            vertex_offset,
            index_offset,
            vertex_constructor,
        }
    }

    pub fn set_current_feature_id(&mut self, feature_id: u32) {
        self.vertex_constructor.feature_id = feature_id;
    }

    pub fn set_current_extent(&mut self, extent: f32) {
        self.vertex_constructor.extent = extent;
    }

    pub fn get_current_index(&mut self) -> u32 {
        self.buffers.indices.len() as u32
    }

    pub fn set_current_vertex_type(&mut self, vertex_type: VertexType) {
        self.vertex_constructor.vertex_type = vertex_type;
    }
}

impl<'l> GeometryBuilder<FillVertex>
    for MeshBuilder<'l>
{
    fn begin_geometry(&mut self) {
        self.vertex_offset = self.buffers.vertices.len() as Index;
        self.index_offset = self.buffers.indices.len() as Index;
    }

    fn end_geometry(&mut self) -> Count {
        Count {
            vertices: self.buffers.vertices.len() as u32 - self.vertex_offset,
            indices: self.buffers.indices.len() as u32 - self.index_offset,
        }
    }

    fn add_vertex(&mut self, v: FillVertex) -> Result<VertexId, GeometryBuilderError> {
        self.buffers.vertices.push(self.vertex_constructor.new_vertex(v));
        let len = self.buffers.vertices.len();
        if len > u32::max_index() {
            return Err(GeometryBuilderError::TooManyVertices);
        }
        Ok(VertexId((len - 1) as Index - self.vertex_offset))
    }

    fn add_triangle(&mut self, a: VertexId, b: VertexId, c: VertexId) {
        self.buffers.indices.push((a + self.vertex_offset).into());
        self.buffers.indices.push((b + self.vertex_offset).into());
        self.buffers.indices.push((c + self.vertex_offset).into());
    }

    fn abort_geometry(&mut self) {
        self.buffers.vertices.truncate(self.vertex_offset as usize);
        self.buffers.indices.truncate(self.index_offset as usize);
    }
}

impl<'l> GeometryBuilder<StrokeVertex>
    for MeshBuilder<'l>
{
    fn begin_geometry(&mut self) {
        self.vertex_offset = self.buffers.vertices.len() as Index;
        self.index_offset = self.buffers.indices.len() as Index;
    }

    fn end_geometry(&mut self) -> Count {
        Count {
            vertices: self.buffers.vertices.len() as u32 - self.vertex_offset,
            indices: self.buffers.indices.len() as u32 - self.index_offset,
        }
    }

    fn add_vertex(&mut self, v: StrokeVertex) -> Result<VertexId, GeometryBuilderError> {
        self.buffers.vertices.push(self.vertex_constructor.new_vertex(v));
        let len = self.buffers.vertices.len();
        if len > u32::max_index() {
            return Err(GeometryBuilderError::TooManyVertices);
        }
        Ok(VertexId((len - 1) as Index - self.vertex_offset))
    }

    fn add_triangle(&mut self, a: VertexId, b: VertexId, c: VertexId) {
        self.buffers.indices.push((a + self.vertex_offset).into());
        self.buffers.indices.push((b + self.vertex_offset).into());
        self.buffers.indices.push((c + self.vertex_offset).into());
    }

    fn abort_geometry(&mut self) {
        self.buffers.vertices.truncate(self.vertex_offset as usize);
        self.buffers.indices.truncate(self.index_offset as usize);
    }
}