Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / src / cad_sketches.lucb

## Sketches as objects of a geometry set: Fusion's sketches in direct
## modeling ("Do not capture design history"), which stay in the design as
## objects beside its bodies. A set's sketch component holds named sketches,
## each its CadSketch text, its plane (an origin and the sketch's x and y
## directions) and whether it shows. luced-3d's Edit CAD makes and edits
## them as recipe steps; Extrude and Revolve steps read a sketch's curves
## from them. The component places with the set (planes move, sketches keep
## their own coordinates), joins, filters by name as an object path, and is
## saved in geometry files (element `cad_sketches`, one child per sketch).
import interop
import memory
from luce_geocore.geocore import Vector3, Matrix4, Bounds, invalid, GeometrySet
from luce_geocore.core.growing import Growing
import ownership
from luce_geocore.kernel import ComponentType, Placement, IdSet, TableBuilder, PathFilter
from luce_geocore.kernel import adopt_set, dispose_set, empty_set, append_text, append_number
from luce_geocore.kernel import register_codec, GeometryWriter, GeometryReader
from geometry import push_decimal

## One sketch: its name (unique in the set), CadSketch text and plane.
struct SketchEntry:
    var name: Growing[u8]
    var text: Growing[u8]
    var origin: Vector3
    var u: Vector3
    var v: Vector3
    var visible: bool

    func close():
        self.name.close()
        self.text.close()

## A set's sketches: immutable once published; each owner has its own copy
## (the texts are small).
pub struct SketchList:
    var entries: Growing[SketchEntry]

    func add(name: str, text: str, origin: Vector3, u: Vector3, v: Vector3, visible: bool) -> !:
        var entry = SketchEntry(Growing[u8](), Growing[u8](), origin, u, v, visible)
        entry.name.assign(name.bytes) catch failure:
            entry.close()
            error(failure.code, failure.message)
        entry.text.assign(text.bytes) catch failure:
            entry.close()
            error(failure.code, failure.message)
        self.entries.push(entry) catch failure:
            entry.close()
            error(failure.code, failure.message)

    func add_entry(entry: const SketchEntry*) -> !:
        try self.add((str)entry.name.view(), (str)entry.text.view(), entry.origin, entry.u, entry.v, entry.visible)

    ## The index of sketch `name`, or none.
    func find(name: str) -> usize?:
        for at in 0..<self.entries.count:
            if (str)self.entries.items[at].name.view() == name: return at
        return none

func new_list() -> SketchList*!:
    let storage = try new SketchList[1] --- in memory.heap
    storage[0].entries = Growing[SketchEntry]()
    return storage.data

pub let sketch_component: ComponentType = ComponentType("cad_sketches", share_list, close_list, list_size, list_bytes, list_bounds, place_list, join_lists, list_paths, filter_list, describe_list,
                                                        "", trace_nothing)

## Sketches hold no Luce objects.
func trace_nothing(data: const void*, visit: func(ownership.Object*, void*) -> unit, context: void*):
    _ = data
    _ = visit
    _ = context

func share_list(data: const void*) -> void*!:
    let copy = try new_list()
    errdefer close_list((void*)copy)
    for entry in ((const SketchList*)data).entries.view(): try copy.add_entry(&entry)
    return (void*)copy

func close_list(data: void*):
    let list = (SketchList*)data
    for at in 0..<list.entries.count: list.entries.items[at].close()
    list.entries.close()
    free(SketchList[](list, 1)) in memory.heap

func list_size(data: const void*) -> usize:
    return ((const SketchList*)data).entries.count

func list_bytes(data: const void*, ids: IdSet*) -> usize!:
    _ = ids
    var total: usize = 64
    for entry in ((const SketchList*)data).entries.view(): total += entry.name.count + entry.text.count + 80
    return total

## A sketch has no surface to frame; the viewport frames the bodies.
func list_bounds(data: const void*, matrix: Matrix4, out: Bounds*) -> bool!:
    _ = data
    _ = matrix
    _ = out
    return false

## Each plane placed: its origin moved, its axes turned (and kept unit
## length, so the sketch keeps its own sizes).
func place_list(data: const void*, placement: const Placement*) -> void*!:
    let placed = try new_list()
    errdefer close_list((void*)placed)
    for entry in ((const SketchList*)data).entries.view():
        let origin = placement.matrix.transform_point(entry.origin)
        let u = (try placement.matrix.transform_direction(entry.u).normalized())
        let v = (try placement.matrix.transform_direction(entry.v).normalized())
        try placed.add((str)entry.name.view(), (str)entry.text.view(), origin, u, v, entry.visible)
    return (void*)placed

func join_lists(first: const void*, second: const void*) -> void*!:
    let joined = try new_list()
    errdefer close_list((void*)joined)
    for entry in ((const SketchList*)first).entries.view(): try joined.add_entry(&entry)
    for entry in ((const SketchList*)second).entries.view(): try joined.add_entry(&entry)
    return (void*)joined

## Sketch names are their object paths.
func list_paths(data: const void*, out: TableBuilder*) -> !:
    for entry in ((const SketchList*)data).entries.view():
        if entry.name.count > 0: _ = try out.intern((str)entry.name.view())

func filter_list(data: const void*, filter: const PathFilter*, keep: bool) -> void*!:
    let filtered = try new_list()
    errdefer close_list((void*)filtered)
    for entry in ((const SketchList*)data).entries.view():
        let selected = filter.is_empty() or filter.matches((str)entry.name.view())
        if selected == keep: try filtered.add_entry(&entry)
    return (void*)filtered

func describe_list(data: const void*, out: Growing[u8]*) -> !:
    let count = ((const SketchList*)data).entries.count
    try append_number(out, count)
    try append_text(out, " sketch" if count == 1 else " sketches")

## Geometry files: element `cad_sketches` with a child `s<i>` per sketch
## holding its name, text, plane and visibility.
func encode_list(data: const void*, writer: GeometryWriter*, path: str) -> !:
    let list = (const SketchList*)data
    try writer.crate.element(path, "cad_sketches")
    try writer.crate.integer("count", (i64)list.entries.count)
    var base = Growing[u8]()
    defer base.close()
    try base.assign(path.bytes)
    var name = Growing[u8]()
    defer name.close()
    for index in 0..<list.entries.count:
        let entry = &list.entries.items[index]
        try name.assign("s".bytes)
        try push_decimal(&name, (i64)index)
        try writer.crate.element(try writer.child((str)base.view(), (str)name.view()), "cad_sketch")
        try writer.crate.text("name", (str)entry.name.view())
        try writer.crate.text("text", (str)entry.text.view())
        try writer.crate.triple("origin", entry.origin.x, entry.origin.y, entry.origin.z)
        try writer.crate.triple("u", entry.u.x, entry.u.y, entry.u.z)
        try writer.crate.triple("v", entry.v.x, entry.v.y, entry.v.z)
        try writer.crate.integer("visible", 1 if entry.visible else 0)

func decode_list(reader: GeometryReader*, path: str) -> void*!:
    let list = try new_list()
    errdefer close_list((void*)list)
    var base = Growing[u8]()
    defer base.close()
    try base.assign(path.bytes)
    while let header = try reader.next_property(): _ = header
    var name = Growing[u8]()
    defer name.close()
    var text = Growing[u8]()
    defer text.close()
    while let child = try reader.next_child((str)base.view()):
        _ = child
        name.clear()
        text.clear()
        var origin = Vector3()
        var u = Vector3(1.0, 0.0, 0.0)
        var v = Vector3(0.0, 1.0, 0.0)
        var visible = true
        while let header = try reader.next_property():
            if header.name == "name": try reader.text(header, &name)
            elif header.name == "text": try reader.text(header, &text)
            elif header.name == "origin": origin = try reader.triple(header)
            elif header.name == "u": u = try reader.triple(header)
            elif header.name == "v": v = try reader.triple(header)
            elif header.name == "visible": visible = (try reader.integer(header)) != 0
        try list.add((str)name.view(), (str)text.view(), origin, u, v, visible)
    return (void*)list

## The set's sketch list; none without sketches.
func list_of(set: const GeometrySet*) -> const SketchList*?:
    let data = set.find(&sketch_component) else return none
    return (const SketchList*)data

## The sketch at `index` of `set`, or an error.
func entry_at(set: interop.Reference[GeometrySet], index: i64) -> const SketchEntry*!:
    let list = list_of(try set.get()) else error(invalid, "the geometry has no sketches")
    if index < 0 or (usize)index >= list.entries.count: error(invalid, "sketch index out of range")
    return &list.entries.items[(usize)index]

## `set` with `list` as its sketches (none when it is empty, which is
## closed); every other component shared.
func with_list(set: const GeometrySet*, list: SketchList*) -> interop.Reference[GeometrySet]!:
    let result = set.storage() catch failure:
        close_list((void*)list)
        error(failure.code, failure.message)
    result.remove(&sketch_component)
    if list.entries.count == 0:
        close_list((void*)list)
    else:
        result.put(&sketch_component, (void*)list) catch failure:
            close_list((void*)list)
            dispose_set(result)
            error(failure.code, failure.message)
    return try adopt_set(result)

## Luce's view of a set's sketches.
pub struct CadSketches:
    let reserved: u8 = 0

    ## Register the sketches' codec with geocore's geometry files (once, at
    ## startup; CadGeometry.register_codec does it with the models').
    pub static func register_codec() -> i64!:
        try register_codec(&sketch_component, encode_list, decode_list)
        return 0

    ## How many sketches `set` holds.
    pub static func count(set: interop.Reference[GeometrySet]) -> i64!:
        let list = list_of(try set.get()) else return 0
        return (i64)list.entries.count

    ## The index of the sketch named `name`, or -1.
    pub static func find(set: interop.Reference[GeometrySet], name: str) -> i64!:
        let list = list_of(try set.get()) else return -1
        let at = list.find(name) else return -1
        return (i64)at

    pub static func name(set: interop.Reference[GeometrySet], index: i64) -> interop.Owned[str]!:
        return try interop.copy_text((str)(try entry_at(set, index)).name.view())

    ## Its CadSketch text.
    pub static func text(set: interop.Reference[GeometrySet], index: i64) -> interop.Owned[str]!:
        return try interop.copy_text((str)(try entry_at(set, index)).text.view())

    ## Its plane: the origin, and the sketch's x and y directions.
    pub static func origin(set: interop.Reference[GeometrySet], index: i64) -> Vector3!:
        return (try entry_at(set, index)).origin

    pub static func u(set: interop.Reference[GeometrySet], index: i64) -> Vector3!:
        return (try entry_at(set, index)).u

    pub static func v(set: interop.Reference[GeometrySet], index: i64) -> Vector3!:
        return (try entry_at(set, index)).v

    pub static func visible(set: interop.Reference[GeometrySet], index: i64) -> bool!:
        return (try entry_at(set, index)).visible

    ## `set` with sketch `name` holding `text` on the plane through
    ## `origin` along `u` and `v`: the one of that name replaced in place,
    ## else a new one after the others.
    pub static func with_sketch(set: interop.Reference[GeometrySet], name: str, text: str, origin: Vector3, u: Vector3, v: Vector3, visible: bool = true) -> interop.Reference[GeometrySet]!:
        if name == "": error(invalid, "a sketch needs a name")
        if not origin.is_finite() or not u.is_finite() or not v.is_finite(): error(invalid, "a sketch's plane must be finite")
        let source = try set.get()
        let list = try new_list()
        var replaced = false
        if let existing = list_of(source):
            for entry in existing.entries.view():
                if (str)entry.name.view() == name:
                    list.add(name, text, origin, u, v, visible) catch failure:
                        close_list((void*)list)
                        error(failure.code, failure.message)
                    replaced = true
                    continue
                list.add_entry(&entry) catch failure:
                    close_list((void*)list)
                    error(failure.code, failure.message)
        if not replaced:
            list.add(name, text, origin, u, v, visible) catch failure:
                close_list((void*)list)
                error(failure.code, failure.message)
        return try with_list(source, list)

    ## `set` with sketch `name` shown or hidden (an error when it has none).
    pub static func with_visible(set: interop.Reference[GeometrySet], name: str, visible: bool) -> interop.Reference[GeometrySet]!:
        let index = try CadSketches.find(set, name)
        if index < 0: error(invalid, "the sketch is not in the model")
        let entry = try entry_at(set, index)
        return try CadSketches.with_sketch(set, name, (str)entry.text.view(), entry.origin, entry.u, entry.v, visible)

    ## `set` without sketch `name` (the same set when it has none).
    pub static func without_sketch(set: interop.Reference[GeometrySet], name: str) -> interop.Reference[GeometrySet]!:
        let source = try set.get()
        let existing = list_of(source) else return set.clone()
        let list = try new_list()
        for entry in existing.entries.view():
            if (str)entry.name.view() == name: continue
            list.add_entry(&entry) catch failure:
                close_list((void*)list)
                error(failure.code, failure.message)
        return try with_list(source, list)

    ## `set` without any sketches.
    pub static func without_sketches(set: interop.Reference[GeometrySet]) -> interop.Reference[GeometrySet]!:
        let source = try set.get()
        if list_of(source) == none: return set.clone()
        let result = try source.storage()
        result.remove(&sketch_component)
        return try adopt_set(result)