# Problem:
API design for this kind of project is hard. The programatic API needs to be
nice to use, but it also needs to be powerfull enough to allow for a
graphical tool to be build.
## Scene
Specifically, there needs to be a great Scene api that allows for many
objects to be added, then rendered, and selectively re-rendered. For
example, changing one object doesn't mean that the entire scene should be
re-rendered.
## Lines (and how lines work)
Implicit surfaces are built off of the idea that everything is a solid. This
doesn't hold up at the very end of the process though when we want to convert
from an implicit to a cut-out line.
Sometimes this line circles all the way around an object, but other times
it requires a mask. This mask is different from implicit-based boolean ops
because the mask can only be subtractive (there's no such thing as an
additive mask). Also, the mask removes parts of the *line*, not parts of
the shape.
Lines can be either a solid outline, or dashed.
Dashed lines have two different modes of interacting with masks.
1. Cut off parts of dashed lines.
2. Don't draw *anything* for a dash that has a part of it masked.
Behavior 1 is closer to what you get for solid lines, but behavior 2 can
be really useful for when you never want a "partially drawn" dash.
# API
Top level elements in the API
```rust
trait Implicit;
enum DrawObject<I: Implicit> {
Solid(I),
Line(I),
DashedLine(I, Vec<f32>, bool)
}
struct Scene {
new(Vec<DrawObject>) -> Scene;
render_svg(&self) -> String;
}
enum RenderedType {
Solid(Vec<f32>),
}
```