dymokomi/luce-usd
Source of release 0.9.4
0.9.4 / src / usda / writer / values.lucb
## Values as text (Sdf_FileIOUtility::StringFromVtValue, WriteDictionary,
## WriteListOp, WriteTimeSamples, WriteRelocates, WriteLayerOffset): numbers
## as TfStringify gives them (shortest doubles and floats, "%g" halves,
## bools as 1 and 0), tuples `(a, b)`, matrices `( (a, b), (c, d) )`,
## arrays `[a, b]` on one line, strings and tokens quoted, assets @...@.
extend Writer:
## A field in a metadata section: `name = value`, list ops per part.
func simple_field(indent: usize, name: u32, value: const Value*) -> !:
match value.kind:
.int_list_op, .int64_list_op, .uint_list_op, .uint64_list_op, .string_list_op, .token_list_op, .unregistered_value_list_op:
try self.list_op(indent, self.text(name), value)
return
_: _ = 0
try self.indent(indent)
try self.token_text(name)
try self.put(" = ")
if value.kind == ValueKind.unregistered_value:
if value.object != none:
let dictionary = Value.of_object(ValueKind.dictionary, value.object else trap("dictionary"))
try self.dictionary(indent, &dictionary, false)
return
try self.token_text(value.as_token())
try self.put("\n")
return
if value.kind == ValueKind.dictionary:
try self.dictionary(indent, value, false)
return
if value.kind == ValueKind.boolean and not value.array:
try self.put("true\n" if value.as_bool() else "false\n")
return
try self.value(value)
try self.put("\n")
## StringFromVtValue: an attribute value, a value block, an array.
func value(value: const Value*) -> !:
match value.kind:
.value_block:
try self.put("None")
return
.unregistered_value:
try self.token_text(value.as_token())
return
.animation_block:
try self.put("AnimationBlock")
return
.array_edit:
try self.array_edit_text(value)
return
.token_vector, .string_vector:
try self.byte('[')
let ids = value.ids()
for index in 0..<ids.length:
if index > 0: try self.put(", ")
try self.quoted(self.text(ids[index]))
try self.byte(']')
return
.double_vector:
try self.byte('[')
let doubles = value.doubles()
for index in 0..<doubles.length:
if index > 0: try self.put(", ")
try numbers.write_double(self.out, doubles[index])
try self.byte(']')
return
_: _ = 0
let size = element_bytes(value.kind)
if size == 0: error(errors.unsupported, "a value this writer cannot print")
if value.array and numeric(value.kind):
if let text = self.preformatted.find(value.bytes()):
try self.byte('[')
try put_bytes(self.out, text)
try self.byte(']')
return
try format_array(value.kind, value.bytes(), value.count, self.out)
return
if value.array:
let bytes = value.bytes()
try self.byte('[')
for index in 0..<value.count:
if index > 0: try self.put(", ")
try self.element(value.kind, &bytes[index * size])
try self.byte(']')
return
if components(value.kind) <= 1:
var bits = value.bits
try self.element(value.kind, (const u8*)&bits)
return
try self.element(value.kind, &value.bytes()[0])
## One element of `kind` stored at `at`.
func element(kind: ValueKind, at: const u8*) -> !:
match kind:
.string, .token, .path_expression:
try self.quoted(self.text(memory.read[u32]((void*)at)))
.asset:
try asset_into(self.out, self.text(memory.read[u32]((void*)at)))
.boolean:
try self.byte('1' if memory.read[u8]((void*)at) != 0 else '0')
.uchar:
try self.number(ValueKind.uchar, at)
.matrix2d, .matrix3d, .matrix4d:
let rows: usize = 2 if kind == ValueKind.matrix2d else (3 if kind == ValueKind.matrix3d else 4)
try self.put("( ")
for row in 0..<rows:
if row > 0: try self.put(", ")
try self.byte('(')
for column in 0..<rows:
if column > 0: try self.put(", ")
try numbers.write_double(self.out, memory.read[f64]((void*)(at + (row * rows + column) * 8)))
try self.byte(')')
try self.put(" )")
_:
let count = components(kind)
if count <= 1:
try self.number(kind, at)
return
let scalar = scalar_of(kind)
let size = element_bytes(scalar)
let quaternion = kind == ValueKind.quatd or kind == ValueKind.quatf or kind == ValueKind.quath
try self.byte('(')
for index in 0..<count:
if index > 0: try self.put(", ")
# Quaternions print (real, i, j, k); memory holds i, j, k, real.
let source = (index + 3) % 4 if quaternion else index
try self.number(scalar, at + source * size)
try self.byte(')')
## One scalar number.
func number(kind: ValueKind, at: const u8*) -> !:
match kind:
.double, .time_code: try numbers.write_double(self.out, memory.read[f64]((void*)at))
.float: try numbers.write_float(self.out, memory.read[f32]((void*)at))
.half: try numbers.write_half(self.out, memory.read[u16]((void*)at))
.int: try self.integer(memory.read[i32]((void*)at))
.uint: try self.unsigned((u64)memory.read[u32]((void*)at))
.uchar: try self.unsigned((u64)memory.read[u8]((void*)at))
.int64: try self.integer(memory.read[i64]((void*)at))
.uint64: try self.unsigned(memory.read[u64]((void*)at))
.boolean: try self.byte('1' if memory.read[u8]((void*)at) != 0 else '0')
_: error(errors.unsupported, "a number kind this writer cannot print")
func integer(value: i64) -> !:
var digits: u8[20]
var count: usize = 0
var rest: u64 = (u64)value if value >= 0 else (u64)(-%value)
while true:
digits[count] = (u8)(48 + rest % 10)
count += 1
rest = rest // 10
if rest == 0: break
if value < 0: try self.byte('-')
while count > 0:
count -= 1
try self.byte(digits[count])
func unsigned(value: u64) -> !:
var digits: u8[20]
var count: usize = 0
var rest = value
while true:
digits[count] = (u8)(48 + rest % 10)
count += 1
rest = rest // 10
if rest == 0: break
while count > 0:
count -= 1
try self.byte(digits[count])
## `{\n ... }\n`: keys in byte order, `dictionary k = {...}` nested,
## `type k = value` otherwise; `"k": "v"` pairs when `strings_only`.
func dictionary(indent: usize, value: const Value*, strings_only: bool) -> !:
let dictionary = value.dictionary() else return
var order = Growing[usize]()
defer order.close()
try self.key_order(dictionary, &order)
try self.put("{\n")
var remaining = order.count
for index in order.view():
remaining -= 1
let key = self.text(dictionary.keys.items[index])
let entry = &dictionary.values.items[index]
if strings_only:
if entry.kind != ValueKind.string: continue
try self.indent(indent + 1)
try self.quoted(key)
try self.put(": ")
try self.quoted(self.text(entry.as_token()))
if remaining > 0: try self.put(", ")
try self.put("\n")
continue
if entry.kind == ValueKind.dictionary:
try self.indent(indent + 1)
try self.put("dictionary ")
try self.key(key)
try self.put(" = ")
try self.dictionary(indent + 1, entry, false)
continue
try self.indent(indent + 1)
try self.value_type(entry)
try self.byte(' ')
try self.key(key)
try self.put(" = ")
if entry.kind == ValueKind.path_expression:
# TfStringify prints path expressions in dictionaries unquoted.
try self.bare_expressions(entry)
else:
try self.value(entry)
try self.put("\n")
try self.indent(indent)
try self.put("}\n")
## `{ type k = value; ... }` on one line (WriteDictionary with
## multiLine false), as knot custom data is written.
func inline_dictionary(value: const Value*) -> !:
let dictionary = value.dictionary() else return
var order = Growing[usize]()
defer order.close()
try self.key_order(dictionary, &order)
try self.put("{ ")
for at in 0..<order.count:
if at > 0: try self.put("; ")
let index = order.items[at]
let key = self.text(dictionary.keys.items[index])
let entry = &dictionary.values.items[index]
if entry.kind == ValueKind.dictionary:
try self.put("dictionary ")
try self.key(key)
try self.put(" = ")
try self.inline_dictionary(entry)
continue
try self.value_type(entry)
try self.byte(' ')
try self.key(key)
try self.put(" = ")
try self.value(entry)
try self.put(" }")
## The dictionary's entry indices, by key in byte order (a std::map).
func key_order(dictionary: const Dictionary*, order: Growing[usize]*) -> !:
for index in 0..<dictionary.count(): try order.push(index)
for index in 1..<order.count:
let current = order.items[index]
var at = index
while at > 0 and byte_less(self.text(dictionary.keys.items[current]), self.text(dictionary.keys.items[order.items[at - 1]])):
order.items[at] = order.items[at - 1]
at -= 1
order.items[at] = current
## A path expression value, or an array of them, without quotes.
func bare_expressions(value: const Value*) -> !:
if not value.array:
try self.token_text(value.as_token())
return
try self.byte('[')
let bytes = value.bytes()
for index in 0..<value.count:
if index > 0: try self.put(", ")
try self.token_text(memory.read[u32]((void*)&bytes[index * 4]))
try self.byte(']')
## A dictionary key: bare when it is an identifier, quoted otherwise.
func key(text: str) -> !:
if is_identifier(text): try self.put(text)
else: try self.quoted(text)
## The serialization type name of a dictionary value.
func value_type(value: const Value*) -> !:
var name = ""
match value.kind:
.boolean: name = "bool"
.uchar: name = "uchar"
.int: name = "int"
.uint: name = "uint"
.int64: name = "int64"
.uint64: name = "uint64"
.half: name = "half"
.float: name = "float"
.double: name = "double"
.time_code: name = "timecode"
.string, .string_vector: name = "string"
.token, .token_vector: name = "token"
.asset: name = "asset"
.path_expression: name = "pathExpression"
.vec2d: name = "double2"
.vec3d: name = "double3"
.vec4d: name = "double4"
.vec2f: name = "float2"
.vec3f: name = "float3"
.vec4f: name = "float4"
.vec2h: name = "half2"
.vec3h: name = "half3"
.vec4h: name = "half4"
.vec2i: name = "int2"
.vec3i: name = "int3"
.vec4i: name = "int4"
.quatd: name = "quatd"
.quatf: name = "quatf"
.quath: name = "quath"
.matrix2d: name = "matrix2d"
.matrix3d: name = "matrix3d"
.matrix4d: name = "matrix4d"
.double_vector: name = "double"
_: error(errors.unsupported, "a dictionary value type this writer cannot name")
try self.put(name)
if value.array or value.kind == ValueKind.string_vector or value.kind == ValueKind.token_vector or value.kind == ValueKind.double_vector:
try self.put("[]")
## A list op field, explicit or one line per part: `op name = items`.
func list_op(indent: usize, name: str, value: const Value*) -> !:
let list = value.list_op() else return
if list.explicit:
try self.list_part(indent, name, "", value.kind, list.items(ListPart.explicit))
return
if list.items(ListPart.deleted).length > 0: try self.list_part(indent, name, "delete", value.kind, list.items(ListPart.deleted))
if list.items(ListPart.added).length > 0: try self.list_part(indent, name, "add", value.kind, list.items(ListPart.added))
if list.items(ListPart.prepended).length > 0: try self.list_part(indent, name, "prepend", value.kind, list.items(ListPart.prepended))
if list.items(ListPart.appended).length > 0: try self.list_part(indent, name, "append", value.kind, list.items(ListPart.appended))
if list.items(ListPart.ordered).length > 0: try self.list_part(indent, name, "reorder", value.kind, list.items(ListPart.ordered))
## One list op part (_WriteListOpList): paths, references and payloads
## one per line, a single path or payload without brackets; tokens,
## strings and numbers on one line in brackets.
func list_part(indent: usize, name: str, op: str, kind: ValueKind, items: const ListItem[]) -> !:
try self.indent(indent)
if op.length > 0:
try self.put(op)
try self.byte(' ')
try self.put(name)
try self.put(" = ")
if items.length == 0:
try self.put("None\n")
return
let per_line = kind == ValueKind.path_list_op or kind == ValueKind.reference_list_op or kind == ValueKind.payload_list_op
if items.length == 1 and not Writer.needs_brackets(kind, items[0]):
try self.list_item(0, kind, items[0])
try self.put("\n")
return
try self.put("[\n" if per_line else "[")
for index in 0..<items.length:
try self.list_item(indent + 1 if per_line else 0, kind, items[index])
if index + 1 < items.length: try self.put(",\n" if per_line else ", ")
elif per_line: try self.put("\n")
if per_line: try self.indent(indent)
try self.put("]\n")
static func needs_brackets(kind: ValueKind, item: ListItem) -> bool:
match kind:
.path_list_op, .payload_list_op: return false
.reference_list_op:
let custom = item.custom else return false
return custom.count() > 0
_: return true
func list_item(indent: usize, kind: ValueKind, item: ListItem) -> !:
match kind:
.token_list_op, .string_list_op:
try self.indent(indent)
try self.quoted(self.text((u32)item.a))
.unregistered_value_list_op:
try self.indent(indent)
try self.token_text((u32)item.a)
.path_list_op:
try self.indent(indent)
try self.path_ref((u32)item.a)
.int_list_op, .int64_list_op:
try self.indent(indent)
try self.integer((i64)item.a)
.uint_list_op, .uint64_list_op:
try self.indent(indent)
try self.unsigned(item.a)
.reference_list_op, .payload_list_op:
try self.reference(indent, kind == ValueKind.reference_list_op, item)
_: error(errors.unsupported, "a list op this writer cannot print")
## A reference or payload: `@asset@<path>` or `<path>`, its layer
## offset, and a reference's custom data in a multi-line block.
func reference(indent: usize, is_reference: bool, item: ListItem) -> !:
var custom: const Dictionary*? = none
if is_reference:
if let found = item.custom:
if found.count() > 0: custom = found
let multiline = custom != none
try self.indent(indent)
if item.a != 0 and self.text((u32)item.a).length > 0:
try asset_into(self.out, self.text((u32)item.a))
if (u32)item.b != empty_path: try self.path_ref((u32)item.b)
else:
try self.path_ref((u32)item.b)
if multiline: try self.put(" (\n")
try self.layer_offset(indent + 1, multiline, item.offset, item.scale)
if let data = custom:
try self.indent(indent + 1)
try self.put("customData = ")
let value = Value.of_object(ValueKind.dictionary, (void*)data)
try self.dictionary(indent + 1, &value, false)
if multiline:
try self.indent(indent)
try self.put(")")
## ` (offset = o; scale = s)` or offset/scale lines, when not identity.
func layer_offset(indent: usize, multiline: bool, offset: f64, scale: f64) -> !:
if offset == 0.0 and scale == 1.0: return
if not multiline: try self.put(" (")
if offset != 0.0:
if multiline: try self.indent(indent)
try self.put("offset = ")
try numbers.write_double(self.out, offset)
if multiline: try self.put("\n")
if scale != 1.0:
if not multiline and offset != 0.0: try self.put("; ")
if multiline: try self.indent(indent)
try self.put("scale = ")
try numbers.write_double(self.out, scale)
if multiline: try self.put("\n")
if not multiline: try self.byte(')')
## Time samples, one `time: value,` line each.
func time_samples(indent: usize, value: const Value*) -> !:
let samples = value.time_samples() else return
for index in 0..<samples.count():
try self.indent(indent + 1)
try numbers.write_double(self.out, samples.times.items[index])
try self.put(": ")
try self.value(&samples.values.items[index])
try self.put(",\n")
## `relocates = { <a>: <b>, ... }`.
func relocates(indent: usize, multiline: bool, value: const Value*) -> !:
try self.indent(indent)
try self.put("relocates = {\n" if multiline else "relocates = { ")
let pairs = value.ids()
let count = pairs.length // 2
for index in 0..<count:
if multiline: try self.indent(indent + 1)
try self.path_ref(pairs[index * 2])
try self.put(": ")
try self.path_ref(pairs[index * 2 + 1])
if index + 1 < count: try self.put(", ")
if multiline: try self.put("\n")
if multiline:
try self.indent(indent)
try self.put("}\n")
else:
try self.put(" }")
## `variants = { string set = "selection" ... }`.
func variant_selections(indent: usize, value: const Value*) -> !:
let pairs = value.ids()
let count = pairs.length // 2
var order = Growing[usize]()
defer order.close()
for index in 0..<count: try order.push(index)
for index in 1..<order.count:
let current = order.items[index]
var at = index
while at > 0 and byte_less(self.text(pairs[current * 2]), self.text(pairs[order.items[at - 1] * 2])):
order.items[at] = order.items[at - 1]
at -= 1
order.items[at] = current
try self.put("{\n")
for index in order.view():
try self.indent(indent + 1)
try self.put("string ")
try self.key(self.text(pairs[index * 2]))
try self.put(" = ")
try self.quoted(self.text(pairs[index * 2 + 1]))
try self.put("\n")
try self.indent(indent)
try self.put("}\n")
## Whether `text` is a valid identifier (TfIsValidIdentifier: ASCII letters,
## digits and underscores, not starting with a digit).
func is_identifier(text: str) -> bool:
if text.length == 0: return false
let first = text.bytes[0]
if not ((first >= 'a' and first <= 'z') or (first >= 'A' and first <= 'Z') or first == '_'): return false
for byte in text.bytes:
if not ((byte >= 'a' and byte <= 'z') or (byte >= 'A' and byte <= 'Z') or (byte >= '0' and byte <= '9') or byte == '_'): return false
return true