Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.5

0.9.5 / src / core / object.lucb

import interop
from luce_std import math
import memory
import ownership
import thread
import errors
from luce_geocore.geocore import Vector3, Matrix4, Geometry, Mesh
from core.material import Material, Color

pub enum LightKind as u8:
    inactive = 0
    ambient = 1
    directional = 2

pub struct Light:
    pub let kind: LightKind
    pub let color: Color = Color(1.0, 1.0, 1.0)
    pub let intensity: f64 = 0.0
    pub let direction: Vector3 = Vector3(0.0, 1.0, 0.0)

## Open scene protocol. node returns one retained reference to stable transform
## and child storage; geometry/material returns transfer optional retained edges.
## polygon returns the mesh a polygon object draws from its GPU arrays, or none.
pub interface Object3D:
    func node() -> interop.Reference[ObjectNode]

    func geometry() -> interop.Interface[Geometry]?

    func polygon() -> interop.Reference[Mesh]?

    func material() -> interop.Interface[Material]?

    func light() -> Light

struct Child:
    let object: interop.Interface[Object3D]
    let node: interop.Reference[ObjectNode]

var serial: u64 = 0
var revision: u64 = 0

pub func epoch() -> u64:
    return revision

## Shared composition for scene objects, never a tagged bag of mesh/light state.
## Parents own child objects and nodes; children store only their parent's identity.
pub struct ObjectNode:
    let identifier: u64
    var parent: u64
    var children: Child[]
    var location: Vector3
    var angles: Vector3
    var scaling: Vector3
    var visible: bool
    var changing: bool

    pub func init() -> !:
        if not thread.is_main():
            error(interop.wrong_thread, "scene objects require the main thread")
        serial = serial +? 1 else error(errors.limit, "scene object identities exhausted")
        self.identifier = serial
        self.parent = 0
        var empty: Child[]
        self.children = empty
        self.location = Vector3()
        self.angles = Vector3()
        self.scaling = Vector3(1.0, 1.0, 1.0)
        self.visible = true
        self.changing = false

    pub func id() -> u64:
        return self.identifier

    pub func parent_id() -> u64:
        return self.parent

    pub func position() -> Vector3:
        return self.location

    pub func rotation() -> Vector3:
        return self.angles

    pub func scale() -> Vector3:
        return self.scaling

    pub func set_position(position: Vector3) -> !:
        try bounded(position)
        self.location = position
        ObjectNode.invalidate()

    pub func set_rotation(rotation: Vector3) -> !:
        try bounded(rotation)
        self.angles = rotation
        ObjectNode.invalidate()

    pub func set_scale(scale: Vector3) -> !:
        try bounded(scale)
        if math.abs(scale.x) < 0.000001 or math.abs(scale.y) < 0.000001 or math.abs(scale.z) < 0.000001:
            error(errors.invalid, "scale magnitudes must be at least 0.000001")
        self.scaling = scale
        ObjectNode.invalidate()

    pub func matrix() -> Matrix4:
        return Matrix4.compose(self.location, self.angles, self.scaling)

    pub func is_visible() -> bool:
        return self.visible

    pub func set_visible(visible: bool):
        self.visible = visible
        ObjectNode.invalidate()

    static func invalidate():
        revision = revision +? 1 else trap("scene revision exhausted")

    pub func child_count() -> i64:
        return (i64)self.children.length

    pub func child(index: i64) -> interop.Interface[Object3D]!:
        if index < 0 or (usize)index >= self.children.length:
            error(errors.invalid, "child index is outside this scene object")
        return self.children[(usize)index].object.clone()

    pub func add(child: interop.Interface[Object3D]) -> !:
        if self.changing:
            error(errors.busy, "scene membership changes cannot reenter the same parent")
        self.changing = true
        defer self.finish_change()
        let node = try object_node(child)
        errdefer node.release()
        let state = try node.get()
        if state.parent != 0:
            error(errors.busy, "remove an object from its current parent before adding it")
        if self.children.length >= 1024 or try contains(state, self.identifier, 0):
            error(errors.invalid, "scene membership would exceed its limit or create a cycle")
        let replacement = try new Child[self.children.length + 1] --- in memory.heap
        for index in 0..<self.children.length:
            replacement[index] = self.children[index]
        replacement[self.children.length] = Child(child.clone(), node)
        let previous = self.children
        self.children = replacement
        state.parent = self.identifier
        ObjectNode.invalidate()
        if previous.length > 0:
            free(previous) in memory.heap

    pub func remove(child: interop.Interface[Object3D]) -> bool!:
        if self.changing:
            error(errors.busy, "scene membership changes cannot reenter the same parent")
        self.changing = true
        defer self.finish_change()
        var index: usize = 0
        while index < self.children.length:
            if self.children[index].object.owner == child.owner:
                let removed = self.children[index]
                let previous = self.children
                var replacement: Child[]
                if previous.length > 1:
                    replacement = try new Child[previous.length - 1] --- in memory.heap
                    var destination: usize = 0
                    for source in 0..<previous.length:
                        if source != index:
                            replacement[destination] = previous[source]
                            destination += 1
                self.children = replacement
                removed.node.value().parent = 0
                ObjectNode.invalidate()
                free(previous) in memory.heap
                removed.object.release()
                removed.node.release()
                return true
            index += 1
        return false

    pub func clear():
        if self.changing:
            return
        self.changing = true
        defer self.finish_change()
        let previous = self.children
        var empty: Child[]
        self.children = empty
        for child in previous:
            child.node.value().parent = 0
        ObjectNode.invalidate()
        for child in previous:
            child.object.release()
            child.node.release()
        if previous.length > 0:
            free(previous) in memory.heap

    func finish_change():
        self.changing = false

    func dispose():
        self.clear()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        for child in self.children:
            child.object.trace(visit, context)
            child.node.trace(visit, context)

pub let object_node_type: interop.Type[ObjectNode] = interop.Type[ObjectNode]("ObjectNode", ObjectNode.dispose, ObjectNode.trace, main_thread = true)

pub func make_node() -> interop.Reference[ObjectNode]!:
    return try interop.Reference[ObjectNode].adopt(new ObjectNode() in memory.heap, object_node_type, memory.heap)

pub func object_node(object: interop.Interface[Object3D]) -> interop.Reference[ObjectNode]!:
    try object.enter()
    defer object.leave()
    return object.value().node()

func contains(node: ObjectNode*, identifier: u64, depth: usize) -> bool!:
    if depth >= 64:
        error(errors.limit, "a scene supports at most 64 levels")
    if node.identifier == identifier:
        return true
    for child in node.children:
        if try contains(child.node.value(), identifier, depth + 1):
            return true
    return false

func bounded(vector: Vector3) -> !:
    if not vector.is_finite() or math.abs(vector.x) > 1000000.0 or math.abs(vector.y) > 1000000.0 or math.abs(vector.z) > 1000000.0:
        error(errors.invalid, "transform components must be finite and at most 1000000 in magnitude")