Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.2

0.9.2 / src / model / preview_set.lucb

## A CAD model's disposable display preview, built on the worker pool. Each
## face's preview mesh is copied into raw arrays on its worker (a mesh and its
## owner stay on the thread that made them) and merged here, in face order,
## into display batches, as luced-3d once merged its per-patch meshes one by
## one: same meshes, same batch limits, far less copying.

## Batch limits: small retained meshes keep partial redraws cheap.
let batch_points: usize = 4096
let batch_vertices: usize = 16000

## One point, corner or face attribute of a part.
struct PartColumn:
    var name: u8[64]
    var length: usize = 0
    var domain: i64 = 0
    var width: i64 = 1
    var integer: bool = false
    var values: f64[]

    func label() -> str:
        return (str)self.name[..<self.length]

## One face's preview and boundary polylines, filled on a worker.
pub struct PreviewPart:
    var points: Vector3[]
    var sizes: i64[]
    var corners: i64[]
    ## Display triangles as corners local to their face, grouped by face.
    var display: i64[]
    var columns: PartColumn[]
    var column_count: usize = 0
    var colored: bool = false
    var guide: bool = false
    var guide_start: Vector3 = Vector3()
    var guide_end: Vector3 = Vector3()
    ## Edge IDs of the face's uses, and each use's polyline in `polyline`.
    var ids: i64[]
    var starts: usize[]
    var polyline: Vector3[]
    var uses: usize = 0
    var used: usize = 0
    var failure: interop.Packet[str]? = none
    var fatal_failure: bool = false

    pub func open_boundaries(uses: usize) -> !:
        self.ids = try new i64[uses] --- in memory.heap
        self.starts = try new usize[uses + 1] --- in memory.heap
        self.polyline = try new Vector3[uses * 65 + 1] --- in memory.heap
        self.starts[0] = 0

    pub func begin_use(id: i64) -> !:
        if self.uses == self.ids.length: error(invalid, "preview boundary use overflow")
        self.ids[self.uses] = id
        self.uses += 1
        self.starts[self.uses] = self.used

    pub func boundary_point(point: Vector3) -> !:
        if self.used == self.polyline.length: error(invalid, "preview boundary overflow")
        self.polyline[self.used] = point
        self.used += 1
        self.starts[self.uses] = self.used

    pub func failed() -> bool:
        if let failure = self.failure:
            _ = failure
            return true
        return false

    ## The preview failed; the face is counted and keeps its boundaries.
    pub func fail(message: str):
        self.failure = interop.text_transfer.copy(message) catch exhausted: trap(exhausted.message)

    ## The whole preview fails, as the serial boundary sampling did.
    pub func fatal(message: str):
        self.fail(message)
        self.fatal_failure = true

    ## Copy `mesh` into raw arrays and its normal guide (as luced-3d drew it).
    pub func adopt(mesh: interop.Reference[Mesh]) -> !:
        let m = mesh.value()
        let point_count = (usize)m.point_count()
        let face_count = (usize)m.face_count()
        self.points = try new Vector3[point_count] --- in memory.heap
        for at in 0..<point_count: self.points[at] = try m.point((i64)at)
        self.sizes = try new i64[face_count] --- in memory.heap
        self.corners = try new i64[(usize)m.vertex_count()] --- in memory.heap
        self.display = try new i64[(usize)m.index_count()] --- in memory.heap
        var corner: usize = 0
        var triangle: usize = 0
        for face in 0..<face_count:
            let size = try m.face_size((i64)face)
            let offset = try m.face_offset((i64)face)
            self.sizes[face] = size
            for at in 0..<size:
                self.corners[corner] = try m.face_point((i64)face, at)
                corner += 1
            let first = (offset - (i64)face * 2) * 3
            for at in 0..<(size - 2) * 3:
                let index = m.index(first + at)
                defer index.release()
                self.display[triangle] = (try index.get()) - offset
                triangle += 1
        var kept: usize = 0
        let count = (usize)m.attribute_count()
        self.columns = try new PartColumn[count] --- in memory.heap
        for index in 0..<count:
            let domain = try m.attribute_domain((i64)index)
            if domain > 2: continue
            let name = try m.attribute_name((i64)index)
            let width = try m.attribute_width((i64)index)
            let elements = try m.domain_count(domain)
            var column = PartColumn()
            memory.copy(column.name[..<name.length], name.bytes, name.length)
            column.length = name.length
            column.domain = domain
            column.width = width
            column.integer = try m.attribute_integer((i64)index)
            column.values = try new f64[(usize)(elements * width)] --- in memory.heap
            for element in 0..<elements:
                for component in 0..<width:
                    column.values[(usize)(element * width + component)] = try m.attribute_value((i64)index, element, component)
            self.columns[kept] = column
            kept += 1
            self.column_count = kept
            if domain == 2 and name == "Cd": self.colored = true
        if face_count > 0:
            let middle = (i64)face_count // 2
            let center = try m.face_center(middle)
            let box = m.bounds()
            let length = box.maximum.subtract(box.minimum).length() * 0.03
            self.guide = true
            self.guide_start = center
            self.guide_end = center.add((try m.face_normal(middle)).multiply_scalar(length))

    func close():
        if self.points.length > 0: free(self.points) in memory.heap
        if self.sizes.length > 0: free(self.sizes) in memory.heap
        if self.corners.length > 0: free(self.corners) in memory.heap
        if self.display.length > 0: free(self.display) in memory.heap
        for column in self.columns[..<self.column_count]:
            if column.values.length > 0: free(column.values) in memory.heap
        if self.columns.length > 0: free(self.columns) in memory.heap
        if self.ids.length > 0: free(self.ids) in memory.heap
        if self.starts.length > 0: free(self.starts) in memory.heap
        if self.polyline.length > 0: free(self.polyline) in memory.heap
        if let failure = self.failure: failure.release()

## Fills face `index`'s part on a worker; must not touch caller-owned objects.
pub type PartMaker = func(void*?, usize, PreviewPart*) -> unit

struct PartJob:
    let make: PartMaker
    let context: void*?
    let parts: PreviewPart[]
    var stop: @bool

func part_item(raw: void*, index: usize, worker: usize):
    let job = (PartJob*)raw
    if job.stop.load(.acquire): return
    let make = job.make
    make(job.context, index, &job.parts[index])

## Make every face's part on the pool and assemble the preview. `edges` bounds
## the shared edge IDs; other IDs belong to one face use and always show.
pub func collect_preview(faces: usize, edges: usize, make: PartMaker, context: void*?, progress: interop.Callback[f64, unit]?) -> interop.Reference[CadPreviewSet]!:
    let parts = try new PreviewPart[faces] --- in memory.heap
    defer free(parts) in memory.heap
    for at in 0..<faces: parts[at] = PreviewPart()
    defer close_parts(parts)
    var job = PartJob(make = make, context = context, parts = parts)
    var pooled = try parallel.start(faces, (void*)&job, part_item)
    var waiting = true
    defer:
        if waiting:
            job.stop.store(true, .release)
            pooled.wait() catch failure: _ = failure
    var reported: usize = 0
    while true:
        let completed = pooled.progress()
        if completed != reported:
            if let report = progress:
                let outcome = report.invoke((f64)completed / (f64)faces)
                defer outcome.release()
                try outcome.get()
            reported = completed
        if completed >= faces: break
        thread.sleep(2)
    waiting = false
    try pooled.wait()
    for part in parts:
        if part.fatal_failure:
            if let failure = part.failure:
                let owned = try interop.copy_text(failure.value)
                if let owner = owned.owner: _ = ownership.pool_object(owner)
                error(invalid, owned.value)
    let set = try new CadPreviewSet(faces) in memory.heap
    let result = try interop.Reference[CadPreviewSet].adopt(set, cad_preview_set_type, memory.heap)
    errdefer result.release()
    try result.value().assemble(parts, edges)
    return result

func close_parts(parts: const PreviewPart[]):
    for part in parts: part.close()

## A model's pooled preview: every face's preview mesh in face order,
## batched for drawing, with every shared edge's outline once and a normal
## guide per face (CadModel.preview).
pub struct CadPreviewSet:
    var meshes: interop.Reference[Mesh][]
    var mesh_total: usize = 0
    var boundaries: Vector3[]
    var boundary_total: usize = 0
    var guides: Vector3[]
    var guide_total: usize = 0
    var failures: i64 = 0
    var error_text: interop.Packet[str]? = none

    func init(faces: usize) -> !:
        self.meshes = try new interop.Reference[Mesh][faces + 1] --- in memory.heap
        errdefer free(self.meshes) in memory.heap
        self.guides = try new Vector3[faces * 2 + 1] --- in memory.heap
        var empty: Vector3[]
        self.boundaries = empty
        self.mesh_total = 0
        self.boundary_total = 0
        self.guide_total = 0
        self.failures = 0
        self.error_text = none

    pub func mesh_count() -> i64:
        return (i64)self.mesh_total

    pub func mesh(index: i64) -> interop.Reference[Mesh]!:
        if index < 0 or (usize)index >= self.mesh_total: error(invalid, "preview mesh index out of range")
        return self.meshes[(usize)index].clone()

    ## Boundary segments as point pairs.
    pub func boundary_count() -> i64:
        return (i64)self.boundary_total

    pub func boundary(index: i64) -> Vector3!:
        if index < 0 or (usize)index >= self.boundary_total: error(invalid, "preview boundary index out of range")
        return self.boundaries[(usize)index]

    ## Normal guides as (start, end) pairs, one per meshed face.
    pub func guide_count() -> i64:
        return (i64)self.guide_total

    pub func guide(index: i64) -> Vector3!:
        if index < 0 or (usize)index >= self.guide_total: error(invalid, "preview guide index out of range")
        return self.guides[(usize)index]

    pub func failed_faces() -> i64:
        return self.failures

    ## "Patch N: message" for the first failed face in order, or empty.
    pub func first_error() -> str:
        return (self.error_text else interop.Packet[str]("")).value

    func assemble(parts: const PreviewPart[], edges: usize) -> !:
        var total: usize = 0
        for part in parts:
            for use in 0..<part.uses:
                total += (part.starts[use + 1] - part.starts[use] - 1) * 2
        self.boundaries = try new Vector3[total + 1] --- in memory.heap
        let shown = try new bool[edges + 1] --- in memory.heap
        defer free(shown) in memory.heap
        for at in 0..<shown.length: shown[at] = false
        var batch_start: usize = 0
        var batch_end: usize = 0
        var points: usize = 0
        var vertices: usize = 0
        for face in 0..<parts.length:
            let part = parts[face]
            for use in 0..<part.uses:
                let id = part.ids[use]
                if id >= 0 and (usize)id < edges:
                    if shown[(usize)id]: continue
                    shown[(usize)id] = true
                for at in part.starts[use] + 1..<part.starts[use + 1]:
                    self.boundaries[self.boundary_total] = part.polyline[at - 1]
                    self.boundaries[self.boundary_total + 1] = part.polyline[at]
                    self.boundary_total += 2
            if let failure = part.failure:
                self.failures += 1
                if self.failures == 1:
                    var buffer: u8[1024]
                    let text = strings.format(buffer, f"Patch {face + 1}: {failure.value}") catch exhausted: recover failure.value
                    self.error_text = try interop.text_transfer.copy(text)
                continue
            if part.guide:
                self.guides[self.guide_total] = part.guide_start
                self.guides[self.guide_total + 1] = part.guide_end
                self.guide_total += 2
            if batch_end > batch_start:
                let same = parts[batch_start].colored == part.colored
                if same and points + part.points.length < batch_points and vertices + part.corners.length < batch_vertices:
                    batch_end = face + 1
                    points += part.points.length
                    vertices += part.corners.length
                    continue
                try self.flush(parts[batch_start..<batch_end])
            batch_start = face
            batch_end = face + 1
            points = part.points.length
            vertices = part.corners.length
        if batch_end > batch_start: try self.flush(parts[batch_start..<batch_end])

    ## One display mesh from consecutive parts; failed parts in the range are
    ## skipped. Attributes join by (name, domain) in first-seen order, zeros
    ## where a part lacks one, as Mesh.merged does.
    func flush(parts: const PreviewPart[]) -> !:
        var builder = try MeshBuilder()
        defer builder.close()
        for part in parts:
            if part.failed(): continue
            let base = (i64)builder.np
            for point in part.points: _ = try builder.point(point)
            var corner: usize = 0
            var triangle: usize = 0
            for size in part.sizes:
                try builder.face(size)
                for at in 0..<(usize)size:
                    try builder.corner(base + part.corners[corner + at])
                corner += (usize)size
                let count = ((usize)size - 2) * 3
                try builder.set_last_display(part.display[triangle..<triangle + count])
                triangle += count
        var mesh = try builder.finish()
        errdefer mesh.release()
        for part in parts:
            if part.failed(): continue
            for column in part.columns[..<part.column_count]:
                if mesh.value().find_attribute(column.label(), column.domain) >= 0: continue
                let values = try joined(parts, column)
                defer free(values) in memory.heap
                let next = try mesh.value().with_attribute(column.label(), column.domain, column.width, values, column.integer)
                mesh.release()
                mesh = next
        self.meshes[self.mesh_total] = mesh
        self.mesh_total += 1

    pub func close():
        for mesh in self.meshes[..<self.mesh_total]: mesh.release()
        free(self.meshes) in memory.heap
        if self.boundaries.length > 0: free(self.boundaries) in memory.heap
        free(self.guides) in memory.heap
        if let text = self.error_text: text.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        for mesh in self.meshes[..<self.mesh_total]: mesh.trace(visit, context)

pub let cad_preview_set_type: interop.Type[CadPreviewSet] = interop.Type[CadPreviewSet]("CadPreviewSet", CadPreviewSet.close, CadPreviewSet.trace, closeable = true)

## One attribute across a batch's parts, zero where a part lacks it.
func joined(parts: const PreviewPart[], like: PartColumn) -> f64[]!:
    var total: usize = 0
    for part in parts:
        if part.failed(): continue
        total += domain_size(part, like.domain) * (usize)like.width
    let values = try new f64[total] --- in memory.heap
    var at: usize = 0
    for part in parts:
        if part.failed(): continue
        let count = domain_size(part, like.domain) * (usize)like.width
        var found = false
        for column in part.columns[..<part.column_count]:
            if column.domain == like.domain and column.width == like.width and column.label() == like.label():
                memory.copy(values[at..<at + count], column.values, count)
                found = true
                break
        if not found:
            for index in at..<at + count: values[index] = 0.0
        at += count
    return values

func domain_size(part: PreviewPart, domain: i64) -> usize:
    if domain == 0: return part.points.length
    if domain == 1: return part.corners.length
    return part.sizes.length