Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / src / model / display.lucb

## What a CadModel shows: its meshes (tessellate, planned_face, a face's
## preview and the pooled preview set) and the lines drawn over it (edges,
## hull, normal guides), for independent faces and a B-rep alike.
extend CadModel:
    ## What its edges' drawn lines depend on (0: not known, draw them anew):
    ## a B-rep's edges and the model's placement. A copy with moved control
    ## vertices keeps the key; the viewport keeps its lines.
    pub func edges_key() -> i64:
        if self.count != 0: return 0
        let boundary = self.boundary else return 0
        var key = boundary_key(boundary.value())
        let m = self.placement
        let values: f64[12] = [m.x.x, m.x.y, m.x.z, m.y.x, m.y.y, m.y.z, m.z.x, m.z.y, m.z.z, m.translation.x, m.translation.y, m.translation.z]
        for value in values: key = (key ^ value.bits()) *% 0x100000001B3
        return (i64)(key >> 1) | 1

    ## Lines to draw over the model: its edges (along `mesh`, its
    ## tessellation: mesh_boundary_lines), its hull, its feature nets and a
    ## normal guide per face of `mesh`.
    pub func overlay(mesh: interop.Reference[Mesh]) -> interop.Reference[CadOverlay]!:
        let result = try interop.Reference[CadOverlay].adopt(new CadOverlay() in memory.heap, cad_overlay_type, memory.heap)
        errdefer result.release()
        let boundaries = boundary_list(result.value())
        let hull = hull_list(result.value())
        if let boundary = self.boundary:
            if not (try mesh_boundary_lines(mesh.value(), &self, boundaries)): try boundary_lines(boundary.value(), self.placement, boundaries)
            try hull_lines(boundary.value(), self.placement, hull, false)
            try hull_lines(boundary.value(), self.placement, net_list(result.value()), true)
        for index in 0..<self.count:
            let entry = self.faces[index]
            let edges = try self.edge_count_in(none, (i64)index)
            for edge in 0..<edges:
                let chords = 1 if entry.nu == 0 else 64
                var previous = try self.edge_point_in(none, (i64)index, edge, 0.0)
                for step in 1..<chords + 1:
                    let next = try self.edge_point_in(none, (i64)index, edge, (f64)step / (f64)chords)
                    try boundaries.push(previous)
                    try boundaries.push(next)
                    previous = next
            for u in 0..<(usize)entry.nu:
                for v in 0..<(usize)entry.nv:
                    let here = self.placement.transform_point(entry.points[u * (usize)entry.nv + v])
                    if v + 1 < (usize)entry.nv:
                        try hull.push(here)
                        try hull.push(self.placement.transform_point(entry.points[u * (usize)entry.nv + v + 1]))
                    if u + 1 < (usize)entry.nu:
                        try hull.push(here)
                        try hull.push(self.placement.transform_point(entry.points[(u + 1) * (usize)entry.nv + v]))
        try face_guides(mesh.value(), guide_list(result.value()))
        return result

    ## The B-rep, resolved on the calling thread: preview workers may use the
    ## pointer but not the reference, whose owner belongs to this thread.
    func topology() -> BrepModel*?:
        if let value = self.boundary:
            return value.value()
        return none

    ## Produce a disposable display mesh; the analytic model is unchanged.
    pub func face_edge_count(face: i64) -> i64!:
        return try self.edge_count_in(self.topology(), face)

    pub func face_edge_point(face: i64, edge: i64, fraction: f64) -> Vector3!:
        return try self.edge_point_in(self.topology(), face, edge, fraction)

    pub func face_edge_linear(face: i64, edge: i64) -> bool!:
        return try self.edge_linear_in(self.topology(), face, edge)

    pub func face_edge_id(face: i64, edge: i64) -> i64!:
        return try self.edge_id_in(self.topology(), face, edge)

    pub func preview_face(face: i64, divisions: i64 = 8) -> interop.Reference[Mesh]!:
        return try self.preview_in(self.topology(), face, divisions)

    ## Every face's preview (see preview_face), meshed on the worker pool and
    ## merged into display batches in face order, with deduplicated analytic
    ## boundary polylines and a normal guide per face. Failed faces are
    ## counted and keep their boundaries.
    pub func preview(progress: interop.Callback[f64, unit]? = none) -> interop.Reference[CadPreviewSet]!:
        var seams = try BitsBuilder.zeros(0)
        if let boundary = self.topology():
            seams.close()
            seams = try seam_edges(boundary)
        defer seams.close()
        var job = PreviewJob(model = &self, topology = self.topology(), seams = seams.view())
        return try collect_preview((usize)self.face_count(), (usize)self.edge_count(), make_preview_part, (void*)&job, progress)

    func edge_count_in(topology: BrepModel*?, face: i64) -> i64!:
        if face < 0 or face >= self.face_count_in(topology):
            error(invalid, "CAD face index out of range")
        if let boundary = topology:
            if face >= (i64)self.count:
                return try boundary.face_edge_count(face - (i64)self.count)
        return (i64)self.faces[(usize)face].points.length if self.faces[(usize)face].nu == 0 else 4

    func face_count_in(topology: BrepModel*?) -> i64:
        if let boundary = topology:
            return (i64)self.count + boundary.face_count()
        return (i64)self.count

    func edge_point_in(topology: BrepModel*?, face: i64, edge: i64, fraction: f64) -> Vector3!:
        let count = try self.edge_count_in(topology, face)
        if edge < 0 or edge >= count or fraction < 0.0 or fraction > 1.0 or not math.is_finite(fraction):
            error(invalid, "invalid CAD boundary sample")
        if let boundary = topology:
            if face >= (i64)self.count:
                return self.placement.transform_point(try boundary.face_edge_point(face - (i64)self.count, edge, fraction))
        let entry = self.faces[(usize)face]
        if entry.nu == 0:
            let a = entry.points[(usize)edge]
            let b = entry.points[(usize)((edge + 1) % count)]
            return a.multiply_scalar(1.0 - fraction).add(b.multiply_scalar(fraction))
        let u = entry.u0 + (entry.u1 - entry.u0) * fraction
        let v = entry.v0 + (entry.v1 - entry.v0) * fraction
        return try NurbsSurface.at(entry.points, entry.weights, entry.nu, entry.nv, entry.du, entry.dv, entry.ku, entry.kv,
                                   u if edge == 0 or edge == 2 else (entry.u1 if edge == 1 else entry.u0), v if edge == 1 or edge == 3 else (entry.v0 if edge == 0 else entry.v1))

    func edge_linear_in(topology: BrepModel*?, face: i64, edge: i64) -> bool!:
        let count = try self.edge_count_in(topology, face)
        if edge < 0 or edge >= count:
            error(invalid, "CAD edge use index out of range")
        if let boundary = topology:
            if face >= (i64)self.count:
                return try boundary.face_edge_linear(face - (i64)self.count, edge)
        return self.faces[(usize)face].nu == 0

    func edge_id_in(topology: BrepModel*?, face: i64, edge: i64) -> i64!:
        let count = try self.edge_count_in(topology, face)
        if edge < 0 or edge >= count:
            error(invalid, "CAD edge use index out of range")
        if let boundary = topology:
            if face >= (i64)self.count:
                return try boundary.face_edge_id(face - (i64)self.count, edge)
        # Independent faces' edges follow the B-rep's, 2^32 ids per face.
        return (i64)CadModel.count_edges_in(topology) + face * 4294967296 + edge

    static func count_edges_in(topology: BrepModel*?) -> i64:
        if let boundary = topology:
            return boundary.edge_count()
        return 0

    func preview_in(topology: BrepModel*?, face: i64, divisions: i64) -> interop.Reference[Mesh]!:
        if face < 0 or face >= self.face_count_in(topology):
            error(invalid, "CAD preview face index out of range")
        if let boundary = topology:
            if face >= (i64)self.count:
                let part = try boundary.preview_face(face - (i64)self.count, divisions)
                defer part.release()
                return try part.value().placed(self.placement)
        let entry = self.faces[(usize)face]
        if entry.nu == 0:
            return try planar_mesh(entry.points)
        let part = try nurbs_grid(entry.points, entry.weights, entry.nu, entry.nv, entry.du, entry.dv, entry.ku, entry.kv, entry.u0, entry.u1, entry.v0, entry.v1, divisions)
        defer part.release()
        var output = try MeshBuilder()
        defer output.close()
        try output.copy_points(part.value())
        for at in 0..<part.value().face_count():
            let count = try part.value().face_size(at)
            try output.face(count)
            for corner in 0..<count:
                try output.corner(try part.value().face_point(at, count - 1 - corner if entry.reversed else corner))
        let raw = try output.finish()
        defer raw.release()
        var groups: i64[1]
        # The NURBS grid comes from precise tessellation; publish it in f32.
        return try brep.published(try MeshNormals.generate(raw, groups[..<0]))

    ## Diagnostic B-rep face using global shared-edge/layout planning, unlike
    ## the independent preview. Other face jobs are not validated by this call.
    pub func planned_face(face: i64, segments: i64 = 16, edge_size: f64 = 0.0) -> interop.Reference[Mesh]!:
        if self.count != 0: error(invalid, "planned face diagnostics require B-rep topology")
        let boundary = self.boundary else error(invalid, "CAD model has no B-rep")
        let part = try boundary.value().planned_face(face, segments, edge_size)
        defer part.release()
        return try part.value().placed(self.placement)

    ## Whether `tessellate` can add curvature attributes: a B-rep model under a
    ## uniform-scale placement.
    pub func supports_curvature() -> bool:
        if self.count != 0 or self.boundary == none: return false
        let matrix = self.placement
        let scale = matrix.x.length()
        let tolerance = scale * 1e-9
        return math.abs(matrix.y.length() - scale) <= tolerance and math.abs(matrix.z.length() - scale) <= tolerance and math.abs(matrix.x.dot(matrix.y)) <= tolerance * scale and math.abs(matrix.y.dot(matrix.z)) <= tolerance * scale and math.abs(matrix.x.dot(matrix.z)) <= tolerance * scale

    ## `curvature`/`directions` add principal curvature corner attributes
    ## (BrepModel.mesh); B-rep models only, under a uniform-scale placement.
    ## `quick` lets a copy with moved cvs answer with its quick preview (a
    ## drag's frames; brep/quick.lucb).
    pub func tessellate(segments: 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")
        if segments < 1 or segments > 64:
            error(invalid, "CAD tessellation segments must be 1..64")
        if self.face_count() == 0:
            error(invalid, "CAD model has no faces")
        let analysis = curvature or directions
        if analysis and self.count != 0:
            error(invalid, "curvature attributes require B-rep topology")
        # The common STEP path needs no second mesh rebuild, recoloring, BVH or
        # normal generation. Placement is applied only when nonidentity.
        if self.count == 0:
            if let boundary = self.boundary:
                let part = try boundary.value().mesh(segments, edge_size, progress, curvature, directions, quick)
                defer part.release()
                # An identity placement shares the mesh as it is.
                if self.placement.is_identity(): return part.clone()
                let placed = try part.value().placed(self.placement)
                if not analysis or self.placement.is_identity(): return placed
                defer placed.release()
                return try scaled_curvature(placed, self.placement, directions)
        # `cad_face` numbers faces as face_count() does: independent faces
        # first, then the B-rep's (after `count`).
        var output = try MeshBuilder()
        defer output.close()
        # The B-rep's polygon colors (white for the independent faces).
        var colors = Growing[f64]()
        defer colors.close()
        var has_colors = false
        # The B-rep's mesh, kept for its notes of faces left out.
        var notes: interop.Reference[Mesh]? = none
        defer:
            if let held = notes: held.release()
        if let boundary = self.boundary:
            let part = try boundary.value().mesh(segments, edge_size, progress)
            notes = part
            for point in 0..<part.value().point_count():
                _ = try output.point(self.placement.transform_point(try part.value().point(point)))
            let reversed = self.placement.determinant() < 0.0
            let groups = part.value().find_attribute("cad_face", 2)
            let cd = part.value().find_attribute("Cd", 2)
            has_colors = cd >= 0
            for face in 0..<part.value().face_count():
                let count = try part.value().face_size(face)
                if cd >= 0:
                    for component in 0..<3:
                        try colors.push(try part.value().attribute_value(cd, face, component))
                try output.face(count, (i64)self.count + (i64)(try part.value().attribute_value(groups, face, 0)))
                for corner in 0..<count:
                    try output.corner(try part.value().face_point(face, count - 1 - corner if reversed else corner))
        for face_id in 0..<self.count:
            let entry = self.faces[face_id]
            if entry.nu == 0 and edge_size == 0.0:
                try output.face((i64)entry.points.length, (i64)face_id)
                for point in entry.points:
                    try output.corner(try output.point(point))
                continue
            var resolution = segments
            if entry.nu > 0 and edge_size > 0.0:
                var span: f64 = 0.0
                for point in entry.points:
                    span = math.max(span, point.subtract(entry.points[0]).length())
                let needed = math.ceil(span / edge_size)
                if needed > 64.0:
                    error(invalid, "edge size exceeds independent NURBS grid budget; increase it")
                resolution = (i64)math.max((f64)segments, needed)
            let part = try planar_grid(entry.points, edge_size) if entry.nu == 0 else (try nurbs_grid(entry.points, entry.weights, entry.nu, entry.nv, entry.du, entry.dv, entry.ku, entry.kv, entry.u0, entry.u1, entry.v0, entry.v1, resolution))
            defer part.release()
            let offset = (i64)output.np
            for point in 0..<part.value().point_count():
                _ = try output.point(try part.value().point(point))
            for face in 0..<part.value().face_count():
                let count = try part.value().face_size(face)
                try output.face(count, (i64)face_id)
                for corner in 0..<count:
                    try output.corner(offset + (try part.value().face_point(face, count - 1 - corner if entry.reversed else corner)))
        let raw = try output.finish()
        defer raw.release()
        for index in 0..<output.nf:
            if output.face_parents[index] < 0:
                output.face_parents[index] = self.face_count() + (i64)index
        let values = try new f64[output.nf] --- in memory.heap
        defer free(values) in memory.heap
        for index in 0..<output.nf:
            values[index] = (f64)output.face_parents[index]
        let tagged = try raw.value().with_attribute("cad_face", 2, 1, values, true)
        defer tagged.release()
        if has_colors:
            try colors.extend(output.nf * 3, 1.0)
            let colored = try tagged.value().with_attribute("Cd", 2, 3, colors.view())
            defer colored.release()
            return try with_notes_of(try MeshNormals.generate(colored, output.face_parents[..<output.nf]), notes)
        return try with_notes_of(try MeshNormals.generate(tagged, output.face_parents[..<output.nf]), notes)

## Takes `made`: with the B-rep mesh `part`'s notes of faces it left out
## (.cad_dropped_faces, .cad_skipped_faces: brep_mesh's with_notes), which
## a mesh rebuilt from its polygons would otherwise lose.
func with_notes_of(made: interop.Reference[Mesh], part: interop.Reference[Mesh]?) -> interop.Reference[Mesh]!:
    let source = part else return made
    var current = made
    errdefer current.release()
    for name in [".cad_dropped_faces", ".cad_skipped_faces"]:
        let index = source.value().find_attribute(name, (i64)(u8)Domain.detail)
        if index < 0: continue
        let next = try current.value().with_attribute_entry(try (try source.value().attribute_entry(index)).renamed(name))
        current.release()
        current = next
    return current

## Curvature under a similarity placement: a uniform scale s divides it by s
## (a reflection keeps it, as corners reverse to keep normals outward), and
## directions turn with the placement.
func scaled_curvature(mesh: interop.Reference[Mesh], matrix: Matrix4, directions: bool) -> interop.Reference[Mesh]!:
    let scale = matrix.x.length()
    let tolerance = scale * 1e-9
    if math.abs(matrix.y.length() - scale) > tolerance or math.abs(matrix.z.length() - scale) > tolerance or math.abs(matrix.x.dot(matrix.y)) > tolerance * scale or math.abs(matrix.y.dot(matrix.z)) > tolerance * scale or math.abs(matrix.x.dot(matrix.z)) > tolerance * scale:
        error(invalid, "curvature analysis needs a uniform-scale CAD placement")
    let corners = (usize)mesh.value().vertex_count()
    let values = try new f64[corners * 3] --- in memory.heap
    defer free(values) in memory.heap
    var current = mesh.clone()
    defer current.release()
    for name in ["curvature.k1", "curvature.k2"]:
        let index = current.value().find_attribute(name, 1)
        if index < 0: continue
        for corner in 0..<corners: values[corner] = (try current.value().attribute_value(index, (i64)corner)) / scale
        let next = try current.value().with_attribute(name, 1, 1, values[..<corners], false, true)
        current.release()
        current = next
    for name in ["curvature.d1", "curvature.d2"]:
        let index = current.value().find_attribute(name, 1)
        if index < 0 or not directions: continue
        for corner in 0..<corners:
            let d = Vector3(try current.value().attribute_value(index, (i64)corner, 0), try current.value().attribute_value(index, (i64)corner, 1), try current.value().attribute_value(index, (i64)corner, 2))
            let turned = matrix.transform_direction(d).multiply_scalar(1.0 / scale)
            values[corner * 3] = turned.x
            values[corner * 3 + 1] = turned.y
            values[corner * 3 + 2] = turned.z
        let next = try current.value().with_attribute(name, 1, 3, values, false, true)
        current.release()
        current = next
    return current.clone()

struct PreviewJob:
    let model: const CadModel*
    let topology: BrepModel*?
    ## The B-rep's seams (overlay.lucb's seam_edges): not drawn.
    let seams: Bits

## One face's preview on a pool worker, as luced-3d's per-patch preview did:
## 8 divisions for faces with many edges, else 16; then 4; then 16 again.
func make_preview_part(raw: void*?, face: usize, part: PreviewPart*):
    let job = (PreviewJob*)(raw else return)
    let index = (i64)face
    # Boundary sampling errors stopped the whole serial preview; they stay fatal.
    fill_boundaries(job, index, part) catch failure:
        part.fatal(failure.message)
        return
    let edges = job.model.edge_count_in(job.topology, index) catch failure:
        part.fatal(failure.message)
        return
    let mesh = fallback_preview(job, index, 8 if edges > 32 else 16) catch failure:
        part.fail(failure.message)
        return
    defer mesh.release()
    part.adopt(mesh) catch failure: part.fail(failure.message)

func fallback_preview(job: PreviewJob*, index: i64, divisions: i64) -> interop.Reference[Mesh]!:
    let first = job.model.preview_in(job.topology, index, divisions) catch failure:
        let coarse = job.model.preview_in(job.topology, index, 4) catch coarse_failure:
            return try job.model.preview_in(job.topology, index, 16)
        return coarse
    return first

## Each edge use's analytic polyline (64 chords when curved, as the display's
## full-circle resolution: a coarse chord sinks into the shaded mesh).
func fill_boundaries(job: PreviewJob*, face: i64, part: PreviewPart*) -> !:
    let model = job.model
    let uses = try model.edge_count_in(job.topology, face)
    try part.open_boundaries((usize)uses)
    for use in 0..<uses:
        let divisions = 1 if (try model.edge_linear_in(job.topology, face, use)) else 64
        let id = try model.edge_id_in(job.topology, face, use)
        try part.begin_use(id)
        # A seam keeps its use, with no line.
        if id >= 0 and (usize)id < job.seams.count and job.seams.get((usize)id): continue
        for step in 0..<divisions + 1:
            try part.boundary_point(try model.edge_point_in(job.topology, face, use, (f64)step / (f64)divisions))

func planar_mesh(points: const Vector3[]) -> interop.Reference[Mesh]!:
    var builder = try MeshBuilder()
    defer builder.close()
    try builder.face((i64)points.length)
    for point in points:
        try builder.corner(try builder.point(point))
    return try builder.finish()