Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / scene.lucb

## Read-only evaluated scene snapshots retain the source document's element order.
import interop
from document import Document
from model import DocumentData, Element
from animation import resolve_property, Property
from evaluation.engine import NodeRegistry, Evaluator
from geometry.affine import Affine2
from geometry.transform import world_matrix_data, visible_data
from storage import List, Buffer, text_copy
from value import Value, own_value
from types import invalid, missing
from names import Name

struct Evaluated:
    var properties: Element
    var outputs: Element
    var world: Affine2
    var visible: bool

    func close():
        self.properties.close()
        self.outputs.close()

pub struct Scene:
    var elements: List[Evaluated]
    var time_value: f64

    pub func init(doc: interop.Reference[Document], registry: interop.Reference[NodeRegistry], time: f64 = 0.0) -> !:
        self.elements = List[Evaluated]()
        self.time_value = time
        errdefer self.close()
        let source = (try doc.get()).view_data()
        var evaluator = try Evaluator(doc, registry, time)
        defer evaluator.close()
        for element in source.elements.span():
            var resolved = Evaluated(world = Affine2())
            errdefer resolved.close()
            let path = element.path.view()
            resolved.world = try world_matrix_data(source, path, time)
            resolved.visible = try visible_data(source, path, time)
            resolved.properties.path = try element.path.copy()
            resolved.properties.kind = try element.kind.copy()
            for prop in element.properties.span():
                var value = Property()
                defer value.close()
                value.name = try prop.name.copy()
                value.value = try resolve_property(&prop, time)
                try resolved.properties.put_property(&value)
            let count = try evaluator.bake(path)
            for index in 0..<count:
                let name = try evaluator.output_name(path, index)
                var slot = try text_copy(path)
                defer slot.close()
                try slot.byte('.')
                try slot.text(name)
                let value = try evaluator.output(slot.view())
                defer value.release()
                var prop = Property()
                defer prop.close()
                prop.name = try Name.of(name)
                prop.value = try value.value().view_data().copy()
                try resolved.outputs.put_property(&prop)
            try self.elements.push(resolved)

    pub func time() -> f64:
        return self.time_value

    pub func count() -> usize:
        return self.elements.count

    func element(index: usize) -> const Evaluated*!:
        if index >= self.elements.count:
            error(invalid, "scene element index is out of bounds")
        return &self.elements.items[index]

    pub func path_at(index: usize) -> str!:
        return (try self.element(index)).properties.path.view()

    pub func type_at(index: usize) -> str!:
        return (try self.element(index)).properties.kind.view()

    pub func world_at(index: usize) -> Affine2!:
        return (try self.element(index)).world

    pub func visible_at(index: usize) -> bool!:
        return (try self.element(index)).visible

    pub func property(index: usize, name: str) -> interop.Reference[Value]!:
        let element = &(try self.element(index)).properties
        let prop = element.property(name) else error(missing, "scene property is absent")
        return try own_value(try element.properties.items[prop].value.copy())

    pub func output(index: usize, name: str) -> interop.Reference[Value]!:
        let element = &(try self.element(index)).outputs
        let prop = element.property(name) else error(missing, "scene output is absent")
        return try own_value(try element.properties.items[prop].value.copy())

    pub func close():
        for i in 0..<self.elements.count:
            self.elements.items[i].close()
        self.elements.close()

pub let scene_type = interop.Type[Scene]("Prism evaluated scene", Scene.close, closeable = true)