egaku2d_core/
shapes.rs

1use super::*;
2
3//pub use self::circle_program::Vertex;
4
5pub struct SquareSave {
6    _ns: NotSend,
7    buffer: vbo::StaticBuffer<circle_program::Vertex>,
8}
9impl SquareSave {
10    pub fn uniforms<'a>(&'a self, sys: &'a mut SimpleCanvas, radius: f32) -> Uniforms<'a> {
11        let common = UniformCommon {
12            color: sys.color,
13            offset: sys.offset,
14        };
15        let un = ProgramUniformValues::new(radius, gl::POINTS);
16
17        Uniforms {
18            sys,
19            un: UniformVals::Regular(un),
20            common,
21            buffer: self.buffer.get_info(),
22        }
23    }
24}
25
26pub struct SquareSession {
27    pub(crate) verts: Vec<circle_program::Vertex>,
28}
29impl SquareSession {
30    pub fn new() -> Self {
31        SquareSession { verts: Vec::new() }
32    }
33    #[inline(always)]
34    pub fn add(&mut self, point: [f32; 2]) -> &mut Self {
35        self.verts.push(circle_program::Vertex(point));
36        self
37    }
38
39    pub fn append(&mut self, other: &mut Self) {
40        self.verts.append(&mut other.verts);
41    }
42
43    pub fn save(&mut self, _sys: &mut SimpleCanvas) -> SquareSave {
44        SquareSave {
45            _ns: ns(),
46            buffer: vbo::StaticBuffer::new(&self.verts),
47        }
48    }
49
50    pub fn send_and_uniforms<'a>(
51        &'a mut self,
52        sys: &'a mut SimpleCanvas,
53        radius: f32,
54    ) -> Uniforms<'a> {
55        sys.circle_buffer.send_to_gpu(&self.verts);
56
57        let common = UniformCommon {
58            color: sys.color,
59            offset: sys.offset,
60        };
61        let un = ProgramUniformValues::new(radius, gl::POINTS);
62
63        let buffer = sys.circle_buffer.get_info(self.verts.len());
64        Uniforms {
65            sys,
66            common,
67            un: UniformVals::Regular(un),
68            buffer,
69        }
70    }
71}
72
73pub struct CircleSave {
74    _ns: NotSend,
75    buffer: vbo::StaticBuffer<circle_program::Vertex>,
76}
77impl CircleSave {
78    pub fn uniforms<'a>(&'a self, sys: &'a mut SimpleCanvas, radius: f32) -> Uniforms<'a> {
79        let common = UniformCommon {
80            color: sys.color,
81            offset: sys.offset,
82        };
83        let un = ProgramUniformValues::new(radius, gl::POINTS);
84
85        let buffer = self.buffer.get_info();
86        Uniforms {
87            common,
88            sys,
89            un: UniformVals::Circle(un),
90            buffer,
91        }
92    }
93}
94pub struct CircleSession {
95    pub(crate) verts: Vec<circle_program::Vertex>,
96}
97
98impl CircleSession {
99    pub fn new() -> Self {
100        CircleSession { verts: Vec::new() }
101    }
102    pub fn save(&mut self, _sys: &mut SimpleCanvas) -> CircleSave {
103        CircleSave {
104            _ns: ns(),
105            buffer: vbo::StaticBuffer::new(&self.verts),
106        }
107    }
108
109    pub fn append(&mut self, other: &mut Self) {
110        self.verts.append(&mut other.verts);
111    }
112    pub fn send_and_uniforms<'a>(
113        &'a mut self,
114        sys: &'a mut SimpleCanvas,
115        radius: f32,
116    ) -> Uniforms<'a> {
117        sys.circle_buffer.send_to_gpu(&self.verts);
118
119        let common = UniformCommon {
120            color: sys.color,
121            offset: sys.offset,
122        };
123        let un = ProgramUniformValues::new(radius, gl::POINTS);
124
125        let buffer = sys.circle_buffer.get_info(self.verts.len());
126        Uniforms {
127            sys,
128            common,
129            un: UniformVals::Circle(un),
130            buffer,
131        }
132    }
133
134    #[inline(always)]
135    pub fn add(&mut self, point: [f32; 2]) -> &mut Self {
136        self.verts.push(circle_program::Vertex(point));
137        self
138    }
139}
140
141pub struct RectSave {
142    _ns: NotSend,
143    buffer: vbo::StaticBuffer<circle_program::Vertex>,
144}
145
146impl RectSave {
147    pub fn uniforms<'a>(&'a self, sys: &'a mut SimpleCanvas) -> Uniforms<'a> {
148        let common = UniformCommon {
149            color: sys.color,
150            offset: sys.offset,
151        };
152        let un = ProgramUniformValues::new(0.0, gl::TRIANGLES);
153        let buffer = self.buffer.get_info();
154        Uniforms {
155            sys,
156            common,
157            un: UniformVals::Regular(un),
158            buffer,
159        }
160    }
161}
162
163pub struct RectSession {
164    pub(crate) verts: Vec<circle_program::Vertex>,
165}
166
167impl RectSession {
168    pub fn new() -> Self {
169        RectSession { verts: Vec::new() }
170    }
171
172    pub fn save(&mut self, _sys: &mut SimpleCanvas) -> RectSave {
173        RectSave {
174            _ns: ns(),
175            buffer: vbo::StaticBuffer::new(&self.verts),
176        }
177    }
178
179    pub fn append(&mut self, other: &mut Self) {
180        self.verts.append(&mut other.verts);
181    }
182    pub fn send_and_uniforms<'a>(&'a mut self, sys: &'a mut SimpleCanvas) -> Uniforms<'a> {
183        sys.circle_buffer.send_to_gpu(&self.verts);
184
185        let common = UniformCommon {
186            color: sys.color,
187            offset: vec2same(0.0),
188        };
189        let un = ProgramUniformValues::new(0.0, gl::TRIANGLES);
190        let buffer = sys.circle_buffer.get_info(self.verts.len());
191        Uniforms {
192            sys,
193            common,
194            un: UniformVals::Regular(un),
195            buffer,
196        }
197    }
198
199    #[inline(always)]
200    fn create_rect(rect: [f32; 4]) -> [circle_program::Vertex; 6] {
201        let rect:Rect<f32> = core::convert::From::from(rect);
202        let [tl, tr, br, bl] = rect.get_corners();
203        //let arr = [tr, tl, bl, bl, br, tr];
204
205        fn doop(a: Vec2<f32>) -> circle_program::Vertex {
206            circle_program::Vertex([a.x, a.y])
207        }
208        [doop(tr), doop(tl), doop(bl), doop(bl), doop(br), doop(tr)]
209    }
210    #[inline(always)]
211    pub fn add(&mut self, rect: [f32; 4]) -> &mut Self {
212        let arr = Self::create_rect(rect);
213        self.verts.extend_from_slice(&arr);
214        self
215    }
216}
217
218pub struct ArrowSave {
219    _ns: NotSend,
220    buffer: vbo::StaticBuffer<circle_program::Vertex>,
221}
222impl ArrowSave {
223    pub fn uniforms<'a>(&'a self, sys: &'a mut SimpleCanvas) -> Uniforms<'a> {
224        let common = UniformCommon {
225            color: sys.color,
226            offset: sys.offset,
227        };
228        let un = ProgramUniformValues::new(0.0, gl::TRIANGLES);
229        Uniforms {
230            sys,
231            common,
232            un: UniformVals::Regular(un),
233            buffer: self.buffer.get_info(),
234        }
235    }
236}
237pub struct ArrowSession {
238    pub(crate) radius: f32,
239    pub(crate) verts: Vec<circle_program::Vertex>,
240}
241
242impl ArrowSession {
243    pub fn new(radius: f32) -> Self {
244        ArrowSession {
245            radius,
246            verts: Vec::new(),
247        }
248    }
249    pub fn save(&mut self, _sys: &mut SimpleCanvas) -> ArrowSave {
250        ArrowSave {
251            _ns: ns(),
252            buffer: vbo::StaticBuffer::new(&self.verts),
253        }
254    }
255
256    pub fn append(&mut self, other: &mut Self) {
257        self.verts.append(&mut other.verts);
258    }
259    pub fn send_and_uniforms<'a>(&'a mut self, sys: &'a mut SimpleCanvas) -> Uniforms<'a> {
260        sys.circle_buffer.send_to_gpu(&self.verts);
261
262        let common = UniformCommon {
263            color: sys.color,
264            offset: vec2same(0.0),
265        };
266        let un = ProgramUniformValues::new(0.0, gl::TRIANGLES);
267        let buffer = sys.circle_buffer.get_info(self.verts.len());
268        Uniforms {
269            sys,
270            common,
271            un: UniformVals::Regular(un),
272            buffer,
273        }
274    }
275
276    #[inline(always)]
277    fn create_arrow(radius: f32, start: PointType, end: PointType) -> [circle_program::Vertex; 9] {
278        let start = vec2(start[0], start[1]);
279        let end = vec2(end[0], end[1]);
280        let offset = end - start;
281
282        let arrow_head = start + offset * 0.8;
283
284        let k = offset.rotate_90deg_right().normalize_to(1.0);
285        let start1 = start + k * radius;
286        let start2 = start - k * radius;
287
288        let end1 = arrow_head + k * radius;
289        let end2 = arrow_head - k * radius;
290
291        let end11 = arrow_head + k * radius * 2.5;
292        let end22 = arrow_head - k * radius * 2.5;
293        //let arr = [start1, start2, end1, start2, end1, end2, end, end11, end22];
294
295        fn doop(a: Vec2<f32>) -> circle_program::Vertex {
296            circle_program::Vertex([a.x, a.y])
297        }
298
299        [
300            doop(start1),
301            doop(start2),
302            doop(end1),
303            doop(start2),
304            doop(end1),
305            doop(end2),
306            doop(end),
307            doop(end11),
308            doop(end22),
309        ]
310    }
311
312    #[inline(always)]
313    pub fn add(&mut self, start: PointType, end: PointType) -> &mut Self {
314        let arr = Self::create_arrow(self.radius, start, end);
315        self.verts.extend_from_slice(&arr);
316        self
317    }
318}
319
320pub struct LineSave {
321    _ns: NotSend,
322    buffer: vbo::StaticBuffer<circle_program::Vertex>,
323}
324
325impl LineSave {
326    pub fn uniforms<'a>(&'a self, sys: &'a mut SimpleCanvas) -> Uniforms<'a> {
327        let common = UniformCommon {
328            color: sys.color,
329            offset: sys.offset,
330        };
331        let un = ProgramUniformValues::new(0.0, gl::TRIANGLES);
332        Uniforms {
333            sys,
334            common,
335            un: UniformVals::Regular(un),
336            buffer: self.buffer.get_info(),
337        }
338    }
339}
340
341pub struct LineSession {
342    pub(crate) radius: f32,
343    pub(crate) verts: Vec<circle_program::Vertex>,
344}
345
346impl LineSession {
347    pub fn new(radius: f32) -> Self {
348        LineSession {
349            radius,
350            verts: Vec::new(),
351        }
352    }
353
354    pub fn save(&mut self, _sys: &mut SimpleCanvas) -> LineSave {
355        LineSave {
356            _ns: ns(),
357            buffer: vbo::StaticBuffer::new(&self.verts),
358        }
359    }
360
361    pub fn append(&mut self, other: &mut Self) {
362        self.verts.append(&mut other.verts);
363    }
364    pub fn send_and_uniforms<'a>(&'a mut self, sys: &'a mut SimpleCanvas) -> Uniforms<'a> {
365        sys.circle_buffer.send_to_gpu(&self.verts);
366
367        let common = UniformCommon {
368            color: sys.color,
369            offset: sys.offset,
370        };
371
372        let un = ProgramUniformValues::new(0.0, gl::TRIANGLES);
373        let buffer = sys.circle_buffer.get_info(self.verts.len());
374        Uniforms {
375            sys,
376            common,
377            un: UniformVals::Regular(un),
378            buffer,
379        }
380    }
381
382    #[inline(always)]
383    fn create_line(radius: f32, start: PointType, end: PointType) -> [circle_program::Vertex; 6] {
384        let start = vec2(start[0], start[1]); //TODO a program that detected bad uses like this would be cool
385        let end = vec2(end[0], end[1]);
386
387        let offset = end - start;
388        let k = offset.rotate_90deg_right().normalize_to(1.0);
389        let start1 = start + k * radius;
390        let start2 = start - k * radius;
391
392        let end1 = end + k * radius;
393        let end2 = end - k * radius;
394
395        //let arr = [start1, start2, end1, start2, end1, end2];
396
397        fn doop(a: Vec2<f32>) -> circle_program::Vertex {
398            circle_program::Vertex([a.x, a.y])
399        }
400
401        [
402            doop(start1),
403            doop(start2),
404            doop(end1),
405            doop(start2),
406            doop(end1),
407            doop(end2),
408        ]
409    }
410
411    #[inline(always)]
412    pub fn add(&mut self, start: PointType, end: PointType) -> &mut Self {
413        let a = Self::create_line(self.radius, start, end);
414        self.verts.extend_from_slice(&a);
415        self
416    }
417}
egaku2d_core/shapes.rs

egaku2d_core/
shapes.rs
