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)