Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.5

0.9.5 / src / cad_geometry.lucb

## CAD models as a family of geocore's geometry sets. A set's CAD component
## holds analytic models (shared, never copied); it places, joins and
## filters by object path like any family, and tessellation turns it into
## the set's mesh, each face carrying its B-rep path in the `path` text
## attribute. Luce reaches all of it through the static methods of
## `CadGeometry`.
import interop
import memory
import ownership
from luce_geocore.geocore import Mesh, Vector3, Matrix4, Bounds, invalid, GeometrySet
from luce_geocore.core.growing import Growing
from luce_geocore.kernel import ComponentType, Placement, IdSet, TableBuilder, PathFilter, MeshPart, Domain, Attribute, Instances
from luce_geocore.kernel import adopt_set, dispose_set, empty_set, set_mesh, append_text, append_number, mesh_component, instances_component, new_instances, concatenated, text_attribute, mesh_share
from model import CadModel, MeshQuality, cad_model_type, encode_model, decode_model, cloud_mesh, is_cloud, moved_models
from geometry import push_decimal
from cad_sketches import CadSketches
from cad_curves import CadCurves, curve_cloud, moved_curves
from cad_trims import register_trims
from luce_geocore.kernel import register_codec, GeometryWriter, GeometryReader

## The models of one set: immutable once published; every owning set has
## its own list of references (see share_parts).
pub struct CadParts:
    var models: Growing[interop.Reference[CadModel]]

    pub func count() -> usize:
        return self.models.count

    pub func faces() -> usize:
        var total: usize = 0
        for model in self.models.view(): total += (usize)model.value().face_count()
        return total

    ## Add another owner of `model`.
    pub func add(model: interop.Reference[CadModel]) -> !:
        let owner = model.clone()
        self.models.push(owner) catch failure:
            owner.release()
            error(failure.code, failure.message)

func new_parts() -> CadParts*!:
    let storage = try new CadParts[1] --- in memory.heap
    storage[0].models = Growing[interop.Reference[CadModel]]()
    return storage.data

pub let cad_component: ComponentType = ComponentType("cad", share_parts, close_parts, parts_size, parts_bytes, parts_bounds, place_parts, join_parts, parts_paths, filter_parts, describe_parts,
                                                     "This operation requires polygons; connect a Tessellate node first", trace_parts)

## Another owner: a new list holding its own reference to every model. The
## list is not shared by count, because each owning set traces its models:
## every strong reference a trace visits must be owned exactly once by the
## traced owner, or the cycle collector subtracts one edge per sharer from a
## single reference and traps. O(models).
func share_parts(data: const void*) -> void*!:
    let copy = try new_parts()
    errdefer close_parts((void*)copy)
    for model in ((const CadParts*)data).models.view(): try copy.add(model)
    return (void*)copy

func close_parts(data: void*):
    let parts = (CadParts*)data
    for model in parts.models.view(): model.release()
    parts.models.close()
    free(CadParts[](parts, 1)) in memory.heap

func parts_size(data: const void*) -> usize:
    return ((const CadParts*)data).faces()

## Analytic data is not columnar yet: a model is charged once, by identity,
## at a nominal 16 KiB a face.
func parts_bytes(data: const void*, ids: IdSet*) -> usize!:
    var total: usize = 64
    for model in ((const CadParts*)data).models.view():
        total += try ids.charge((u64)(usize)model.value(), (usize)model.value().face_count() * 16384)
    return total

## Analytic bounds need a preview; the viewport frames CAD by its preview.
func parts_bounds(data: const void*, matrix: Matrix4, out: Bounds*) -> bool!:
    _ = data
    _ = matrix
    _ = out
    return false

func place_parts(data: const void*, placement: const Placement*) -> void*!:
    let placed = try new_parts()
    errdefer close_parts((void*)placed)
    for model in ((const CadParts*)data).models.view():
        let moved = try model.value().transformed(placement.translation, placement.rotation, placement.scale)
        defer moved.release()
        try placed.add(moved)
    return (void*)placed

func join_parts(first: const void*, second: const void*) -> void*!:
    let joined = try new_parts()
    errdefer close_parts((void*)joined)
    for model in ((const CadParts*)first).models.view(): try joined.add(model)
    for model in ((const CadParts*)second).models.view(): try joined.add(model)
    return (void*)joined

func parts_paths(data: const void*, out: TableBuilder*) -> !:
    for model in ((const CadParts*)data).models.view():
        let value = model.value()
        for face in 0..<value.face_count():
            let path = try value.face_path(face)
            if path != "": _ = try out.intern(path)

## Each model keeps the faces whose path the filter matches (or loses them);
## a model left with no faces is dropped, one left whole is shared.
func filter_parts(data: const void*, filter: const PathFilter*, keep: bool) -> void*!:
    let filtered = try new_parts()
    errdefer close_parts((void*)filtered)
    var retained = Growing[i64]()
    defer retained.close()
    for model in ((const CadParts*)data).models.view():
        let value = model.value()
        let count = value.face_count()
        retained.clear()
        for face in 0..<count:
            let selected = filter.matches(try value.face_path(face)) if not filter.is_empty() else true
            let path_known = filter.is_empty() or (try value.face_path(face)) != ""
            if (selected and path_known) == keep: try retained.push(face)
        if retained.count == 0: continue
        if (i64)retained.count == count:
            try filtered.add(model)
            continue
        let subset = try value.subset(retained.view())
        defer subset.release()
        try filtered.add(subset)
    return (void*)filtered

func describe_parts(data: const void*, out: Growing[u8]*) -> !:
    try append_number(out, ((const CadParts*)data).faces())
    try append_text(out, " CAD surfaces")

func trace_parts(data: const void*, visit: func(ownership.Object*, void*) -> unit, context: void*):
    for model in ((const CadParts*)data).models.view(): model.trace(visit, context)

func detail_count(mesh: const Mesh*, name: str) -> i64!:
    let index = mesh.find_attribute(name, (i64)(u8)Domain.detail)
    return (i64)(try mesh.attribute_value(index, 0)) if index >= 0 else 0

## A tessellation's skipped-face lines (brep_mesh.with_notes).
func skipped_text(mesh: const Mesh*) -> str!:
    let index = mesh.find_attribute(".cad_skipped_faces", (i64)(u8)Domain.detail)
    if index < 0: return ""
    return (try mesh.attribute_entry(index)).text_at(0)

## `mesh` joined from several models' tessellations (`parts`), with their
## dropped-face counts summed and skipped-face lines joined (a joined
## detail attribute keeps only the first part's).
func with_joined_notes(mesh: interop.Reference[Mesh], parts: const interop.Reference[Mesh][]) -> interop.Reference[Mesh]!:
    var dropped: i64 = 0
    var lines = Growing[u8]()
    defer lines.close()
    for part in parts:
        dropped += try detail_count(part.value(), ".cad_dropped_faces")
        try append_text(&lines, try skipped_text(part.value()))
    if dropped == 0 and lines.count == 0: return mesh.clone()
    var value: f64[1] = [(f64)dropped]
    let counted = try mesh.value().with_attribute(".cad_dropped_faces", 3, 1, value[..<1], true)
    if lines.count == 0: return counted
    defer counted.release()
    var strings = TableBuilder()
    defer strings.close()
    var index: i32[1] = [try strings.intern((str)lines.view())]
    return try counted.value().with_attribute_entry(try text_attribute(".cad_skipped_faces", Domain.detail, 1, &strings, index[..<1]))

## The CAD family in geometry files: element `cad` holding one `cad_model`
## child per model (m0, m1, …; luce_cad.model's codec).
func encode_parts(data: const void*, writer: GeometryWriter*, path: str) -> !:
    let parts = (const CadParts*)data
    try writer.crate.element(path, "cad")
    try writer.crate.integer("count", (i64)parts.models.count)
    var base = Growing[u8]()
    defer base.close()
    try base.assign(path.bytes)
    var name = Growing[u8]()
    defer name.close()
    for index in 0..<parts.models.count:
        try name.assign("m".bytes)
        try push_decimal(&name, (i64)index)
        try encode_model(parts.models.items[index].value(), writer, try writer.child((str)base.view(), (str)name.view()))

func decode_parts(reader: GeometryReader*, path: str) -> void*!:
    let parts = try new_parts()
    errdefer close_parts((void*)parts)
    var base = Growing[u8]()
    defer base.close()
    try base.assign(path.bytes)
    while let header = try reader.next_property(): _ = header
    while let child = try reader.next_child((str)base.view()):
        let model = try decode_model(reader, child.0)
        defer model.release()
        try parts.add(model)
    return (void*)parts

## The set's own models (Base editors: cad_edits.lucb); none without CAD.
pub func set_models(set: const GeometrySet*) -> const interop.Reference[CadModel][]:
    let data = set.find(&cad_component) else return empty_models()
    return ((const CadParts*)data).models.view()

func empty_models() -> const interop.Reference[CadModel][]:
    var none_held: interop.Reference[CadModel][]
    return none_held

## `set` with `models` in place of its CAD models (without CAD when there
## are none); every other component shared.
pub func with_models(set: const GeometrySet*, models: const interop.Reference[CadModel][]) -> interop.Reference[GeometrySet]!:
    let result = try set.storage()
    result.remove(&cad_component)
    if models.length > 0:
        let parts = new_parts() catch failure:
            dispose_set(result)
            error(failure.code, failure.message)
        for model in models:
            parts.add(model) catch failure:
                close_parts((void*)parts)
                dispose_set(result)
                error(failure.code, failure.message)
        result.put(&cad_component, (void*)parts) catch failure:
            close_parts((void*)parts)
            dispose_set(result)
            error(failure.code, failure.message)
    return try adopt_set(result)

## `models` put into `set`, a set being built (an importer's), as its CAD
## component; nothing when there are none.
pub func put_models(set: GeometrySet*, models: const interop.Reference[CadModel][]) -> !:
    if models.length == 0: return
    let parts = try new_parts()
    for model in models:
        parts.add(model) catch failure:
            close_parts((void*)parts)
            error(failure.code, failure.message)
    set.put(&cad_component, (void*)parts) catch failure:
        close_parts((void*)parts)
        error(failure.code, failure.message)

## Luce's view of the CAD family of a geometry set.
pub struct CadGeometry:
    let reserved: u8 = 0

    ## Register the CAD family's codec with geocore's geometry files (once,
    ## at startup, before CAD is saved or loaded; again is harmless).
    pub static func register_codec() -> i64!:
        try register_codec(&cad_component, encode_parts, decode_parts)
        _ = try CadSketches.register_codec()
        _ = try CadCurves.register_codec()
        try register_trims()
        return 0

    ## A set holding `model`.
    pub static func of_model(model: interop.Reference[CadModel]) -> interop.Reference[GeometrySet]!:
        let parts = try new_parts()
        parts.add(model) catch failure:
            close_parts((void*)parts)
            error(failure.code, failure.message)
        let storage = empty_set() catch failure:
            close_parts((void*)parts)
            error(failure.code, failure.message)
        storage.put(&cad_component, (void*)parts) catch failure:
            dispose_set(storage)
            error(failure.code, failure.message)
        return try adopt_set(storage)

    ## The set's CAD models (not its instances').
    pub static func model_count(set: interop.Reference[GeometrySet]) -> i64!:
        let data = (try set.get()).find(&cad_component) else return 0
        return (i64)((const CadParts*)data).count()

    pub static func model(set: interop.Reference[GeometrySet], index: i64) -> interop.Reference[CadModel]!:
        let data = (try set.get()).find(&cad_component) else error(invalid, "the geometry has no CAD models")
        let parts = (const CadParts*)data
        if index < 0 or (usize)index >= parts.count(): error(invalid, "CAD model index out of range")
        return parts.models.items[(usize)index].clone()

    ## The set's own models' control vertices, then its curves' (cad_curves'
    ## curve_cloud), as a point cloud (placed; no faces), which point verbs
    ## edit (cv_cloud.lucb).
    pub static func cv_cloud(set: interop.Reference[GeometrySet]) -> interop.Reference[Mesh]!:
        let source = try set.get()
        let models = set_models(source)
        if models.length == 0 and (try CadCurves.count(set)) == 0: error(invalid, "the geometry has no CAD models or curves")
        var points = Growing[Vector3]()
        defer points.close()
        var places = Growing[f64]()
        defer places.close()
        var frames = Growing[Vector3]()
        defer frames.close()
        try curve_cloud(source, models, &points, &places, &frames)
        return try cloud_mesh(models, points.view(), places.view(), frames.view())

    pub static func is_cv_cloud(mesh: interop.Reference[Mesh]) -> bool!:
        return is_cloud(try mesh.get())

    ## The set with the cvs `after` moved relative to `before` (its clouds):
    ## its models', then its curves'.
    pub static func with_cv_cloud(set: interop.Reference[GeometrySet], before: interop.Reference[Mesh], after: interop.Reference[Mesh]) -> interop.Reference[GeometrySet]!:
        let source = try set.get()
        let parts = try new_parts()
        let result = source.storage() catch failure:
            close_parts((void*)parts)
            error(failure.code, failure.message)
        let first = moved_models(set_models(source), try before.get(), try after.get(), &parts.models) catch failure:
            close_parts((void*)parts)
            dispose_set(result)
            error(failure.code, failure.message)
        result.remove(&cad_component)
        if parts.models.count > 0:
            result.put(&cad_component, (void*)parts) catch failure:
                close_parts((void*)parts)
                dispose_set(result)
                error(failure.code, failure.message)
        else:
            close_parts((void*)parts)
        let moved = try adopt_set(result)
        defer moved.release()
        # The curves on faces lie on the moved models' faces.
        let curved = try moved_curves(try moved.get(), set_models(try moved.get()), try before.get(), try after.get(), first)
        return curved

    ## Faces of a CAD tessellation left out because their moved control
    ## vertices pulled their trims into a shape that no longer meshes.
    pub static func dropped_faces(mesh: interop.Reference[Mesh]) -> i64!:
        return try detail_count(try mesh.get(), ".cad_dropped_faces")

    ## Faces of a CAD tessellation left out because no mesher could follow
    ## them: one "Skipped CAD face i: reason" line each ("" when none were).
    pub static func skipped_faces(mesh: interop.Reference[Mesh]) -> interop.Owned[str]!:
        return try interop.copy_text(try skipped_text(try mesh.get()))

    ## Analytic faces of the set's own CAD models.
    pub static func face_count(set: interop.Reference[GeometrySet]) -> i64!:
        let data = (try set.get()).find(&cad_component) else return 0
        return (i64)((const CadParts*)data).faces()

    ## The set with its CAD models tessellated into its mesh, instances
    ## included. Each face's `path` text attribute names its B-rep face's
    ## path; principal curvatures ride along where the model supports them.
    ## Every model, an instance's prototype's too, is meshed at `quality`
    ## (its angle, chord height and longest edge; MeshQuality).
    pub static func tessellated(set: interop.Reference[GeometrySet], quality: MeshQuality, progress: interop.Callback[f64, unit]? = none) -> interop.Reference[GeometrySet]!:
        try quality.checked()
        return try adopt_set(try tessellated_storage(try set.get(), quality, progress, 0))

func tessellated_storage(set: const GeometrySet*, quality: MeshQuality, progress: interop.Callback[f64, unit]?, depth: usize) -> GeometrySet*!:
    if depth > 64: error(invalid, "instances nest more than 64 deep")
    let result = try set.storage()
    errdefer dispose_set(result)
    if let data = set.find(&cad_component):
        let parts = (const CadParts*)data
        var owners = Growing[interop.Reference[Mesh]]()
        defer:
            for owner in owners.view(): owner.release()
            owners.close()
        var pieces = Growing[MeshPart]()
        defer pieces.close()
        if let existing = set_mesh(set): try pieces.push(MeshPart(existing, Matrix4()))
        for model in parts.models.view():
            let owner = try tessellate_with_paths(model.value(), quality, progress)
            owners.push(owner) catch failure:
                owner.release()
                error(failure.code, failure.message)
            try pieces.push(MeshPart(owner.value(), Matrix4()))
        result.remove(&cad_component)
        # One model's tessellation is placed as it is: the set shares the
        # model's kept mesh (and the GPU buffers already made for it).
        if pieces.count == 1:
            try result.put(mesh_component(), (void*)(try mesh_share(pieces.items[0].mesh)))
        else:
            let joined = try concatenated(pieces.view())
            defer joined.release()
            let mesh = try with_joined_notes(joined, owners.view())
            defer mesh.release()
            try result.put(mesh_component(), (void*)(try mesh_share(mesh.value())))
    try tessellate_instances(result, quality, progress, depth)
    return result

## One model's tessellation with its faces' B-rep paths as `path` (a B-rep
## model's kept mesh has them already).
func tessellate_with_paths(model: const CadModel*, quality: MeshQuality, progress: interop.Callback[f64, unit]?) -> interop.Reference[Mesh]!:
    let part = try model.tessellated(quality, progress, model.supports_curvature())
    if part.value().find_attribute("path", 2) >= 0: return part
    defer part.release()
    let mesh = part.value()
    let source = mesh.find_attribute("cad_face", 2)
    var strings = TableBuilder()
    defer strings.close()
    let face_count = model.face_count()
    let face_paths = try new i32[(usize)face_count] --- in memory.heap
    defer free(face_paths) in memory.heap
    var any = false
    for face in 0..<face_count:
        let path = try model.face_path(face)
        face_paths[(usize)face] = (try strings.intern(path)) if path != "" else -1
        any = any or path != ""
    if not any or source < 0: return part.clone()
    let faces = (usize)mesh.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.attribute_value(source, (i64)face))
        values[face] = face_paths[(usize)original] if original >= 0 and original < face_count else -1
    let attribute = try text_attribute("path", Domain.face, faces, &strings, values)
    return try mesh.with_attribute_entry(attribute)

## The set's instances with each prototype tessellated once: every
## instance keeps its prototype index and placement.
func tessellate_instances(result: GeometrySet*, quality: MeshQuality, progress: interop.Callback[f64, unit]?, depth: usize) -> !:
    let data = result.find(instances_component()) else return
    let source = (const Instances*)data
    let rebuilt = try new_instances()
    let close = instances_component().close
    for index in 0..<source.prototype_count():
        let child = tessellated_storage(source.prototype(index), quality, progress, depth + 1) catch failure:
            close((void*)rebuilt)
            error(failure.code, failure.message)
        let slot = rebuilt.add_prototype(child) catch failure:
            close((void*)rebuilt)
            error(failure.code, failure.message)
        _ = slot
    for index in 0..<source.count():
        let row = source.row(index)
        let placement = Placement(row.translation, row.rotation, row.scale, Matrix4.compose(row.translation, row.rotation, row.scale))
        rebuilt.add_instance((usize)row.prototype, &placement, row.visible) catch failure:
            close((void*)rebuilt)
            error(failure.code, failure.message)
    result.put(instances_component(), (void*)rebuilt) catch failure:
        close((void*)rebuilt)
        error(failure.code, failure.message)