Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.3

0.9.3 / src / usda / writer / prims.lucb

## Prims (Sdf_WritePrim and its parts): the preamble `def Type "name"`, the
## metadata section (comment, then fields in dictionary order, with the
## arcs, variant sets and selections, relocates and substitutions in their
## own syntax), the body (reorder statements, properties in dictionary
## order, children, variant sets), and variant sets with their variants.

extend Writer:
    func write_prim(spec: usize, indent: usize) -> !:
        let prim = self.layer.spec(spec)
        var specifier = specifier_over
        if let value = prim.get(self.keys.specifier): specifier = value.bits
        try self.indent(indent)
        if specifier == specifier_def: try self.put("def")
        elif specifier == specifier_class: try self.put("class")
        else: try self.put("over")
        # A non-defining specifier writes a type only when one is set.
        if let type_name = prim.get(self.keys.type_name):
            let text = self.text(type_name.as_token())
            if text.length > 0 and text != "__AnyType__":
                try self.byte(' ')
                try self.put(text)
        try self.byte(' ')
        try self.quoted(self.names.name_text(prim.path))
        try self.prim_metadata(spec, indent)
        try self.put("\n")
        try self.indent(indent)
        try self.put("{\n")
        try self.prim_body(spec, indent)
        try self.indent(indent)
        try self.put("}\n")

    ## ` (\n ... )` when the prim has a comment or metadata.
    func prim_metadata(spec: usize, indent: usize) -> !:
        let prim = self.layer.spec(spec)
        var fields = Growing[u32]()
        defer fields.close()
        try self.metadata_fields(prim, prim_extra, &fields)
        var comment = ""
        if let value = prim.get(self.keys.comment): comment = self.text(value.as_token())
        if comment.length == 0 and fields.count == 0: return
        try self.put(" (\n")
        if comment.length > 0:
            try self.indent(indent + 1)
            try self.quoted(comment)
            try self.put("\n")
        for name in fields.view():
            let value = prim.get(name) else continue
            if name == self.keys.documentation:
                try self.indent(indent + 1)
                try self.put("doc = ")
                try self.quoted(self.text(value.as_token()))
                try self.put("\n")
            elif name == self.keys.permission:
                try self.indent(indent + 1)
                try self.put("permission = private\n" if value.bits == permission_private else "permission = public\n")
            elif name == self.keys.symmetry_function:
                try self.indent(indent + 1)
                try self.put("symmetryFunction = ")
                try self.token_text(value.as_token())
                try self.put("\n")
            elif name == self.keys.payload:
                try self.list_op(indent + 1, "payload", value)
            elif name == self.keys.references:
                try self.list_op(indent + 1, "references", value)
            elif name == self.keys.variant_set_names:
                try self.variant_set_names(indent + 1, value)
            elif name == self.keys.inherit_paths:
                try self.list_op(indent + 1, "inherits", value)
            elif name == self.keys.specializes:
                try self.list_op(indent + 1, "specializes", value)
            elif name == self.keys.relocates:
                try self.prim_relocates(indent + 1, prim.path, value)
            elif name == self.keys.prefix_substitutions:
                try self.indent(indent + 1)
                try self.put("prefixSubstitutions = ")
                try self.dictionary(indent + 1, value, true)
            elif name == self.keys.suffix_substitutions:
                try self.indent(indent + 1)
                try self.put("suffixSubstitutions = ")
                try self.dictionary(indent + 1, value, true)
            elif name == self.keys.variant_selection:
                if value.count > 0:
                    try self.indent(indent + 1)
                    try self.put("variants = ")
                    try self.variant_selections(indent + 1, value)
            else:
                try self.simple_field(indent + 1, name, value)
        try self.indent(indent)
        try self.put(")")

    ## `variantSets = ...` lines, explicit or per list op part.
    func variant_set_names(indent: usize, value: const Value*) -> !:
        let list = value.list_op() else return
        if list.explicit:
            try self.indent(indent)
            try self.put("variantSets = ")
            try self.name_items(list.items(ListPart.explicit))
            try self.put("\n")
            return
        try self.variant_set_part(indent, "delete variantSets = ", list.items(ListPart.deleted))
        try self.variant_set_part(indent, "add variantSets = ", list.items(ListPart.added))
        try self.variant_set_part(indent, "prepend variantSets = ", list.items(ListPart.prepended))
        try self.variant_set_part(indent, "append variantSets = ", list.items(ListPart.appended))
        try self.variant_set_part(indent, "reorder variantSets = ", list.items(ListPart.ordered))

    func variant_set_part(indent: usize, lead: str, items: const ListItem[]) -> !:
        if items.length == 0: return
        try self.indent(indent)
        try self.put(lead)
        try self.name_items(items)
        try self.put("\n")

    ## A name vector: one quoted name, or `["a", "b"]`.
    func name_items(items: const ListItem[]) -> !:
        if items.length > 1: try self.byte('[')
        for index in 0..<items.length:
            if index > 0: try self.put(", ")
            try self.quoted(self.text((u32)items[index].a))
        if items.length > 1: try self.byte(']')

    func name_vector(ids: const u32[]) -> !:
        if ids.length > 1: try self.byte('[')
        for index in 0..<ids.length:
            if index > 0: try self.put(", ")
            try self.quoted(self.text(ids[index]))
        if ids.length > 1: try self.byte(']')

    ## Reorders, properties, children and variant sets.
    func prim_body(spec: usize, indent: usize) -> !:
        let prim = self.layer.spec(spec)
        if let order = prim.get(self.keys.property_order):
            if order.count > 1:
                try self.indent(indent + 1)
                try self.put("reorder properties = ")
                try self.name_vector(order.ids())
                try self.put("\n")
        if let order = prim.get(self.keys.prim_order):
            if order.count > 1:
                try self.indent(indent + 1)
                try self.put("reorder nameChildren = ")
                try self.name_vector(order.ids())
                try self.put("\n")
        var properties = Growing[usize]()
        defer properties.close()
        if let names = prim.get(self.keys.properties):
            for name in names.ids():
                let path = try self.names.property(prim.path, name)
                if let found = self.layer.find(path): try properties.push(found)
        try self.sort_properties(&properties)
        for property in properties.view():
            if self.layer.spec(property).kind == SpecType.attribute: try self.write_attribute(property, indent + 1)
            else: try self.write_relationship(property, indent + 1)
        var children = Growing[usize]()
        defer children.close()
        if let names = prim.get(self.keys.prim_children):
            for name in names.ids():
                let path = try self.names.child(prim.path, name)
                if let found = self.layer.find(path): try children.push(found)
        if properties.count > 0 and children.count > 0: try self.put("\n")
        for index in 0..<children.count:
            if index > 0: try self.put("\n")
            try self.write_prim(children.items[index], indent + 1)
        if let sets = prim.get(self.keys.variant_set_children):
            for name in sets.ids():
                let path = try self.names.variant(prim.path, name, 0)
                if let found = self.layer.find(path): try self.write_variant_set(found, name, prim.path, indent + 1)

    ## Properties by name in dictionary order, attributes before
    ## relationships of the same name.
    func sort_properties(properties: Growing[usize]*) -> !:
        for index in 1..<properties.count:
            let current = properties.items[index]
            var at = index
            while at > 0 and self.property_less(current, properties.items[at - 1]):
                properties.items[at] = properties.items[at - 1]
                at -= 1
            properties.items[at] = current

    func property_less(left: usize, right: usize) -> bool:
        let a = self.layer.spec(left)
        let b = self.layer.spec(right)
        let a_name = self.names.name_text(a.path)
        let b_name = self.names.name_text(b.path)
        if a_name == b_name: return (u8)a.kind < (u8)b.kind
        return dictionary_less(a_name, b_name)

    ## `variantSet "name" = { ... }` with its variants in name order.
    func write_variant_set(spec: usize, name: u32, prim: u32, indent: usize) -> !:
        let set = self.layer.spec(spec)
        var variants = Growing[usize]()
        defer variants.close()
        if let names = set.get(self.keys.variant_children):
            for variant in names.ids():
                let path = try self.names.variant(prim, name, variant)
                if let found = self.layer.find(path): try variants.push(found)
        if variants.count == 0: return
        for index in 1..<variants.count:
            let current = variants.items[index]
            var at = index
            while at > 0 and byte_less(self.variant_name(current), self.variant_name(variants.items[at - 1])):
                variants.items[at] = variants.items[at - 1]
                at -= 1
            variants.items[at] = current
        try self.indent(indent)
        try self.put("variantSet ")
        try self.quoted(self.text(name))
        try self.put(" = {\n")
        for variant in variants.view(): try self.write_variant(variant, indent + 1)
        try self.indent(indent)
        try self.put("}\n")

    func variant_name(spec: usize) -> str:
        return self.text(self.names.node(self.layer.spec(spec).path).extra)

    func write_variant(spec: usize, indent: usize) -> !:
        try self.indent(indent)
        try self.quoted(self.variant_name(spec))
        try self.prim_metadata(spec, indent)
        try self.put(" {\n")
        try self.prim_body(spec, indent)
        try self.put("\n")
        try self.indent(indent)
        try self.put("}\n")

## A prim's metadata section also takes these fields, and not typeName.
func prim_extra(keys: FieldKeys, name: u32) -> bool:
    return name == keys.payload or name == keys.references or name == keys.relocates or name == keys.inherit_paths or name == keys.specializes or name == keys.variant_set_names or name == keys.variant_selection

extend Writer:
    ## A prim's relocates, each path relative to the prim.
    func prim_relocates(indent: usize, prim: u32, value: const Value*) -> !:
        let pairs = value.ids()
        var column = try Column[u8].allocate(pairs.length * 4)
        let relative = column.span()
        for index in 0..<pairs.length:
            let path = pairs[index]
            var made = empty_path
            if path != empty_path: made = try self.names.make_relative(path, prim)
            memory.write[u32]((void*)&relative[index * 4], made)
        # A relocates map is ordered by its (relative) source paths.
        let count = pairs.length // 2
        for index in 1..<count:
            let source = memory.read[u32]((void*)&relative[index * 8])
            let target = memory.read[u32]((void*)&relative[index * 8 + 4])
            var at = index
            while at > 0 and self.names.path_less(source, memory.read[u32]((void*)&relative[(at - 1) * 8])):
                memory.write[u64]((void*)&relative[at * 8], memory.read[u64]((void*)&relative[(at - 1) * 8]))
                at -= 1
            memory.write[u32]((void*)&relative[at * 8], source)
            memory.write[u32]((void*)&relative[at * 8 + 4], target)
        var relative_value = Value.of_records(ValueKind.relocates, value.count, column)
        defer relative_value.release()
        try self.relocates(indent, true, &relative_value)