Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.5

0.9.5 / src / objects / mesh.lucb

import interop
import memory
import ownership
import errors
import core.object
from core.object import Object3D, ObjectNode, Light, LightKind
from luce_geocore import geocore
from luce_geocore.geocore import Geometry, Vector3
from core.material import Material, Color, check_color
from geometries.mesh_geometry import MeshGeometry, mesh_geometry_type

## A scene object drawing a geometry with a material. `Mesh.of` wraps a
## polygon mesh, which the renderer draws from retained GPU arrays keyed by
## the mesh's change ids instead of through the per-vertex interface.
pub struct Mesh: Object3D:
    let transform: interop.Reference[ObjectNode]
    let shape: interop.Interface[Geometry]
    let appearance: interop.Interface[Material]
    let source: interop.Reference[geocore.Mesh]?

    pub func init(geometry: interop.Interface[Geometry], material: interop.Interface[Material], polygon: interop.Reference[geocore.Mesh]? = none) -> !:
        try geometry.enter()
        defer geometry.leave()
        try material.enter()
        defer material.leave()
        self.transform = try object.make_node()
        self.shape = geometry.clone()
        self.appearance = material.clone()
        var retained: interop.Reference[geocore.Mesh]? = none
        if let mesh = polygon: retained = mesh.clone()
        self.source = retained

    ## A scene object for a polygon mesh.
    pub static func of(mesh: interop.Reference[geocore.Mesh], material: interop.Interface[Material]) -> interop.Reference[Mesh]!:
        let wrapped = try interop.Reference[MeshGeometry].adopt(new MeshGeometry(mesh) in memory.heap, mesh_geometry_type, memory.heap)
        defer wrapped.release()
        let geometry = wrapped.as_interface[Geometry](wrapped.value())
        defer geometry.release()
        return try interop.Reference[Mesh].adopt(new Mesh(geometry, material, mesh) in memory.heap, mesh_type, memory.heap)

    pub func polygon() -> interop.Reference[geocore.Mesh]?:
        let mesh = self.source else return none
        return mesh.clone()

    pub func node() -> interop.Reference[ObjectNode]:
        return self.transform.clone()

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

    pub func set_position(position: Vector3) -> !:
        try self.transform.value().set_position(position)

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

    pub func set_rotation(rotation: Vector3) -> !:
        try self.transform.value().set_rotation(rotation)

    pub func set_scale(scale: Vector3) -> !:
        try self.transform.value().set_scale(scale)

    pub func add(child: interop.Interface[Object3D]) -> !:
        try self.transform.value().add(child)

    pub func remove(child: interop.Interface[Object3D]) -> bool!:
        return try self.transform.value().remove(child)

    pub func clear():
        self.transform.value().clear()

    pub func geometry() -> interop.Interface[Geometry]?:
        return self.shape.clone()

    pub func material() -> interop.Interface[Material]?:
        return self.appearance.clone()

    pub func light() -> Light:
        return Light()

    pub func close():
        self.transform.value().clear()
        self.shape.release()
        self.appearance.release()
        if let mesh = self.source: mesh.release()
        self.transform.release()

    func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        self.transform.trace(visit, context)
        self.shape.trace(visit, context)
        self.appearance.trace(visit, context)
        if let mesh = self.source: mesh.trace(visit, context)

pub let mesh_type: interop.Type[Mesh] = interop.Type[Mesh]("Mesh", Mesh.close, Mesh.trace, closeable = true, main_thread = true)