Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / src / brep / quick.lucb

## The quick preview of a copy with moved cvs, for an interactive drag: its
## parent's kept tessellation with the moved surfaces' own points moved onto
## the new surfaces, in milliseconds instead of a full tessellation. A point
## of a moved face takes its parameters on the old surface (it lies on it)
## and moves to the new surface there; points the face shares with other
## faces (its edges' samples) stay, so the preview stays joined, as the full
## tessellation's re-projected trims do. The layout, the sampling and every
## other face are the parent's; releasing the drag tessellates in full.

## Where a copy's quick preview comes from: the parent's kept mesh for
## these parameters, and the surfaces whose cvs moved with their old cvs.
struct QuickSource:
    let divisions: i64
    let edge_size: f64
    let curvature: bool
    let directions: bool
    let base: interop.Reference[Mesh]
    var surfaces: Growing[i64]
    ## Old cvs of surfaces[i]: points[offsets[i]..<offsets[i + 1]].
    var offsets: Growing[usize]
    var points: Growing[Vector3]

    func close():
        self.base.release()
        self.surfaces.close()
        self.offsets.close()
        self.points.close()

func drop_quick(derived: Derived*):
    if let source = derived.quick:
        source.close()
        free(source) in memory.heap
        derived.quick = none
    if let result = derived.quick_result:
        result.release()
        derived.quick_result = none

extend BrepModel:
    ## Record in `copy` (made from this model with cvs `ids` moved) where its
    ## quick preview comes from: this model's newest kept mesh. Nothing when
    ## this model has none.
    func pass_quick(copy: BrepModel*, ids: const i64[]) -> !:
        let derived = self.derived
        derived.lock.lock()
        defer derived.lock.unlock()
        if derived.meshes.count == 0: return
        let kept = derived.meshes.items[derived.meshes.count - 1]
        let source = try new QuickSource(kept.divisions, kept.edge_size, kept.curvature, kept.directions, kept.mesh.clone(), Growing[i64](), Growing[usize](), Growing[Vector3]()) in memory.heap
        errdefer:
            source.close()
            free(source) in memory.heap
        for id in ids:
            let surface = try self.cv_surface(id)
            var known = false
            for entry in source.surfaces.view(): known = known or entry == surface
            if not known: try source.surfaces.push(surface)
        try source.offsets.push(0)
        for surface in source.surfaces.view():
            for point in self.cvs_of((usize)surface): try source.points.push(point)
            try source.offsets.push(source.points.count)
        let target = copy.derived
        target.lock.lock()
        defer target.lock.unlock()
        drop_quick(target)
        target.quick = source

    ## The quick preview for these parameters, or none (no source, or other
    ## parameters).
    func quick_mesh(divisions: i64, edge_size: f64, curvature: bool, directions: bool) -> interop.Reference[Mesh]?!:
        let derived = self.derived
        derived.lock.lock()
        defer derived.lock.unlock()
        let source = derived.quick else return none
        if source.divisions != divisions or source.edge_size != edge_size or source.curvature != curvature or source.directions != directions: return none
        if let made = derived.quick_result: return made.clone()
        let made = try self.quick_from(source)
        derived.quick_result = made.clone()
        return made

    func quick_from(source: const QuickSource*) -> interop.Reference[Mesh]!:
        let base = source.base.value()
        let owner = base.find_attribute("cad_face", 2)
        let shared = base.find_attribute(".cad_shared_points", 3)
        if owner < 0 or shared < 0: error(invalid, "a kept CAD tessellation lost its faces")
        let faces = try base.attribute_entry(owner)
        let first_own = (usize)(try base.attribute_value(shared, 0))
        let offsets = base.offset_span()
        let corners = base.corner_span()
        let polygons = offsets.length - 1
        let count = base.point_span().length
        # The moved faces; the faces' own points (after the shared ones) of
        # their polygons, which come in face order, move.
        let moved_face = try new bool[(usize)self.face_count()] --- in memory.heap
        defer free(moved_face) in memory.heap
        for face in 0..<moved_face.length:
            let surface = (i64)self.face_surface.get(face)
            var hit = false
            for entry in source.surfaces.view(): hit = hit or entry == surface
            moved_face[face] = hit
        let owners = try new i64[count] --- in memory.heap
        defer free(owners) in memory.heap
        for at in 0..<count: owners[at] = -1
        for face in 0..<moved_face.length:
            if not moved_face[face]: continue
            var low = first_polygon(faces, polygons, (f64)face)
            while low < polygons and faces.number(low, 0) == (f64)face:
                for corner in (usize)offsets[low]..<(usize)offsets[low + 1]:
                    let point = (usize)corners[corner]
                    if point >= first_own: owners[point] = (i64)face
                low += 1
        # Old and new surfaces, and each moved face's placement.
        let origin = base.position_origin()
        let exact = precise_span(base)
        let loose = base.point_span()
        var positions = try Column[Float3].copy_of(loose)
        defer positions.release()
        let placed = positions.span()
        var moved = Growing[u32]()
        defer moved.close()
        # Each moved surface before and after, by its slot in the source.
        var before = Growing[Surface]()
        var now = Growing[Surface]()
        defer:
            for record in before.view(): record.close()
            for record in now.view(): record.close()
            before.close()
            now.close()
        for at in 0..<source.surfaces.count:
            let record = try self.surface((usize)source.surfaces.items[at])
            now.push(record) catch failure:
                record.close()
                error(failure.code, failure.message)
            let old = try Surface(3, record.origin, record.x, record.z, record.radius, record.angle, source.points.items[source.offsets.items[at]..<source.offsets.items[at + 1]], record.weights, record.ku, record.kv, record.nu, record.nv, record.du, record.dv)
            before.push(old) catch failure:
                old.close()
                error(failure.code, failure.message)
        # Each moved face's slot and inverse placement.
        let slots = try new i64[moved_face.length] --- in memory.heap
        defer free(slots) in memory.heap
        var backs = Growing[Matrix4]()
        defer backs.close()
        try backs.fill(moved_face.length, Matrix4())
        for face in 0..<moved_face.length:
            slots[face] = -1
            if not moved_face[face]: continue
            let surface = (i64)self.face_surface.get(face)
            for at in 0..<source.surfaces.count:
                if source.surfaces.items[at] == surface: slots[face] = (i64)at
            backs.items[face] = try self.face_placement.get(face).inverse()
        for point in 0..<count:
            if owners[point] >= 0: try moved.push((u32)point)
        # In parallel, a run of neighboring points at a time: each seeds the
        # next one's parameters.
        let placements = self.face_placement.view()
        var work = Projection(owners, slots, before.view(), now.view(), backs.view(), placements, exact, loose, origin, self.tolerance, moved.view(), placed)
        try parallel.for_each_range(moved.count, 64, (void*)&work, project_points)
        if work.failed.load(.acquire) != 0: error(invalid, "a moved CAD surface could not be previewed")
        return try mesh_adopt(try moved_storage(base, positions, moved.view()))

## What projecting the moved points reads and writes.
struct Projection:
    let owners: const i64[]
    let slots: const i64[]
    let before: const Surface[]
    let now: const Surface[]
    let backs: const Matrix4[]
    let placements: const Matrix4[]
    let exact: const Vector3[]
    let loose: const Float3[]
    let origin: Vector3
    let tolerance: f64
    let points: const u32[]
    let placed: Float3[]
    var failed: @u32

## Points `first..<end` of the moved list: parameters on the old surface,
## positions on the new one.
func project_points(context: void*, first: usize, end: usize, worker: usize):
    let work = (Projection*)context
    var seed = Vector3(0.5, 0.5, 0.0)
    var seeded: i64 = -1
    for at in first..<end:
        let point = (usize)work.points[at]
        let face = work.owners[point]
        let slot = (usize)work.slots[(usize)face]
        if face != seeded:
            seed = Vector3(0.5, 0.5, 0.0)
            seeded = face
        let world = work.exact[point] if work.exact.length > 0 else work.loose[point].vector().add(work.origin)
        let uv = project(work.before[slot], work.backs[(usize)face].transform_point(world), seed, work.tolerance) catch failure:
            work.failed.store(1, .relaxed)
            return
        seed = uv
        let moved = evaluate(work.now[slot], uv) catch failure:
            work.failed.store(1, .relaxed)
            return
        work.placed[point] = Float3.of(work.placements[(usize)face].transform_point(moved).subtract(work.origin))

## The first polygon of face `face` (polygons run in face order), or where
## it would be.
func first_polygon(faces: const Attribute*, polygons: usize, face: f64) -> usize:
    var low: usize = 0
    var high = polygons
    while low < high:
        let middle = (low + high) // 2
        if faces.number(middle, 0) < face: low = middle + 1
        else: high = middle
    return low