dymokomi/luce-usd
Source of release 0.9.6
0.9.6 / src / pcp / layer_stack.lucb
## Layer stacks, after PcpLayerStack::_BuildLayerStack (pxr/usd/pcp/
## layerStack.cpp): a session layer's tree (when there is one), then the
## root layer's, each layer followed by its sublayers depth first, strongest
## first. Every layer carries the offset mapping its times into the root's:
## its sublayer offset composed with its parent's, and scaled when its
## timeCodesPerSecond differs. A sublayer that is missing or already an
## ancestor (a cycle) is skipped with an error; the same layer may appear
## twice on different branches. Its relocations come from its layers'
## layerRelocates (relocations.lucb). Its expression variables
## (PcpExpressionVariables) are the root layer's expressionVariables, the
## session layer's over them, and those of the layer stack that references
## it over both; a sublayer path may be an expression over them.
## One layer stack.
pub struct LayerStack:
pub var root: usize
pub var session: usize?
pub var layers: Growing[usize]
pub var offsets: Growing[Offset]
pub var time_codes_per_second: f64
pub var relocates: Growing[Relocate]
## The variables (a dictionary value), the stack that last changed
## them, and the stack whose variables override its own (part of its
## identity); none stands for the root layer stack (the first built).
pub var variables: Value
pub var source: usize?
pub var overrides: usize?
pub func close():
self.layers.close()
self.offsets.close()
self.relocates.close()
self.variables.release()
## Whether any layer's offset is not the identity.
pub func has_offsets() -> bool:
for offset in self.offsets.view():
if not offset.is_identity(): return true
return false
## Every layer stack a composition has built, each once.
pub struct Stacks:
var stacks: Growing[LayerStack]
pub func init():
self.stacks = Growing[LayerStack]()
pub func close():
for at in 0..<self.stacks.count: self.stacks.items[at].close()
self.stacks.close()
pub func stack(index: usize) -> const LayerStack*:
return &self.stacks.items[index]
## The layer stack of root layer `root` (and `session`) whose variables
## `overrides` (a stack's variables source) overrides, built now if new.
pub func find_or_build(layers: Layers*, root: usize, session: usize?, overrides: usize?, problems: Problems*) -> usize!:
for at in 0..<self.stacks.count:
let stack = &self.stacks.items[at]
if stack.root == root and stack.session == session and stack.overrides == overrides: return at
var stack = LayerStack(root = root, session = session, layers = Growing[usize](), offsets = Growing[Offset](), time_codes_per_second = layers.time_codes_per_second(root), relocates = Growing[Relocate](), variables = Value.marker(ValueKind.empty), source = none, overrides = overrides)
errdefer stack.close()
try self.compose_variables(layers, &stack)
var seen = Growing[usize]()
defer seen.close()
var root_offset = Offset.identity()
if let owner = session:
let session_rate = layers.time_codes_per_second(owner)
var session_offset = Offset.identity()
if session_governs(layers, owner, root):
stack.time_codes_per_second = session_rate
root_offset.scale = session_rate / layers.time_codes_per_second(root)
else:
session_offset.scale = stack.time_codes_per_second / session_rate
try build(layers, owner, session_offset, session_rate, 0, &stack, &seen, problems)
# The session tree's first sessionOwner reorders owned sublayers.
var session_owner: u32 = 0
let owner_key = try layers.names.token("sessionOwner")
for layer in stack.layers.view():
if session_owner != 0: break
if let found = layers.field(layer, owner_key): session_owner = found.as_token()
try build(layers, root, root_offset, layers.time_codes_per_second(root), session_owner, &stack, &seen, problems)
try compute_relocations(layers, &stack, problems)
try self.stacks.push(stack)
return self.stacks.count - 1
extend Stacks:
## The stack's expression variables (Pcp_ComposeExpressionVariablesOver):
## later sources win; the source stays the overriding stack's when
## nothing changed.
func compose_variables(layers: Layers*, stack: LayerStack*) -> !:
let made = try Dictionary.create()
stack.variables = Value.of_object(ValueKind.dictionary, (void*)made)
let key = layers.layer(stack.root).keys.expression_variables
if let found = layers.field(stack.root, key): try over(made, found)
if let session = stack.session:
if let found = layers.field(session, key): try over(made, found)
# The root layer stack's own variables are the base of the others.
if self.stacks.count == 0: return
let overrides = stack.overrides else 0
let base = &self.stacks.items[overrides].variables
try over(made, base)
if not same_entries(made, base.dictionary()): stack.source = self.stacks.count
else: stack.source = self.stacks.items[overrides].source
## Put `stronger`'s entries over `into` (VtDictionaryOver).
func over(into: Dictionary*, stronger: const Value*) -> !:
let held = stronger.dictionary() else return
for at in 0..<held.keys.count: try into.put(held.keys.items[at], held.values.items[at].share())
## Whether two dictionaries hold the same entries, in any order.
func same_entries(a: const Dictionary*, b: const Dictionary*?) -> bool:
let other = b else return a.count() == 0
if a.count() != other.count(): return false
for at in 0..<a.keys.count:
let found = other.find(a.keys.items[at]) else return false
if not same(&a.values.items[at], found): return false
return true
## Whether a session layer's own rate governs the stack
## (_ShouldUseSessionTcps): it authors timeCodesPerSecond, or the root does
## not and the session authors framesPerSecond.
func session_governs(layers: const Layers*, session: usize, root: usize) -> bool:
let keys = &layers.layer(session).keys
if layers.field(session, keys.time_codes_per_second) != none: return true
return layers.field(root, keys.time_codes_per_second) == none and layers.field(session, keys.frames_per_second) != none
## One sublayer about to be built into the stack.
struct Sublayer:
var layer: usize
var offset: Offset
var rate: f64
func build(layers: Layers*, layer: usize, offset: Offset, rate: f64, session_owner: u32, stack: LayerStack*, seen: Growing[usize]*, problems: Problems*) -> !:
try seen.push(layer)
defer seen.count -= 1
try stack.layers.push(layer)
try stack.offsets.push(offset)
let keys = &layers.layer(layer).keys
let found = layers.field(layer, keys.sub_layers) else return
let paths = found.ids()
var no_offsets: f64[]
var offsets: const f64[] = no_offsets
if let recorded = layers.field(layer, keys.sub_layer_offsets): offsets = recorded.doubles()
var identifier = Growing[u8]()
defer identifier.close()
var sublayers = Growing[Sublayer]()
defer sublayers.close()
for at in 0..<paths.length:
var asset = layers.names.text_of(paths[at])
if is_expression(asset):
# Expressions evaluating to nothing (or failing) are skipped.
asset = layers.names.text_of(try evaluate_to_string(layers.names, asset, &stack.variables))
if asset.length == 0: continue
try ar.anchored(asset, layers.identifier(layer), &identifier)
let opened = try layers.find_or_open((str)identifier.view())
if opened == none:
try problems.add_with("Could not load sublayer @", (str)identifier.view())
continue
let sublayer = opened else continue
var cycle = false
for ancestor in seen.view(): cycle = cycle or ancestor == sublayer
if cycle:
try problems.add_with("Sublayer cycle through @", (str)identifier.view())
continue
var own = Offset.identity()
if at * 2 + 1 < offsets.length: own = Offset(offset = offsets[at * 2], scale = offsets[at * 2 + 1])
if not own.is_valid(): own = Offset.identity()
let sub_rate = layers.time_codes_per_second(sublayer)
if rate != sub_rate: own.scale = own.scale * rate / sub_rate
try sublayers.push(Sublayer(layer = sublayer, offset = offset.times(own), rate = sub_rate))
try own_first(layers, layer, session_owner, &sublayers)
for sublayer in sublayers.view():
try build(layers, sublayer.layer, sublayer.offset, sublayer.rate, session_owner, stack, seen, problems)
## The session owner's sublayers first, when the layer has owned sublayers
## (_ApplyOwnedSublayerOrder, a stable partition).
func own_first(layers: Layers*, layer: usize, session_owner: u32, sublayers: Growing[Sublayer]*) -> !:
if session_owner == 0: return
let owned = layers.field(layer, try layers.names.token("hasOwnedSubLayers")) else return
if not owned.as_bool(): return
let owner_key = try layers.names.token("owner")
var first = Growing[Sublayer]()
defer first.close()
var rest = Growing[Sublayer]()
defer rest.close()
for sublayer in sublayers.view():
var mine = false
if let found = layers.field(sublayer.layer, owner_key): mine = found.as_token() == session_owner
if mine: try first.push(sublayer)
else: try rest.push(sublayer)
sublayers.clear()
for sublayer in first.view(): try sublayers.push(sublayer)
for sublayer in rest.view(): try sublayers.push(sublayer)