dymokomi/luce-usd
Source of release 0.9.3
0.9.3 / 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)