// p5's GeometryBuilder (src/webgl/GeometryBuilder.js): while building,
// drawn shapes and models are collected into one geometry with the model
// matrix applied. (Per-material parts are not split out yet.)
///|
priv struct GeometryBuilder {
geometry : Geometry
}
///|
let next_builder_id : Ref[Int32] = Ref(0)
///|
/// Starts collecting drawn shapes into a geometry (`beginGeometry`).
pub fn Renderer3D::begin_geometry(self : Renderer3D) -> Unit {
self.push()
self.state.model = @math.Matrix::new(4)
let g = Geometry::new()
g.gid = "_p5_GeometryBuilder_\{next_builder_id.val}"
next_builder_id.val += 1
self.builder = Some({ geometry: g, })
}
///|
/// Finishes collecting and returns the geometry (`endGeometry`).
pub fn Renderer3D::end_geometry(self : Renderer3D) -> Geometry {
self.pop()
match self.builder {
Some(b) => {
self.builder = None
b.geometry
}
None => Geometry::new()
}
}
///|
fn is_identity(m : @math.Matrix) -> Bool {
let id = @math.Matrix::new(4)
for i in 0..<16 {
if m.get(i) != id.get(i) {
return false
}
}
true
}
///|
fn Renderer3D::builder_add(
self : Renderer3D,
input : Geometry,
faces : Array[(Int32, Int32, Int32)],
style : Style,
) -> Unit {
guard self.builder is Some(b) else { return }
let out = b.geometry
let model = self.state.model
let has_transform = !is_identity(model)
let normal_m = @math.Matrix::new(3)
if has_transform {
ignore(normal_m.inverse_transpose4x4(model))
}
let start = out.vertices.length()
for v in input.vertices {
if has_transform {
let (x, y, z, _) = model.multiply_vec4(v.x, v.y, v.z, 1)
out.vertices.push(Vec3::new(x, y, z))
} else {
out.vertices.push(v)
}
}
for n in input.vertex_normals {
if has_transform {
let m = (i : Int32) => normal_m.get(i)
out.vertex_normals.push(
Vec3::new(
0.0 + m(0) * n.x + m(3) * n.y + m(6) * n.z,
0.0 + m(1) * n.x + m(4) * n.y + m(7) * n.z,
0.0 + m(2) * n.x + m(5) * n.y + m(8) * n.z,
),
)
} else {
out.vertex_normals.push(n)
}
}
out.uvs.append(input.uvs)
if style.fill is Some(_) {
for f in faces {
out.faces.push((f.0 + start, f.1 + start, f.2 + start))
}
}
if style.stroke is Some(_) {
for e in input.edges {
out.edges.push((e.0 + start, e.1 + start))
}
}
let colors = input.vertex_colors.copy()
let fill = style.fill.unwrap_or([0, 0, 0, 0])
while colors.length() < input.vertices.length() * 4 {
for k in 0..<4 {
colors.push(fill[k])
}
}
out.vertex_colors.append(colors)
out.dirty = true
}
///|
/// Faces for an immediate shape in the builder (`addImmediate`).
fn immediate_faces(
g : Geometry,
mode : ShapeMode,
has_fill : Bool,
) -> Array[(Int32, Int32, Int32)] {
let faces : Array[(Int32, Int32, Int32)] = []
if !has_fill {
return faces
}
let n = g.vertices.length()
match mode {
TriangleStripMode | QuadStripMode =>
for i in 2..
for i in 2.. {
let mut i = 0
while i < n {
faces.push((i, i + 1, i + 2))
i += 3
}
}
_ => ()
}
faces
}