Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.1

0.9.1 / src / brep / model.lucb

## The B-rep as a structure of arrays: vertices, curves, surfaces, faces and
## loops each a set of columns (brep_store.lucb), shared by count between
## copies of a model. Edge IDs are shared across incident faces. The
## surfaces' control vertices form the `cv` domain (brep_cvs.lucb). The
## tessellator reads owned records (brep_types.lucb) made from the columns
## once per model and kept until the model changes.
import interop
import memory
from luce_geocore.core import parallel
from luce_std import math
import sync
from luce_geocore.geocore import Vector3, Matrix4, Mesh, invalid
from luce_geocore.core.growing import Growing
from luce_geocore.kernel import BitsBuilder, GeometryWriter, GeometryReader, PropertyHeader, dtype_float64, dtype_int32, dtype_uint8
from luce_geocore.core.shared import Column
from luce_geocore.kernel import TableBuilder, Domain, text_attribute
from tessellation.surface import NurbsSurface, NurbsCurve
from brep_types import Curve, Surface, BrepFace
from brep_store import Store
from brep_mesh import tessellate
from face_cache import FaceCache, dispose_cache, inherited
from face_mesh import face_mesh
from curve_trim import parameter
from surface_trim import project, evaluate
from luce_geocore.kernel import moved_storage, mesh_adopt, precise_span, Float3, Attribute

## Values per curve frame: origin, x and y axes, radius, start angle, sweep.
let curve_stride: usize = 12
## Values per surface frame: origin, x and z axes, radius, angle.
let surface_stride: usize = 11

## The tessellator's records, made once from the columns: the first
## `made_*` of each array are valid.
pub struct Records:
    pub var edges: Curve[]
    pub var surfaces: Surface[]
    pub var faces: BrepFace[]
    var made_edges: usize = 0
    var made_surfaces: usize = 0
    var made_faces: usize = 0

    pub func close():
        for edge in self.edges[..<self.made_edges]: edge.close()
        for surface in self.surfaces[..<self.made_surfaces]: surface.close()
        for face in self.faces[..<self.made_faces]: face.close()
        free(self.edges) in memory.heap
        free(self.surfaces) in memory.heap
        free(self.faces) in memory.heap

## A whole-model tessellation kept for its parameters.
struct KeptMesh:
    let divisions: i64
    let edge_size: f64
    let curvature: bool
    let directions: bool
    let mesh: interop.Reference[Mesh]

## What a model derives from its columns on demand (from any thread): the
## tessellator's records, the per-face tessellation cache and the last few
## whole tessellations. Behind a pointer, so reading a model can fill it.
struct Derived:
    var lock: sync.Mutex
    var records: Records*?
    var faces: FaceCache*?
    var meshes: Growing[KeptMesh]
    ## A copy with moved cvs: where its quick preview comes from, and the
    ## preview once made (quick.lucb).
    var quick: QuickSource*? = none
    var quick_result: interop.Reference[Mesh]? = none
    ## The edges' polylines (overlay.lucb), made once; copies with moved
    ## cvs share every edge, so they start with them.
    var boundaries: Growing[Vector3] = Growing[Vector3]()

pub struct BrepModel:
    let tolerance: f64
    var vertices: Store[Vector3]
    # Curves: kind (0 line, 1 circle arc, 2 B-spline interval, 3 ellipse
    # arc), end vertices, frame, degree, sense, control points (lines keep
    # their two ends), weights (an ellipse its minor radius) and knots.
    var curve_kind: Store[u8]
    var curve_ends: Store[i32]
    var curve_frame: Store[f64]
    var curve_degree: Store[i32]
    var curve_sense: Store[u8]
    var curve_point_offsets: Store[i32]
    var curve_points: Store[Vector3]
    var curve_weight_offsets: Store[i32]
    var curve_weights: Store[f64]
    var curve_knot_offsets: Store[i32]
    var curve_knots: Store[f64]
    # Surfaces: kind (0 plane, 1 cylinder, 2 cone, 3 rational B-spline,
    # 4 sphere, 5 torus), frame, dimensions (nu, nv, du, dv), control
    # vertices (the cv domain: positions and weights), knots (u then v), and
    # whether its cvs were moved since import (its trims may leave it).
    var surface_kind: Store[u8]
    var surface_edited: Store[u8]
    var surface_frame: Store[f64]
    var surface_dims: Store[i32]
    var surface_cv_offsets: Store[i32]
    var cv_positions: Store[Vector3]
    var surface_weight_offsets: Store[i32]
    var cv_weights: Store[f64]
    var surface_knot_offsets: Store[i32]
    var surface_knots: Store[f64]
    # Faces: support surface, sense, edge uses (signed: +(edge + 1) forward),
    # loop sizes (outer first), placement, color and path.
    var face_surface: Store[i32]
    var face_sense: Store[u8]
    var face_use_offsets: Store[i32]
    var face_uses: Store[i32]
    var face_loop_offsets: Store[i32]
    var loop_sizes: Store[i32]
    var face_placement: Store[Matrix4]
    var face_color: Store[Vector3]
    var face_colored: Store[u8]
    var face_paths: Growing[interop.Packet[str]?]
    var derived: Derived*

    pub func init(tolerance: f64 = 0.000001) -> !:
        if not math.is_finite(tolerance) or tolerance < 0.000000001 or tolerance > 1.0:
            error(invalid, "CAD tolerance must be finite and between 1e-9 and 1 source unit")
        self.tolerance = tolerance
        self.vertices = Store[Vector3]()
        self.curve_kind = Store[u8]()
        self.curve_ends = Store[i32]()
        self.curve_frame = Store[f64]()
        self.curve_degree = Store[i32]()
        self.curve_sense = Store[u8]()
        self.curve_point_offsets = Store[i32]()
        self.curve_points = Store[Vector3]()
        self.curve_weight_offsets = Store[i32]()
        self.curve_weights = Store[f64]()
        self.curve_knot_offsets = Store[i32]()
        self.curve_knots = Store[f64]()
        self.surface_kind = Store[u8]()
        self.surface_edited = Store[u8]()
        self.surface_frame = Store[f64]()
        self.surface_dims = Store[i32]()
        self.surface_cv_offsets = Store[i32]()
        self.cv_positions = Store[Vector3]()
        self.surface_weight_offsets = Store[i32]()
        self.cv_weights = Store[f64]()
        self.surface_knot_offsets = Store[i32]()
        self.surface_knots = Store[f64]()
        self.face_surface = Store[i32]()
        self.face_sense = Store[u8]()
        self.face_use_offsets = Store[i32]()
        self.face_uses = Store[i32]()
        self.face_loop_offsets = Store[i32]()
        self.loop_sizes = Store[i32]()
        self.face_placement = Store[Matrix4]()
        self.face_color = Store[Vector3]()
        self.face_colored = Store[u8]()
        self.face_paths = Growing[interop.Packet[str]?]()
        self.derived = try new Derived(sync.Mutex(), none, none, Growing[KeptMesh]()) in memory.heap
        # A failure below lets go of what is made so far.
        errdefer self.close()
        try self.curve_point_offsets.push(0)
        try self.curve_weight_offsets.push(0)
        try self.curve_knot_offsets.push(0)
        try self.surface_cv_offsets.push(0)
        try self.surface_weight_offsets.push(0)
        try self.surface_knot_offsets.push(0)
        try self.face_use_offsets.push(0)
        try self.face_loop_offsets.push(0)

    pub func face_count() -> i64:
        return (i64)self.face_surface.count

    pub func edge_count() -> i64:
        return (i64)self.curve_kind.count

    pub func vertex_count() -> i64:
        return (i64)self.vertices.count

    pub func surface_count() -> i64:
        return (i64)self.surface_kind.count

    func check_face(face: i64) -> !:
        if face < 0 or face >= self.face_count(): error(invalid, "CAD face index out of range")

    ## Support type: plane=0, cylinder=1, cone=2, NURBS=3, sphere=4, torus=5.
    pub func face_surface_kind(face: i64) -> i64!:
        try self.check_face(face)
        return (i64)self.surface_kind.get((usize)self.face_surface.get((usize)face))

    ## A format-independent object path attached to an analytic face.
    pub func face_path(face: i64) -> str!:
        try self.check_face(face)
        return (self.face_paths.items[(usize)face] else interop.Packet[str]("")).value

    pub func set_face_path(face: i64, path: str) -> !:
        try self.check_face(face)
        let copy = try interop.text_transfer.copy(path)
        if let previous = self.face_paths.items[(usize)face]: previous.release()
        self.face_paths.items[(usize)face] = copy

    ## The edge uses of face `face` (signed) and its loop sizes.
    func uses_of(face: usize) -> const i32[]:
        return self.face_uses.range((usize)self.face_use_offsets.get(face), (usize)self.face_use_offsets.get(face + 1))

    func loops_of(face: usize) -> const i32[]:
        return self.loop_sizes.range((usize)self.face_loop_offsets.get(face), (usize)self.face_loop_offsets.get(face + 1))

    ## Extract faces with compact shared topology; unrelated points and curves
    ## are not copied into the result. Face paths/colors/placements survive.
    pub func subset(selection: const i64[]) -> interop.Reference[BrepModel]!:
        let output = try interop.Reference[BrepModel].adopt(new BrepModel(self.tolerance) in memory.heap, brep_model_type, memory.heap)
        errdefer output.release()
        let target = output.value()
        let vertices = try new i64[self.vertices.count] --- in memory.heap
        defer free(vertices) in memory.heap
        let edges = try new i64[self.curve_kind.count] --- in memory.heap
        defer free(edges) in memory.heap
        let surfaces = try new i64[self.surface_kind.count] --- in memory.heap
        defer free(surfaces) in memory.heap
        for index in 0..<vertices.length: vertices[index] = -1
        for index in 0..<edges.length: edges[index] = -1
        for index in 0..<surfaces.length: surfaces[index] = -1
        var uses = Growing[i64]()
        defer uses.close()
        var sizes = Growing[i64]()
        defer sizes.close()
        for id in selection:
            try self.check_face(id)
            uses.clear()
            sizes.clear()
            for use in self.uses_of((usize)id):
                let index = (usize)(use - 1 if use > 0 else -use - 1)
                if edges[index] < 0:
                    for side in 0..<(usize)2:
                        let point = (usize)self.curve_ends.get(index * 2 + side)
                        if vertices[point] < 0: vertices[point] = try target.add_vertex(self.vertices.get(point))
                    edges[index] = try target.copy_curve(&self, index, vertices)
                try uses.push((edges[index] + 1) * (1 if use > 0 else -1))
            for size in self.loops_of((usize)id): try sizes.push((i64)size)
            let sid = (usize)self.face_surface.get((usize)id)
            if surfaces[sid] < 0:
                surfaces[sid] = try target.copy_surface(&self, sid)
                try target.surface_edited.set((usize)surfaces[sid], self.surface_edited.get(sid))
            let copied = try target.add_face(surfaces[sid], uses.view(), sizes.view(), self.face_sense.get((usize)id) == 1)
            try target.face_placement.set((usize)copied, self.face_placement.get((usize)id))
            try target.face_color.set((usize)copied, self.face_color.get((usize)id))
            try target.face_colored.set((usize)copied, self.face_colored.get((usize)id))
            try target.set_face_path(copied, try self.face_path(id))
        return output

    ## Curve `index` of `source`, its end vertices mapped through `vertices`.
    func copy_curve(source: const BrepModel*, index: usize, vertices: const i64[]) -> i64!:
        let start = vertices[(usize)source.curve_ends.get(index * 2)]
        let end = vertices[(usize)source.curve_ends.get(index * 2 + 1)]
        try self.push_curve(source.curve_kind.get(index), start, end, source.curve_frame.range(index * curve_stride, (index + 1) * curve_stride),
                            source.curve_points_of(index), source.curve_weights_of(index), source.curve_knots_of(index), (i64)source.curve_degree.get(index), source.curve_sense.get(index) == 1)
        return self.edge_count() - 1

    func copy_surface(source: const BrepModel*, index: usize) -> i64!:
        let dims = source.surface_dims.range(index * 4, index * 4 + 4)
        try self.push_surface(source.surface_kind.get(index), source.surface_frame.range(index * surface_stride, (index + 1) * surface_stride),
                              source.cvs_of(index), source.cv_weights_of(index), source.knots_of(index, 0), source.knots_of(index, 1), dims)
        return self.surface_count() - 1

    func curve_points_of(index: usize) -> const Vector3[]:
        return self.curve_points.range((usize)self.curve_point_offsets.get(index), (usize)self.curve_point_offsets.get(index + 1))

    func curve_weights_of(index: usize) -> const f64[]:
        return self.curve_weights.range((usize)self.curve_weight_offsets.get(index), (usize)self.curve_weight_offsets.get(index + 1))

    func curve_knots_of(index: usize) -> const f64[]:
        return self.curve_knots.range((usize)self.curve_knot_offsets.get(index), (usize)self.curve_knot_offsets.get(index + 1))

    ## Surface `index`'s control vertices (the cv domain range) and weights.
    func cvs_of(index: usize) -> const Vector3[]:
        return self.cv_positions.range((usize)self.surface_cv_offsets.get(index), (usize)self.surface_cv_offsets.get(index + 1))

    func cv_weights_of(index: usize) -> const f64[]:
        return self.cv_weights.range((usize)self.surface_weight_offsets.get(index), (usize)self.surface_weight_offsets.get(index + 1))

    ## Surface `index`'s knots in u (`axis` 0) or v (1).
    func knots_of(index: usize, axis: usize) -> const f64[]:
        let at = index * 2 + axis
        return self.surface_knots.range((usize)self.surface_knot_offsets.get(at), (usize)self.surface_knot_offsets.get(at + 1))

    pub func face_edge_count(face: i64) -> i64!:
        try self.check_face(face)
        return (i64)self.uses_of((usize)face).length

    func use_at(face: i64, use_index: i64) -> i64!:
        let count = try self.face_edge_count(face)
        if use_index < 0 or use_index >= count:
            error(invalid, "CAD edge use index out of range")
        return (i64)self.uses_of((usize)face)[(usize)use_index]

    pub func face_edge_point(face: i64, use_index: i64, fraction: f64) -> Vector3!:
        let use = try self.use_at(face, use_index)
        let edge = try self.curve((usize)(use - 1 if use > 0 else -use - 1))
        defer edge.close()
        return self.face_placement.get((usize)face).transform_point(try edge.at(fraction if use > 0 else 1.0 - fraction))

    pub func face_edge_linear(face: i64, use_index: i64) -> bool!:
        let use = try self.use_at(face, use_index)
        return self.curve_kind.get((usize)(use - 1 if use > 0 else -use - 1)) == 0

    pub func face_edge_id(face: i64, use_index: i64) -> i64!:
        let use = try self.use_at(face, use_index)
        return use - 1 if use > 0 else -use - 1

    pub func set_face_color(face: i64, color: Vector3) -> !:
        if face < 0 or face >= self.face_count() or not color.is_finite() or color.x < 0.0 or color.x > 1.0 or color.y < 0.0 or color.y > 1.0 or color.z < 0.0 or color.z > 1.0:
            error(invalid, "invalid CAD face color")
        try self.face_color.set((usize)face, color)
        try self.face_colored.set((usize)face, 1)
        self.changed()

    ## Preserve rigid assembly placement without changing support geometry.
    pub func set_face_placement(face: i64, matrix: Matrix4) -> !:
        if face < 0 or face >= self.face_count() or not matrix.is_finite() or math.abs(matrix.determinant() - 1.0) > 0.000001:
            error(invalid, "invalid rigid CAD face placement")
        try self.face_placement.set((usize)face, matrix)
        self.changed()

    pub func add_vertex(point: Vector3) -> i64!:
        if not point.is_finite(): error(invalid, "invalid B-rep vertex")
        try self.vertices.push(point)
        self.changed()
        return self.vertex_count() - 1

    func check_edge(start: i64, end: i64) -> !:
        if start < 0 or end < 0 or start >= self.vertex_count() or end >= self.vertex_count():
            error(invalid, "invalid B-rep edge endpoints")

    ## Append one curve's columns.
    func push_curve(kind: u8, start: i64, end: i64, frame: const f64[], points: const Vector3[], weights: const f64[], knots: const f64[], degree: i64, sense: bool) -> !:
        try self.curve_kind.push(kind)
        try self.curve_ends.push((i32)start)
        try self.curve_ends.push((i32)end)
        try self.curve_frame.append(frame)
        try self.curve_degree.push((i32)degree)
        try self.curve_sense.push(1 if sense else 0)
        try self.curve_points.append(points)
        try self.curve_point_offsets.push((i32)self.curve_points.count)
        try self.curve_weights.append(weights)
        try self.curve_weight_offsets.push((i32)self.curve_weights.count)
        try self.curve_knots.append(knots)
        try self.curve_knot_offsets.push((i32)self.curve_knots.count)
        self.changed()

    pub func add_line(start: i64, end: i64) -> i64!:
        try self.check_edge(start, end)
        if start == end:
            error(invalid, "collapsed B-rep line")
        var empty: f64[1]
        let frame = curve_frame(Vector3(), Vector3(), Vector3(), 0.0, 0.0, 0.0)
        try self.push_curve(0, start, end, frame[..<frame.length], [self.vertices.get((usize)start), self.vertices.get((usize)end)], empty[..<0], empty[..<0], 0, true)
        return self.edge_count() - 1

    pub func add_circle(start: i64, end: i64, origin: Vector3, axis: Vector3, reference: Vector3, radius: f64, sense: bool = true) -> i64!:
        try self.check_edge(start, end)
        let z = try axis.normalized()
        let x = try reference.subtract(z.multiply_scalar(reference.dot(z))).normalized()
        let y = z.cross(x)
        if not origin.is_finite() or not math.is_finite(radius) or radius <= 0.0:
            error(invalid, "invalid B-rep circle")
        let a = self.vertices.get((usize)start).subtract(origin)
        let b = self.vertices.get((usize)end).subtract(origin)
        if math.abs(a.dot(z)) > self.tolerance or math.abs(b.dot(z)) > self.tolerance or math.abs(a.length() - radius) > self.tolerance or math.abs(b.length() - radius) > self.tolerance:
            error(invalid, "circle endpoints are not on the curve")
        let angle = math.atan2(a.dot(y), a.dot(x))
        let sweep = swept(math.atan2(b.dot(y), b.dot(x)) - angle, sense)
        var empty: f64[1]
        let frame = curve_frame(origin, x, y, radius, angle, sweep)
        try self.push_curve(1, start, end, frame[..<frame.length], self.vertices.view()[..<0], empty[..<0], empty[..<0], 0, sense)
        return self.edge_count() - 1

    ## Retain an exact elliptical arc, with angles recovered from its endpoints.
    pub func add_ellipse(start: i64, end: i64, origin: Vector3, axis: Vector3, reference: Vector3, major: f64, minor: f64, sense: bool = true) -> i64!:
        try self.check_edge(start, end)
        if not origin.is_finite() or not math.is_finite(major) or not math.is_finite(minor) or major <= 0.0 or minor <= 0.0:
            error(invalid, "invalid B-rep ellipse")
        let z = try axis.normalized()
        let x = try reference.subtract(z.multiply_scalar(reference.dot(z))).normalized()
        let y = z.cross(x)
        let a = self.vertices.get((usize)start).subtract(origin)
        let b = self.vertices.get((usize)end).subtract(origin)
        let angle = math.atan2(a.dot(y) / minor, a.dot(x) / major)
        let end_angle = math.atan2(b.dot(y) / minor, b.dot(x) / major)
        if a.subtract(x.multiply_scalar(major * math.cos(angle)).add(y.multiply_scalar(minor * math.sin(angle)))).length() > self.tolerance or b.subtract(x.multiply_scalar(major * math.cos(end_angle)).add(y.multiply_scalar(minor * math.sin(end_angle)))).length() > self.tolerance:
            error(invalid, "ellipse endpoints are not on the curve")
        let sweep = swept(end_angle - angle, sense)
        var empty: f64[1]
        let frame = curve_frame(origin, x, y, major, angle, sweep)
        try self.push_curve(3, start, end, frame[..<frame.length], self.vertices.view()[..<0], [minor], empty[..<0], 0, sense)
        return self.edge_count() - 1

    pub func add_spline_edge(start: i64, end: i64, points: const Vector3[], weights: const f64[], degree: i64, knots: const f64[], sense: bool) -> i64!:
        try self.check_edge(start, end)
        if degree < 1 or (usize)degree >= knots.length or points.length >= knots.length:
            error(invalid, "invalid B-spline edge")
        let low = knots[(usize)degree]
        let high = knots[points.length]
        let a = try parameter(points, weights, degree, knots, self.vertices.get((usize)start), low if sense else high, self.tolerance)
        let b = try parameter(points, weights, degree, knots, self.vertices.get((usize)end), high if sense else low, self.tolerance)
        var sweep = b - a
        if (sense and sweep <= 0.0) or (not sense and sweep >= 0.0):
            let first = try NurbsCurve.at(points, weights, degree, knots, low)
            let last = try NurbsCurve.at(points, weights, degree, knots, high)
            if first.subtract(last).length() > self.tolerance:
                error(invalid, "B-spline trim orientation contradicts the edge sense")
            sweep += (high - low) * (1.0 if sense else -1.0)
        let frame = curve_frame(Vector3(), Vector3(), Vector3(), 0.0, a, sweep)
        try self.push_curve(2, start, end, frame[..<frame.length], points, weights, knots, degree, sense)
        return self.edge_count() - 1

    ## Append one surface's columns.
    func push_surface(kind: u8, frame: const f64[], points: const Vector3[], weights: const f64[], ku: const f64[], kv: const f64[], dims: const i32[]) -> !:
        try self.surface_kind.push(kind)
        try self.surface_edited.push(0)
        try self.surface_frame.append(frame)
        try self.surface_dims.append(dims)
        try self.cv_positions.append(points)
        try self.surface_cv_offsets.push((i32)self.cv_positions.count)
        try self.cv_weights.append(weights)
        try self.surface_weight_offsets.push((i32)self.cv_weights.count)
        try self.surface_knots.append(ku)
        try self.surface_knot_offsets.push((i32)self.surface_knots.count)
        try self.surface_knots.append(kv)
        try self.surface_knot_offsets.push((i32)self.surface_knots.count)
        self.changed()

    ## kind 0 plane, 1 cylinder, 2 cone, 4 sphere, 5 torus.
    ## For a torus radius/angle are major/minor radii. Placements stay exact.
    pub func add_surface(kind: i64, origin: Vector3, axis: Vector3, reference: Vector3, radius: f64 = 0.0, angle: f64 = 0.0) -> i64!:
        if kind < 0 or kind == 3 or kind > 5 or not origin.is_finite() or not math.is_finite(radius) or not math.is_finite(angle) or (kind > 0 and radius <= 0.0) or (kind == 2 and math.abs(angle) >= 1.5707963267948966) or (kind == 5 and angle <= 0.0):
            error(invalid, "invalid analytic B-rep surface")
        let z = try axis.normalized()
        let x = try reference.subtract(z.multiply_scalar(reference.dot(z))).normalized()
        let frame: f64[11] = [origin.x, origin.y, origin.z, x.x, x.y, x.z, z.x, z.y, z.z, radius, angle]
        var empty: f64[1]
        let dims: i32[4] = [0, 0, 0, 0]
        try self.push_surface((u8)kind, frame[..<frame.length], self.vertices.view()[..<0], empty[..<0], empty[..<0], empty[..<0], dims[..<4])
        return self.surface_count() - 1

    pub func add_spline_surface(points: const Vector3[], weights: const f64[], nu: i64, nv: i64, du: i64, dv: i64, ku: const f64[], kv: const f64[]) -> i64!:
        try NurbsSurface.check(points, weights, nu, nv, du, dv, ku, kv)
        let frame: f64[11] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        let dims: i32[4] = [(i32)nu, (i32)nv, (i32)du, (i32)dv]
        try self.push_surface(3, frame[..<frame.length], points, weights, ku, kv, dims[..<4])
        return self.surface_count() - 1

    ## Signed edge uses: +(edge ID + 1) forward, -(edge ID + 1) reversed.
    ## Outer loop first, holes afterward, any number of each. Reject
    ## disconnected topological loops.
    pub func add_face(surface: i64, uses: const i64[], sizes: const i64[], sense: bool = true) -> i64!:
        if surface < 0 or surface >= self.surface_count() or sizes.length == 0:
            error(invalid, "invalid B-rep face")
        let edges = self.edge_count()
        for use in uses:
            if use == 0 or use < -edges or use > edges:
                error(invalid, "B-rep face references a missing edge")
        var offset: usize = 0
        for size in sizes:
            if size < 1 or (usize)size > uses.length - offset:
                error(invalid, "invalid B-rep loop size")
            for at in 0..<(usize)size:
                let use = uses[offset + at]
                let next = uses[offset + (at + 1) % (usize)size]
                let edge = (usize)(use - 1 if use > 0 else -use - 1)
                let following = (usize)(next - 1 if next > 0 else -next - 1)
                let arrives = self.curve_ends.get(edge * 2 + (1 if use > 0 else 0))
                let leaves = self.curve_ends.get(following * 2 + (0 if next > 0 else 1))
                if arrives != leaves:
                    error(invalid, "disconnected B-rep loop")
            offset += (usize)size
        if offset != uses.length:
            error(invalid, "B-rep loop sizes do not describe every edge use")
        try self.face_surface.push((i32)surface)
        try self.face_sense.push(1 if sense else 0)
        for use in uses: try self.face_uses.push((i32)use)
        try self.face_use_offsets.push((i32)self.face_uses.count)
        for size in sizes: try self.loop_sizes.push((i32)size)
        try self.face_loop_offsets.push((i32)self.loop_sizes.count)
        try self.face_placement.push(Matrix4())
        try self.face_color.push(Vector3(1.0, 1.0, 1.0))
        try self.face_colored.push(0)
        try self.face_paths.push(none)
        self.changed()
        return self.face_count() - 1

    ## Owned records of curve `index` and surface `index`, and of face `index`
    ## (edge uses, loops, sense, placement, color).
    func curve(index: usize) -> Curve!:
        let frame = self.curve_frame.range(index * curve_stride, (index + 1) * curve_stride)
        return try Curve((i64)self.curve_kind.get(index), (i64)self.curve_ends.get(index * 2), (i64)self.curve_ends.get(index * 2 + 1),
                         Vector3(frame[0], frame[1], frame[2]), Vector3(frame[3], frame[4], frame[5]), Vector3(frame[6], frame[7], frame[8]), frame[9],
                         self.curve_points_of(index), self.curve_weights_of(index), self.curve_knots_of(index), (i64)self.curve_degree.get(index),
                         self.curve_sense.get(index) == 1, frame[10], frame[11])

    func surface(index: usize) -> Surface!:
        let frame = self.surface_frame.range(index * surface_stride, (index + 1) * surface_stride)
        let dims = self.surface_dims.range(index * 4, index * 4 + 4)
        var record = try Surface((i64)self.surface_kind.get(index), Vector3(frame[0], frame[1], frame[2]), Vector3(frame[3], frame[4], frame[5]), Vector3(frame[6], frame[7], frame[8]),
                                 frame[9], frame[10], self.cvs_of(index), self.cv_weights_of(index), self.knots_of(index, 0), self.knots_of(index, 1),
                                 (i64)dims[0], (i64)dims[1], (i64)dims[2], (i64)dims[3])
        record.edited = self.surface_edited.get(index) == 1
        return record

    func face(index: usize) -> BrepFace!:
        var uses = Growing[i64]()
        defer uses.close()
        var sizes = Growing[i64]()
        defer sizes.close()
        for use in self.uses_of(index): try uses.push((i64)use)
        for size in self.loops_of(index): try sizes.push((i64)size)
        var record = try BrepFace((i64)self.face_surface.get(index), uses.view(), sizes.view(), self.face_sense.get(index) == 1)
        record.placement = self.face_placement.get(index)
        record.color = self.face_color.get(index)
        record.colored = self.face_colored.get(index) == 1
        return record

    ## The tessellator's records: made on first use, kept until a change.
    func tessellation_records() -> const Records*!:
        let derived = self.derived
        derived.lock.lock()
        defer derived.lock.unlock()
        if let made = derived.records: return made
        let made = try make_records(&self)
        derived.records = made
        return made

    ## The per-face tessellation cache, made on first use.
    func face_cache() -> FaceCache*!:
        let derived = self.derived
        derived.lock.lock()
        defer derived.lock.unlock()
        if let made = derived.faces: return made
        let made = try new FaceCache() in memory.heap
        derived.faces = made
        return made

    ## A kept tessellation for these parameters (another owner), or none.
    func kept_mesh(divisions: i64, edge_size: f64, curvature: bool, directions: bool) -> interop.Reference[Mesh]?:
        let derived = self.derived
        derived.lock.lock()
        defer derived.lock.unlock()
        for kept in derived.meshes.view():
            if kept.divisions == divisions and kept.edge_size == edge_size and kept.curvature == curvature and kept.directions == directions: return kept.mesh.clone()
        return none

    ## Keep `mesh` for these parameters (the last four are kept).
    func keep_mesh(divisions: i64, edge_size: f64, curvature: bool, directions: bool, mesh: interop.Reference[Mesh]) -> !:
        let derived = self.derived
        derived.lock.lock()
        defer derived.lock.unlock()
        if derived.meshes.count == 4:
            derived.meshes.items[0].mesh.release()
            for at in 1..<4: derived.meshes.items[at - 1] = derived.meshes.items[at]
            derived.meshes.count = 3
        let owner = mesh.clone()
        derived.meshes.push(KeptMesh(divisions, edge_size, curvature, directions, owner)) catch failure:
            owner.release()
            error(failure.code, failure.message)

    ## Drop what was derived before a change.
    func changed():
        let derived = self.derived
        if let made = derived.records:
            made.close()
            free(made) in memory.heap
            derived.records = none
        if let cache = derived.faces:
            dispose_cache(cache)
            derived.faces = none
        for kept in derived.meshes.view(): kept.mesh.release()
        derived.meshes.count = 0
        drop_quick(derived)
        derived.boundaries.clear()

    ## Disposable per-face display mesh; independent of the whole-model budget.
    pub func preview_face(face: i64, divisions: i64 = 8) -> interop.Reference[Mesh]!:
        try self.check_face(face)
        let records = try self.tessellation_records()
        let entry = records.faces[(usize)face]
        return try published(try face_mesh(self.vertices.view(), records.edges, records.surfaces[(usize)entry.surface], entry, divisions, self.tolerance))

    ## Boundary-conforming tessellation; each shared edge is sampled once.
    ## `curvature` adds corner attributes curvature.k1/k2 (principal
    ## curvatures, k1 >= k2, positive where convex); `directions` adds the unit
    ## principal directions curvature.d1/d2. Both are off by default.
    ## With `quick`, a copy with moved cvs may answer with its quick preview
    ## (quick.lucb) instead of tessellating.
    pub func mesh(divisions: i64 = 16, edge_size: f64 = 0.0, progress: interop.Callback[f64, unit]? = none, curvature: bool = false, directions: bool = false, quick: bool = false) -> interop.Reference[Mesh]!:
        if not math.is_finite(edge_size) or edge_size < 0.0:
            error(invalid, "edge size must be finite and nonnegative")
        # The same parameters give the same mesh: share the kept one.
        if let kept = self.kept_mesh(divisions, edge_size, curvature, directions): return kept
        if quick:
            if let fast = try self.quick_mesh(divisions, edge_size, curvature, directions): return fast
        let records = try self.tessellation_records()
        let raw = try published(try tessellate(self.vertices.view(), records.edges, records.surfaces, records.faces, divisions, self.tolerance, edge_size, progress, -1, curvature, directions, try self.face_cache()))
        let made = try self.with_paths(raw)
        errdefer made.release()
        try self.keep_mesh(divisions, edge_size, curvature, directions, made)
        return made

    ## Takes `mesh`: with each face's B-rep path (by its `cad_face`) in the
    ## `path` text attribute, when any face has one.
    func with_paths(mesh: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
        var any = false
        for path in self.face_paths.view():
            if let text = path: any = any or text.value != ""
        let source = mesh.value().find_attribute("cad_face", 2)
        if not any or source < 0: return mesh
        defer mesh.release()
        var strings = TableBuilder()
        defer strings.close()
        let count = self.face_paths.count
        let face_paths = try new i32[count] --- in memory.heap
        defer free(face_paths) in memory.heap
        for face in 0..<count:
            face_paths[face] = -1
            if let text = self.face_paths.items[face]:
                if text.value != "": face_paths[face] = try strings.intern(text.value)
        let faces = (usize)mesh.value().face_count()
        let values = try new i32[faces] --- in memory.heap
        defer free(values) in memory.heap
        for face in 0..<faces:
            let original = (i64)(try mesh.value().attribute_value(source, (i64)face))
            values[face] = face_paths[(usize)original] if original >= 0 and (usize)original < count else -1
        return try mesh.value().with_attribute_entry(try text_attribute("path", Domain.face, faces, &strings, values))

    ## Diagnostic face mesh using the complete model's shared edge/layout plan.
    ## Other face jobs are skipped; success does not establish whole-model validity.
    pub func planned_face(face: i64, divisions: i64 = 16, edge_size: f64 = 0.0) -> interop.Reference[Mesh]!:
        try self.check_face(face)
        if not math.is_finite(edge_size) or edge_size < 0.0: error(invalid, "edge size must be finite and nonnegative")
        let records = try self.tessellation_records()
        let result = try tessellate(self.vertices.view(), records.edges, records.surfaces, records.faces, divisions, self.tolerance, edge_size, none, face)
        defer result.release()
        return try published(try result.value().compacted())

    pub func close():
        self.changed()
        self.derived.meshes.close()
        self.derived.boundaries.close()
        free(self.derived) in memory.heap
        self.vertices.close()
        self.curve_kind.close()
        self.curve_ends.close()
        self.curve_frame.close()
        self.curve_degree.close()
        self.curve_sense.close()
        self.curve_point_offsets.close()
        self.curve_points.close()
        self.curve_weight_offsets.close()
        self.curve_weights.close()
        self.curve_knot_offsets.close()
        self.curve_knots.close()
        self.surface_kind.close()
        self.surface_edited.close()
        self.surface_frame.close()
        self.surface_dims.close()
        self.surface_cv_offsets.close()
        self.cv_positions.close()
        self.surface_weight_offsets.close()
        self.cv_weights.close()
        self.surface_knot_offsets.close()
        self.surface_knots.close()
        self.face_surface.close()
        self.face_sense.close()
        self.face_use_offsets.close()
        self.face_uses.close()
        self.face_loop_offsets.close()
        self.loop_sizes.close()
        self.face_placement.close()
        self.face_color.close()
        self.face_colored.close()
        for path in self.face_paths.view():
            if let text = path: text.release()
        self.face_paths.close()

pub let brep_model_type: interop.Type[BrepModel] = interop.Type[BrepModel]("BrepModel", BrepModel.close, closeable = true)

## A curve frame's values.
func curve_frame(origin: Vector3, x: Vector3, y: Vector3, radius: f64, angle: f64, sweep: f64) -> f64[12]:
    return [origin.x, origin.y, origin.z, x.x, x.y, x.z, y.x, y.y, y.z, radius, angle, sweep]

## A sweep taken the way `sense` runs, never zero.
func swept(value: f64, sense: bool) -> f64:
    var sweep = value
    if sense:
        while sweep <= 0.000000000001: sweep += 6.283185307179586
    else:
        while sweep >= -0.000000000001: sweep -= 6.283185307179586
    return sweep

## Every record, in model order.
func make_records(model: const BrepModel*) -> Records*!:
    let edges = try new Curve[(usize)model.edge_count()] --- in memory.heap
    errdefer free(edges) in memory.heap
    let surfaces = try new Surface[(usize)model.surface_count()] --- in memory.heap
    errdefer free(surfaces) in memory.heap
    let faces = try new BrepFace[(usize)model.face_count()] --- in memory.heap
    errdefer free(faces) in memory.heap
    let made = try new Records(edges, surfaces, faces) in memory.heap
    errdefer:
        for edge in made.edges[..<made.made_edges]: edge.close()
        for surface in made.surfaces[..<made.made_surfaces]: surface.close()
        for face in made.faces[..<made.made_faces]: face.close()
        free(made) in memory.heap
    for index in 0..<edges.length:
        edges[index] = try model.curve(index)
        made.made_edges += 1
    for index in 0..<surfaces.length:
        surfaces[index] = try model.surface(index)
        made.made_surfaces += 1
    for index in 0..<faces.length:
        faces[index] = try model.face(index)
        made.made_faces += 1
    return made

## Tessellation works on precise meshes (f64 points; see geocore's
## Mesh); what it hands out is an ordinary f32 mesh. Takes `mesh`.
pub func published(mesh: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
    defer mesh.release()
    return try mesh.value().without_precision()