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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
use flo_draw::*;
use flo_draw::canvas::*;
use flo_draw::render_canvas::*;
use ::desync::*;
use futures::prelude::*;
use futures::stream;
use futures::executor;
use std::mem;
use std::sync::*;
use std::collections::{HashMap};
///
/// Draws a circle, then intercepts the tessellation and displays that instead
///
/// flo_draw sends graphics to and from its various subsystems using streams rather than
/// method calls: this makes it very easy to intercept and change what's being sent around.
/// In this case we take the instructions just before they would have been sent to the GPU
/// and display them as line art, showing what the GPU would be rendering.
///
/// These actions are performed by the flo_render_canvas library. The instructions aren't
/// specific to any particular API at this point, so they can be used to implement rendering
/// on APIs or libraries that aren't explicitly supported by `flo_render` or to interoperate
/// with other rendering systems such as that which might be present in a game engine or a
/// UI layer. Note that there's no need to set up callbacks or implement traits in order to
/// retrieve this part of the state of the renderer.
///
/// It's possible to create a window that renders the GPU instructions directly by calling
/// `create_render_window`.
///
pub fn main() {
with_2d_graphics(|| {
// Create a drawing target. canvas is our renderer, and stream is where these instructions are sent to
let (canvas, canvas_stream) = DrawingTarget::new();
// Create a canvas renderer, and wrap it in a Desync.
// The canvas renderer generates instructions for a GPU-based renderer.
// Desync is a companion library; it provides a convenient API for many asynchronous tasks, in this case stream processing
let renderer = CanvasRenderer::new();
let renderer = Arc::new(Desync::new(renderer));
// Configure it to a viewport of 768x768 (want 'square pixels' so the rendering isn't squashed later on)
renderer.desync(|renderer| {
renderer.set_viewport(0.0..768.0, 0.0..768.0, 768.0, 768.0, 1.0);
});
// Use Desync to process the rendering instructions on the stream (returning a stream of vecs, which we flatten to a stream of single instructions)
let canvas_stream = canvas_stream.ready_chunks(1000);
let mut gpu_instructions = pipe(renderer, canvas_stream, |renderer, drawing_instructions| {
async move {
renderer.draw(drawing_instructions.into_iter())
.collect::<Vec<_>>()
.await
}.boxed()
}).map(|as_vectors| stream::iter(as_vectors)).flatten();
// Draw a circle that will get sent to the renderer we just set up (rather than directly to the window)
canvas.draw(|gc| {
// Set up the canvas
gc.canvas_height(1000.0);
gc.center_region(0.0, 0.0, 1000.0, 1000.0);
// Draw a circle
gc.new_path();
gc.circle(500.0, 500.0, 250.0);
gc.fill_color(Color::Rgba(0.3, 0.6, 0.8, 1.0));
gc.fill();
gc.line_width(6.0);
gc.stroke_color(Color::Rgba(0.0, 0.0, 0.0, 1.0));
gc.stroke();
});
// Dropping the canvas closes the stream so the list of drawing instructions ends
mem::drop(canvas);
// Create a window to render on
let tessellation_window = create_drawing_window("Circle Tessellation");
// Run an executor to track the instructions that we would be sending to the GPU and render them to the tessellation window instead
executor::block_on(async {
// We to keep the vertex buffers around so we can render them once we get the index buffers
let mut vertex_buffers = HashMap::new();
let mut index_buffers = HashMap::new();
while let Some(gpu_instruction) = gpu_instructions.next().await {
// Render the tessellation to the tesselator window
match &gpu_instruction {
RenderAction::SetTransform(Matrix(t)) => {
// Set an approximate equivalent of the transform the 'draw' instruction generated
tessellation_window.draw(|gc| {
gc.canvas_height(2.0);
gc.center_region(0.0, 0.0, 2.0, 2.0);
gc.transform(Transform2D([
[t[0][0], t[0][1], t[0][2]],
[t[1][0], t[1][1], t[1][2]],
[t[2][0], t[2][1], t[2][2]]
]));
})
}
RenderAction::CreateVertex2DBuffer(buffer_id, vertices) => {
// Store the vertex buffer: we can render it when we get the corresponding index buffer
vertex_buffers.insert(*buffer_id, vertices.clone());
}
RenderAction::CreateIndexBuffer(buffer_id, indicies) => {
// Store the index buffer for when we receive the rendering instruction
index_buffers.insert(*buffer_id, indicies.clone());
}
RenderAction::DrawIndexedTriangles(vertex_buffer_id, index_buffer_id, num_vertices) => {
// Fetch the buffers
let vertices = vertex_buffers.get(&vertex_buffer_id).unwrap();
let indicies = index_buffers.get(&index_buffer_id).unwrap();
tessellation_window.draw(|gc| {
// Render triangles from the index buffer
for triangle_num in 0..(num_vertices/3) {
// Use the index buffer to look up the vertices for this triangle
let index = triangle_num * 3;
let i1: u16 = indicies[index+0];
let i2: u16 = indicies[index+1];
let i3: u16 = indicies[index+2];
let p1: &Vertex2D = &vertices[i1 as usize];
let p2: &Vertex2D = &vertices[i2 as usize];
let p3: &Vertex2D = &vertices[i3 as usize];
let colour = Color::Rgba(p1.color[0] as f32/255.0, p1.color[1] as f32/255.0, p1.color[2] as f32/255.0, p1.color[3] as f32/255.0);
// Render as lines
gc.new_path();
gc.move_to(p1.pos[0], p1.pos[1]);
gc.line_to(p2.pos[0], p2.pos[1]);
gc.line_to(p3.pos[0], p3.pos[1]);
gc.close_path();
gc.stroke_color(colour);
gc.stroke();
}
});
}
_ => {}
}
}
})
});
}