Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.4

0.9.4 / src / flatten / flatten.lucb

## A composed stage flattened into one layer, after UsdStage::Flatten
## (pxr/usd/usd/stage.cpp: _CopyPrim, _CopyProperty, _CopyMetadata): the
## stage metadata of the session and root layers, then every active prim
## depth first with its composed metadata and properties. Opinions are read
## as Usd_Resolver walks them: nodes in strength order, each node's layers
## strongest first; values move into stage time by their layer's offset,
## and asset paths are anchored at the layer that authored them.
##
## Instances reference a prototype written first as /Flattened_Prototype_N
## (instances.lucb). This fragment walks prims and writes specs;
## metadata.lucb composes fields; properties.lucb writes attributes and
## relationships.
from luce_std import math
import memory
import errors
import ar
from sdf.names import Names, PathKind, absolute_root, empty_path
from sdf.layer_data import LayerData, Spec, SpecType, FieldKeys
from sdf.values import Value, Dictionary, ListOp, ListItem, ListPart, TimeSamples, apply_edit, is_list_op, specifier_def, specifier_over, specifier_class, variability_varying, variability_uniform
from sdf.value_types import ValueKind, scalar_of, element_bytes
from sdf.list_ops import compose_list_ops, explicit_list
from dictionary_order import dictionary_less
from sdf.schema import find_field, applies_layer, applies_prim, applies_attribute, applies_relationship
from pcp import Composer, PrimIndex, Offset, InstanceKey
from prim_definitions import Schemas, PropertyDefinition
from sdf.expressions import is_expression, evaluate, ExpressionKind
from sdf.splines import offset_spline
from luce_geocore.core.growing import Growing
from luce_geocore.core.shared import Column

## One place an opinion can be: a node's layer and the spec path in it.
struct Opinion:
    var node: u32
    var layer: usize
    var position: usize
    var spec: usize

## Flatten the composer's stage into the empty layer `out` (sharing its
## Names). `comment` adds OpenUSD's "Generated from Composed Stage" note.
## With `instancing`, instances reference prototypes as UsdStage::Flatten
## writes them; without, each instance holds its own copy of the
## prototype's prims (as instance proxies show them).
pub func flatten_stage(composer: Composer*, out: LayerData*, comment: bool, instancing: bool) -> !:
    var schemas = try Schemas(composer.names)
    defer schemas.close()
    var flat = Flattener(composer, out, &schemas)
    defer flat.close()
    flat.instancing = instancing
    try flat.pseudo_root(comment)
    var children = Growing[u32]()
    defer children.close()
    try composer.child_names(try composer.index(absolute_root), &children)
    var roots = Growing[u32]()
    defer roots.close()
    for name in children.view(): try roots.push(try composer.names.child(absolute_root, name))
    if instancing:
        try flat.populate(roots.view())
        try flat.write_prototypes()
    for name in children.view():
        let path = try composer.names.child(absolute_root, name)
        try flat.prim(path, path)
    try flat.finish()

## The flattening's output state.
struct Flattener:
    var composer: Composer*
    var out: LayerData*
    var names: Names*
    ## Child and property names per output spec index.
    var children: Growing[Growing[u32]]
    var properties: Growing[Growing[u32]]
    ## The stage's prototypes and its instances' paths and prototypes.
    var prototypes: Growing[Prototype]
    var instances: Growing[u32]
    var instance_of: Growing[u32]
    ## While a prototype is written: its source and flattened paths.
    var writing_source: u32
    var writing_path: u32
    ## Whether instances reference prototypes.
    var instancing: bool
    ## Schema definitions, and the prim being written's type and applied
    ## API schemas (its built-in properties come from them).
    var schemas: const Schemas*
    var prim_type: u32
    var prim_applied: Growing[u32]

    func init(composer: Composer*, out: LayerData*, schemas: const Schemas*):
        self.composer = composer
        self.out = out
        self.names = composer.names
        self.children = Growing[Growing[u32]]()
        self.properties = Growing[Growing[u32]]()
        self.prototypes = Growing[Prototype]()
        self.instances = Growing[u32]()
        self.instance_of = Growing[u32]()
        self.writing_source = empty_path
        self.writing_path = empty_path
        self.instancing = true
        self.schemas = schemas
        self.prim_type = 0
        self.prim_applied = Growing[u32]()

    func close():
        for at in 0..<self.children.count: self.children.items[at].close()
        for at in 0..<self.properties.count: self.properties.items[at].close()
        self.children.close()
        self.properties.close()
        for at in 0..<self.prototypes.count: self.prototypes.items[at].key.close()
        self.prototypes.close()
        self.instances.close()
        self.instance_of.close()
        self.prim_applied.close()

    func grow(index: usize) -> !:
        while self.children.count <= index:
            try self.children.push(Growing[u32]())
            try self.properties.push(Growing[u32]())

    ## Write the children and properties fields.
    func finish() -> !:
        let keys = &self.out.keys
        for spec in 0..<self.children.count:
            if self.children.items[spec].count > 0:
                try self.out.set(spec, keys.prim_children, try id_vector(ValueKind.token_vector, self.children.items[spec].view()))
            if self.properties.items[spec].count > 0:
                try self.out.set(spec, keys.properties, try id_vector(ValueKind.token_vector, self.properties.items[spec].view()))

    ## Stage metadata: the session layer's fields, then the root layer's
    ## (not their sublayers'), composed (_ComposePseudoRootMetadataImpl).
    func pseudo_root(comment: bool) -> !:
        let composer = self.composer
        let index = try composer.index(absolute_root)
        let stack = composer.stacks.stack(composer.root_stack)
        var opinions = Growing[Opinion]()
        defer opinions.close()
        if let session = stack.session: try opinions.push(Opinion(node = 0, layer = session, position = 0, spec = 0))
        for position in 0..<stack.layers.count:
            if stack.layers.items[position] == stack.root:
                try opinions.push(Opinion(node = 0, layer = stack.root, position = position, spec = 0))
                break
        var fields = Growing[u32]()
        defer fields.close()
        for opinion in opinions.view():
            for field in composer.layers.layer(opinion.layer).spec(0).fields.view():
                if not self.private_field(field.name, SpecType.pseudo_root): try add_unique(&fields, field.name)
        try self.grow(0)
        for key in fields.view():
            if let value = try self.composed_value(index, opinions.view(), key): try self.out.set(0, key, value)
        if comment: try self.add_comment(composer.layers.identifier(stack.root))

    ## Append "Generated from Composed Stage of root layer <path>" to the
    ## flattened layer's documentation.
    func add_comment(root: str) -> !:
        let key = self.out.keys.documentation
        var text = Growing[u8]()
        defer text.close()
        if let found = self.out.get(0, key):
            let held = self.names.text_of(found.as_token())
            if held.length > 0:
                try text.assign(held.bytes)
                for byte in "\n\n".bytes: try text.push(byte)
        for byte in "Generated from Composed Stage of root layer ".bytes: try text.push(byte)
        for byte in root.bytes: try text.push(byte)
        try text.push(10)
        try self.out.set(0, key, Value.scalar(ValueKind.string, (u64)(try self.names.token((str)text.view()))))

    ## Flatten the prim whose index is at `source` into `path`, and its
    ## descendants unless it is an instance (_CopyPrim over the range).
    func prim(source: u32, path: u32) -> !:
        let composer = self.composer
        let index = try composer.index(source)
        var opinions = Growing[Opinion]()
        defer opinions.close()
        try self.gather(index, 0, &opinions)
        if not try self.is_active(index, opinions.view()): return
        let spec = try self.out.create_spec(path, SpecType.prim)
        try self.grow(spec)
        let parent = self.out.find(self.names.parent(path)) else error(errors.invalid, "a flattened prim's parent is missing")
        try self.grow(parent)
        try self.children.items[parent].push(self.names.name(path))
        let instance = index.instanceable and self.instancing
        if instance: try self.reference_prototype(source, spec)
        try self.prim_metadata(index, opinions.view(), spec)
        try self.definition_of(index, opinions.view())
        # Properties by name (TfDictionaryLessThan), then propertyOrder.
        var names = Growing[u32]()
        defer names.close()
        try composer.property_names(index, &names)
        try self.sort_names(&names)
        if let order = try self.composed_value(index, opinions.view(), self.out.keys.property_order):
            var held = order
            defer held.release()
            try apply_property_order(&names, held.ids())
        for name in names.view(): try self.property(index, path, spec, name)
        if instance: return
        var children = Growing[u32]()
        defer children.close()
        try composer.child_names(index, &children)
        for name in children.view(): try self.prim(try self.names.child(source, name), try self.names.child(path, name))

    ## The opinions of the prim (`property` 0) or of one of its properties.
    func gather(index: const PrimIndex*, property: u32, out: Growing[Opinion]*) -> !:
        out.clear()
        var order = Growing[u32]()
        defer order.close()
        try index.order(&order, true)
        let composer = self.composer
        for node in order.view():
            let entry = index.node(node)
            if not entry.contributes(): continue
            let path = entry.path if property == 0 else try self.names.property(entry.path, property)
            let layers = composer.stacks.stack(entry.stack).layers.view()
            for position in 0..<layers.length:
                let data = composer.layers.layer(layers[position])
                if let spec = data.find(path): try out.push(Opinion(node = node, layer = layers[position], position = position, spec = spec))

    ## The prim's typed schema and applied API schemas, for its properties.
    func definition_of(index: const PrimIndex*, opinions: const Opinion[]) -> !:
        self.prim_type = self.type_name(opinions)
        self.prim_applied.clear()
        var applied = try self.composed_value(index, opinions, try self.names.token("apiSchemas"))
        if let value = applied:
            var held = value
            defer held.release()
            if let list = held.list_op():
                for item in list.items(ListPart.explicit): try self.prim_applied.push((u32)item.a)

    ## The built-in definition of property `name` of the prim being
    ## written, if any.
    func builtin(name: u32) -> PropertyDefinition?:
        return self.schemas.find(self.prim_type, self.prim_applied.view(), name)

    func sort_names(names: Growing[u32]*) -> !:
        for at in 1..<names.count:
            let current = names.items[at]
            var move = at
            while move > 0 and dictionary_less(self.names.text_of(current), self.names.text_of(names.items[move - 1])):
                names.items[move] = names.items[move - 1]
                move -= 1
            names.items[move] = current

func add_unique(list: Growing[u32]*, name: u32) -> !:
    for known in list.view():
        if known == name: return
    try list.push(name)

## A token, path or string vector value of `ids`.
func id_vector(kind: ValueKind, ids: const u32[]) -> Value!:
    let column = try Column[u8].copy_of(u8[]((u8*)ids.data, ids.length * 4))
    return Value.of_records(kind, ids.length, column)

## UsdPrim's ApplyPropertyOrder: the names `order` lists come first in its
## order; the rest follow in their order.
func apply_property_order(names: Growing[u32]*, order: const u32[]) -> !:
    if order.length == 0: return
    var first = Growing[u32]()
    defer first.close()
    for name in order:
        var present = false
        for known in names.view(): present = present or known == name
        var repeated = false
        for known in first.view(): repeated = repeated or known == name
        if present and not repeated: try first.push(name)
    var rest = Growing[u32]()
    defer rest.close()
    for name in names.view():
        var listed = false
        for known in first.view(): listed = listed or known == name
        if not listed: try rest.push(name)
    names.clear()
    for name in first.view(): try names.push(name)
    for name in rest.view(): try names.push(name)