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
|
use crate::{
core_shapes::CoreDrawable,
rendering::{Render, Renderer},
solving::{Constrainable, SolverContext},
types::Bounds,
};
// TODO:
// const RECURSION_LIMIT: u64 = 10_000;
pub struct Runtime<'a> {
solver_ctx: Box<dyn SolverContext + 'a>,
renderer: Box<dyn Renderer>,
// drawables: Vec<DynDrawable>,
drawables: Vec<CoreDrawable>,
}
impl<'a> Runtime<'a> {
pub fn new(solver_ctx: Box<dyn SolverContext + 'a>, renderer: Box<dyn Renderer>) -> Self {
Self {
solver_ctx,
renderer,
drawables: Vec::new(),
}
}
pub fn add_drawable(&mut self, drawable: CoreDrawable) {
self.drawables.push(drawable)
}
pub fn solver_ctx(&mut self) -> &mut (dyn SolverContext + 'a) {
&mut *self.solver_ctx
}
pub fn renderer(&mut self) -> &mut dyn Renderer {
&mut *self.renderer
}
pub fn render(self, bounds: Bounds) {
// Separate self into several variables, so we can get mutable references to each at the
// same time
let Runtime {
mut solver_ctx,
mut renderer,
drawables,
} = self;
for drawable in &drawables {
drawable.inherent_constraints(&mut *solver_ctx, &mut *renderer);
}
let model = solver_ctx.solve();
let bounds = bounds
.fixate(&*model)
.expect("Could not fixate figure bounds");
renderer.set_size(bounds.width, bounds.height);
for drawable in &drawables {
let defined_drawable = drawable
.fixate(&*model)
.expect("Could not fixate core shape");
defined_drawable
.shape
.render(defined_drawable.context, &mut *renderer);
}
}
}
|
