Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.6

0.9.6 / src / sdf / layer_data.lucb

## A layer's contents, after OpenUSD's SdfData and SdfAbstractData
## (pxr/usd/sdf/data.cpp): specs keyed by path, each a spec type and a list
## of named fields. This is the whole of a layer; usda and usdc are two
## serializations of it, and composition reads it.
##
## Children are ordinary fields, as in Sdf: a prim's `primChildren` and
## `properties` token vectors, `variantSetChildren`, a variant set's
## `variantChildren`, a relationship's `targetChildren` path vector. The
## pseudo-root spec (`/`) holds the layer's metadata.
import memory
import errors
from sdf.names import Names, absolute_root
from sdf.values import Value
from sdf.value_types import ValueKind
from luce_geocore.core.growing import Growing

## SdfSpecType; the numbers are the crate's.
pub enum SpecType as u8:
    unknown = 0
    attribute = 1
    connection = 2
    expression = 3
    mapper = 4
    mapper_arg = 5
    prim = 6
    pseudo_root = 7
    relationship = 8
    relationship_target = 9
    variant = 10
    variant_set = 11

pub struct Field:
    pub var name: u32
    pub var value: Value

pub struct Spec:
    pub var path: u32
    pub var kind: SpecType
    pub var fields: Growing[Field]

    ## The value of the field `name`.
    pub func get(name: u32) -> const Value*?:
        for index in 0..<self.fields.count:
            if self.fields.items[index].name == name: return &self.fields.items[index].value
        return none

## The token ids of Sdf's field keys (SDF_FIELD_KEYS, SDF_CHILDREN_KEYS).
pub struct FieldKeys:
    pub var active: u32
    pub var allowed_tokens: u32
    pub var asset_info: u32
    pub var clips: u32
    pub var clip_sets: u32
    pub var color_configuration: u32
    pub var color_management_system: u32
    pub var color_space: u32
    pub var comment: u32
    pub var connection_paths: u32
    pub var custom: u32
    pub var custom_data: u32
    pub var custom_layer_data: u32
    pub var default: u32
    pub var default_prim: u32
    pub var display_group: u32
    pub var display_group_order: u32
    pub var display_name: u32
    pub var display_unit: u32
    pub var documentation: u32
    pub var end_time_code: u32
    pub var expression_variables: u32
    pub var frame_precision: u32
    pub var frames_per_second: u32
    pub var hidden: u32
    pub var has_owned_sub_layers: u32
    pub var inherit_paths: u32
    pub var instanceable: u32
    pub var kind: u32
    pub var layer_relocates: u32
    pub var limits: u32
    pub var prim_order: u32
    pub var no_load_hint: u32
    pub var owner: u32
    pub var payload: u32
    pub var permission: u32
    pub var prefix: u32
    pub var prefix_substitutions: u32
    pub var property_order: u32
    pub var references: u32
    pub var relocates: u32
    pub var session_owner: u32
    pub var specializes: u32
    pub var specifier: u32
    pub var spline: u32
    pub var start_time_code: u32
    pub var sub_layers: u32
    pub var sub_layer_offsets: u32
    pub var suffix: u32
    pub var suffix_substitutions: u32
    pub var symmetric_peer: u32
    pub var symmetry_arguments: u32
    pub var symmetry_function: u32
    pub var target_paths: u32
    pub var time_samples: u32
    pub var time_codes_per_second: u32
    pub var type_name: u32
    pub var variant_selection: u32
    pub var variability: u32
    pub var variant_set_names: u32
    pub var end_frame: u32
    pub var start_frame: u32
    pub var api_schemas: u32
    pub var connection_children: u32
    pub var expression_children: u32
    pub var mapper_arg_children: u32
    pub var mapper_children: u32
    pub var prim_children: u32
    pub var properties: u32
    pub var target_children: u32
    pub var variant_children: u32
    pub var variant_set_children: u32

    ## The keys, interned in `names`.
    pub static func of(names: Names*) -> FieldKeys!:
        return FieldKeys(
            active = try names.token("active"),
            allowed_tokens = try names.token("allowedTokens"),
            asset_info = try names.token("assetInfo"),
            clips = try names.token("clips"),
            clip_sets = try names.token("clipSets"),
            color_configuration = try names.token("colorConfiguration"),
            color_management_system = try names.token("colorManagementSystem"),
            color_space = try names.token("colorSpace"),
            comment = try names.token("comment"),
            connection_paths = try names.token("connectionPaths"),
            custom = try names.token("custom"),
            custom_data = try names.token("customData"),
            custom_layer_data = try names.token("customLayerData"),
            default = try names.token("default"),
            default_prim = try names.token("defaultPrim"),
            display_group = try names.token("displayGroup"),
            display_group_order = try names.token("displayGroupOrder"),
            display_name = try names.token("displayName"),
            display_unit = try names.token("displayUnit"),
            documentation = try names.token("documentation"),
            end_time_code = try names.token("endTimeCode"),
            expression_variables = try names.token("expressionVariables"),
            frame_precision = try names.token("framePrecision"),
            frames_per_second = try names.token("framesPerSecond"),
            hidden = try names.token("hidden"),
            has_owned_sub_layers = try names.token("hasOwnedSubLayers"),
            inherit_paths = try names.token("inheritPaths"),
            instanceable = try names.token("instanceable"),
            kind = try names.token("kind"),
            layer_relocates = try names.token("layerRelocates"),
            limits = try names.token("limits"),
            prim_order = try names.token("primOrder"),
            no_load_hint = try names.token("noLoadHint"),
            owner = try names.token("owner"),
            payload = try names.token("payload"),
            permission = try names.token("permission"),
            prefix = try names.token("prefix"),
            prefix_substitutions = try names.token("prefixSubstitutions"),
            property_order = try names.token("propertyOrder"),
            references = try names.token("references"),
            relocates = try names.token("relocates"),
            session_owner = try names.token("sessionOwner"),
            specializes = try names.token("specializes"),
            specifier = try names.token("specifier"),
            spline = try names.token("spline"),
            start_time_code = try names.token("startTimeCode"),
            sub_layers = try names.token("subLayers"),
            sub_layer_offsets = try names.token("subLayerOffsets"),
            suffix = try names.token("suffix"),
            suffix_substitutions = try names.token("suffixSubstitutions"),
            symmetric_peer = try names.token("symmetricPeer"),
            symmetry_arguments = try names.token("symmetryArguments"),
            symmetry_function = try names.token("symmetryFunction"),
            target_paths = try names.token("targetPaths"),
            time_samples = try names.token("timeSamples"),
            time_codes_per_second = try names.token("timeCodesPerSecond"),
            type_name = try names.token("typeName"),
            variant_selection = try names.token("variantSelection"),
            variability = try names.token("variability"),
            variant_set_names = try names.token("variantSetNames"),
            end_frame = try names.token("endFrame"),
            start_frame = try names.token("startFrame"),
            api_schemas = try names.token("apiSchemas"),
            connection_children = try names.token("connectionChildren"),
            expression_children = try names.token("expressionChildren"),
            mapper_arg_children = try names.token("mapperArgChildren"),
            mapper_children = try names.token("mapperChildren"),
            prim_children = try names.token("primChildren"),
            properties = try names.token("properties"),
            target_children = try names.token("targetChildren"),
            variant_children = try names.token("variantChildren"),
            variant_set_children = try names.token("variantSetChildren"),
        )

## A layer's specs. The Names it was made with must outlive it.
pub struct LayerData:
    pub var names: Names*
    pub var keys: FieldKeys
    var specs: Growing[Spec]
    ## Spec index + 1 per slot, 0 empty, keyed by path; a power of two.
    var slots: Growing[u32]

    ## An empty layer: the pseudo-root spec alone.
    pub func init(names: Names*) -> !:
        let keys = try FieldKeys.of(names)
        self.names = names
        self.keys = keys
        self.specs = Growing[Spec]()
        self.slots = Growing[u32]()
        errdefer:
            self.specs.close()
            self.slots.close()
        _ = try self.create_spec(absolute_root, SpecType.pseudo_root)

    pub func close():
        for index in 0..<self.specs.count:
            let spec = &self.specs.items[index]
            for field in 0..<spec.fields.count: spec.fields.items[field].value.release()
            spec.fields.close()
        self.specs.close()
        self.slots.close()

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

    ## Spec `index` (0 is the pseudo-root; creation order otherwise).
    pub func spec(index: usize) -> const Spec*:
        return &self.specs.items[index]

    ## The index of the spec at `path`.
    pub func find(path: u32) -> usize?:
        if self.slots.count == 0: return none
        let mask = self.slots.count - 1
        var slot = (usize)path_hash(path) & mask
        while self.slots.items[slot] != 0:
            let index = (usize)self.slots.items[slot] - 1
            if self.specs.items[index].path == path: return index
            slot = (slot + 1) & mask
        return none

    ## A new spec at `path`; fails when one exists.
    pub func create_spec(path: u32, kind: SpecType) -> usize!:
        if self.slots.count == 0 or (self.specs.count + 1) * 2 >= self.slots.count:
            try self.rehash(64 if self.slots.count == 0 else self.slots.count * 2)
        let mask = self.slots.count - 1
        var slot = (usize)path_hash(path) & mask
        while self.slots.items[slot] != 0:
            if self.specs.items[(usize)self.slots.items[slot] - 1].path == path:
                error(errors.invalid, "a spec already exists at this path")
            slot = (slot + 1) & mask
        try self.specs.push(Spec(path = path, kind = kind, fields = Growing[Field]()))
        self.slots.items[slot] = (u32)self.specs.count
        return self.specs.count - 1

    ## The field `name` of spec `index`.
    pub func get(index: usize, name: u32) -> const Value*?:
        return self.specs.items[index].get(name)

    ## Set the field `name` of spec `index` to `value` (taken).
    pub func set(index: usize, name: u32, value: Value) -> !:
        let spec = &self.specs.items[index]
        for at in 0..<spec.fields.count:
            if spec.fields.items[at].name == name:
                spec.fields.items[at].value.release()
                spec.fields.items[at].value = value
                return
        var owned = value
        errdefer owned.release()
        try spec.fields.push(Field(name = name, value = owned))

    ## Remove the field `name` of spec `index`, when present.
    pub func erase(index: usize, name: u32):
        let spec = &self.specs.items[index]
        for at in 0..<spec.fields.count:
            if spec.fields.items[at].name == name:
                spec.fields.items[at].value.release()
                var rest = at
                while rest + 1 < spec.fields.count:
                    spec.fields.items[rest] = spec.fields.items[rest + 1]
                    rest += 1
                spec.fields.count -= 1
                return

    func rehash(capacity: usize) -> !:
        try self.slots.fill(capacity, 0)
        let mask = capacity - 1
        for index in 0..<self.specs.count:
            var slot = (usize)path_hash(self.specs.items[index].path) & mask
            while self.slots.items[slot] != 0: slot = (slot + 1) & mask
            self.slots.items[slot] = (u32)index + 1

func path_hash(path: u32) -> u64:
    let key = (u64)path *% 0x9E3779B97F4A7C15
    return key ^ (key >> 31)