Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.1

0.11.1 / src / scene_projection.luc

## Hierarchical display submission. Group transforms never bake child meshes.
from geometry_data import GeometryData
from luce_geocore import geocore
from luce_3d.graphics import Group, Mesh, MeshLambertMaterial, Matrix4, Vector3
import theme
from overlay_lines import OverlayLines
from luce_ui import ui

pub func append_scene(data: GeometryData, parent: Group, depth: int = 0, mode: int = 3) -> int!:
    if depth > 48:
        error(ui.invalid, "Scene hierarchy exceeds the display depth budget")
    var analytic = 0
    if data.has_cad():
        let preview = data.preview()
        analytic = preview.failed_faces
        for mesh in preview.meshes:
            _ = append_scene(GeometryData(mesh), parent, depth, mode)
    if let mesh = data.mesh:
        if mesh.face_count() > 0:
            parent.add(display_mesh(mesh))
    if let preview = data.field_preview():
        parent.add(display_mesh(preview))
    for index in 0..<data.instance_count():
        if not data.instance_visible(index):
            continue
        let branch = Group()
        branch.set_position(data.instance_translation(index))
        branch.set_rotation(data.instance_rotation(index))
        branch.set_scale(data.instance_scale(index))
        analytic += append_scene(data.instance(index), branch, depth + 1, mode)
        parent.add(branch)
    return analytic

## Shaded scene object for one polygon mesh, drawn from its GPU arrays; vertex
## colors show at full white.
pub func display_mesh(mesh: geocore.Mesh) -> Mesh!:
    let colored = mesh.find_attribute("Cd", 2) >= 0 or mesh.find_attribute("Cd", 1) >= 0 or mesh.find_attribute("Cd", 0) >= 0 or mesh.find_attribute("Cd", 3) >= 0
    return Mesh.of(mesh, MeshLambertMaterial(theme.grey(255.0 if colored else 180.0)))

## Overlays in world space, gathered in Base (OverlayLines): CAD
## boundaries into `wires`, CAD normal guides and (with `polygons`) a
## polygon normal guide per face into `normals`. Polygon wires come from the
## renderer, which draws them from each mesh's GPU arrays.
pub func append_overlays(data: GeometryData, matrix: Matrix4, wires: OverlayLines, normals: OverlayLines, depth: int = 0, polygons: bool = true) -> unit!:
    if depth > 48:
        error(ui.invalid, "Scene hierarchy exceeds overlay depth budget")
    if data.has_cad():
        let preview = data.preview()
        preview.lines(0, matrix, wires)
        preview.lines(2, matrix, normals)
    if let mesh = data.mesh if polygons else none:
        normals.add_face_guides(mesh, matrix)
    for index in 0..<data.instance_count():
        if data.instance_visible(index):
            append_overlays(data.instance(index), matrix.multiply(data.instance_matrix(index)), wires, normals, depth + 1, polygons)

## Analytic patch borders stay visible independently of polygon wire overlays.
pub func append_patch_boundaries(data: GeometryData, matrix: Matrix4, lines: OverlayLines) -> unit!:
    if data.has_cad():
        data.preview().lines(0, matrix, lines)
    for index in 0..<data.instance_count():
        if data.instance_visible(index):
            append_patch_boundaries(data.instance(index), matrix.multiply(data.instance_matrix(index)), lines)

## CAD control nets (the hull), as world-space point pairs.
pub func append_cad_hulls(data: GeometryData, matrix: Matrix4, lines: OverlayLines, depth: int = 0) -> unit!:
    if depth > 48:
        error(ui.invalid, "Scene hierarchy exceeds overlay depth budget")
    if data.has_cad():
        data.preview().lines(1, matrix, lines)
    for index in 0..<data.instance_count():
        if data.instance_visible(index):
            append_cad_hulls(data.instance(index), matrix.multiply(data.instance_matrix(index)), lines, depth + 1)

## Transform bounding-box corners, not geometry, when framing an assembly.
pub func append_bounds(data: GeometryData, matrix: Matrix4, points: list[Vector3], depth: int = 0) -> unit!:
    if depth > 48:
        error(ui.invalid, "Scene hierarchy exceeds the display depth budget")
    if data.has_cad():
        let preview = data.preview()
        for mesh in preview.meshes:
            append_bounds(GeometryData(mesh), matrix, points, depth)
        # Failed preview patches still have visible analytic boundary curves.
        let boundaries = OverlayLines.make()
        preview.lines(0, matrix, boundaries)
        if boundaries.count() > 0:
            let box = boundaries.bounds()
            points.append(box.minimum)
            points.append(box.maximum)
    for shown in [data.mesh, data.field_preview()]:
        let mesh = shown else continue
        if mesh.point_count() > 0:
            let box = mesh.bounds()
            for x in [box.minimum.x, box.maximum.x]:
                for y in [box.minimum.y, box.maximum.y]:
                    for z in [box.minimum.z, box.maximum.z]:
                        points.append(matrix.transform_point(Vector3(x, y, z)))
    for index in 0..<data.instance_count():
        if data.instance_visible(index):
            append_bounds(data.instance(index), matrix.multiply(data.instance_matrix(index)), points, depth + 1)