dymokomi/luce-usd
Source of release 0.9.2
0.9.2 / src / convert / export_extras.lucb
## What a Mesh prim carries besides primvars, written back from the
## attributes the import made: groups as GeomSubsets (the family from
## usd.subset_family.<group>), subdivision (scheme, boundary rule, creases
## as two-point chains, corners, holes) and material bindings (one
## material: bound on the prim; several: one materialBind subset each).
## The part's own number of mesh point `point`, or -1.
func local_point(part: const MeshPart*, numbers: const i32[], point: usize) -> i32:
if part.whole: return (i32)point
let at = numbers[point]
if at < 0 or (usize)at >= part.points.count or part.points.items[(usize)at] != (i32)point: return -1
return at
extend MeshExport:
## The edges edge attribute `attribute` marks, found on first use: the
## parts each take theirs from the list rather than every edge.
func marked_edges(attribute: i64) -> const u32[]!:
for list in self.marked.view():
if list.attribute == attribute: return list.edges.view()
var edges = Growing[u32]()
errdefer edges.close()
let entry = try self.mesh.attribute_entry(attribute)
if entry.is_group():
let bits = Bits.of_bytes(entry.data.view(), entry.elements)
for edge in 0..<entry.elements:
if bits.get(edge): try edges.push((u32)edge)
else:
for edge in 0..<entry.elements:
if entry.number(edge, 0) > 0.0: try edges.push((u32)edge)
try self.marked.push(MarkedEdges(attribute = attribute, edges = edges))
return self.marked.items[self.marked.count - 1].edges.view()
## Every face, point and edge group but `hole` as a GeomSubset of the part.
func write_subsets(work: MeshExport*, part: const MeshPart*, spec: usize, numbers: const i32[]) -> !:
let mesh = work.mesh
var members = Growing[i32]()
defer members.close()
var name = Growing[u8]()
defer name.close()
for index in 0..<(usize)mesh.attribute_count():
let entry = try mesh.attribute_entry((i64)index)
if not entry.is_group() or entry.name() == "hole": continue
let bits = Bits.of_bytes(entry.data.view(), entry.elements)
members.clear()
var element = "face"
match entry.domain:
.face:
for at in 0..<part.faces.count:
if bits.get((usize)part.faces.items[at]): try members.push((i32)at)
.point:
element = "point"
for at in 0..<part.point_count():
if bits.get(part.point_at(at)): try members.push((i32)at)
.edge:
element = "edge"
let pairs = try mesh.edge_span()
for edge in try work.marked_edges((i64)index):
let a = local_point(part, numbers, (usize)pairs[edge * 2])
let b = local_point(part, numbers, (usize)pairs[edge * 2 + 1])
if a < 0 or b < 0: continue
try members.push(a)
try members.push(b)
_: continue
if members.count == 0: continue
try valid_name(entry.name(), &name)
# Bindings are written from the material attribute (below); a group
# keeps its own materialBind family only when there is none.
var family = try subset_family(mesh, entry.name())
if family == "materialBind" and mesh.attribute_on("material", Domain.face) >= 0: family = ""
_ = try write_subset(work, part, (str)name.view(), element, members.view(), family)
## A GeomSubset child of the part; its path.
func write_subset(work: MeshExport*, part: const MeshPart*, name: str, element: str, members: const i32[], family: str) -> u32!:
let author = work.author
let path = try author.names.child(part.path, try author.names.token(name))
let spec = try author.define(path, work.tokens.geom_subset, work.tokens.xform)
_ = try author.attribute(path, spec, "elementType", "token", true, Value.scalar(ValueKind.token, (u64)(try author.names.token(element))))
_ = try author.attribute(path, spec, "indices", "int[]", false, try array_of(ValueKind.int, members.length, u8[]((u8*)members.data, members.length * 4)))
if family.length > 0: _ = try author.attribute(path, spec, "familyName", "token", true, Value.scalar(ValueKind.token, (u64)(try author.names.token(family))))
return path
## The subset family the import recorded for group `name` ("" without one).
func subset_family(mesh: const Mesh*, name: str) -> str!:
var label = Growing[u8]()
defer label.close()
try label.assign("usd.subset_family.".bytes)
for byte in name.bytes: try label.push(byte)
if label.count > 64: return ""
let found = mesh.attribute_on((str)label.view(), Domain.detail)
if found < 0: return ""
let entry = try mesh.attribute_entry(found)
if entry.kind != DataType.text: return ""
return entry.text_at(0)
## The subdivision scheme (always authored: USD's default is Catmull-Clark)
## and, when subdivided, the boundary rule, creases, corners and holes.
func write_subdivision(work: MeshExport*, part: const MeshPart*, spec: usize, numbers: const i32[]) -> !:
let mesh = work.mesh
let author = work.author
let scheme = detail_number(mesh, "subd.scheme", 0.0)
let text = "catmullClark" if scheme == 1.0 else ("loop" if scheme == 2.0 else ("bilinear" if scheme == 3.0 else "none"))
_ = try author.attribute(part.path, spec, "subdivisionScheme", "token", true, Value.scalar(ValueKind.token, (u64)(try author.names.token(text))))
if text == "none": return
if detail_number(mesh, "subd.boundary", 1.0) == 0.0:
_ = try author.attribute(part.path, spec, "interpolateBoundary", "token", false, Value.scalar(ValueKind.token, (u64)(try author.names.token("edgeOnly"))))
var indices = Growing[i32]()
defer indices.close()
var values = Growing[f32]()
defer values.close()
let crease = mesh.attribute_on("crease", Domain.edge)
if crease >= 0:
let pairs = try mesh.edge_span()
let entry = try mesh.attribute_entry(crease)
for edge in try work.marked_edges(crease):
let sharpness = entry.number(edge, 0)
let a = local_point(part, numbers, (usize)pairs[edge * 2])
let b = local_point(part, numbers, (usize)pairs[edge * 2 + 1])
if a < 0 or b < 0: continue
try indices.push(a)
try indices.push(b)
try values.push((f32)sharpness)
if values.count > 0:
var lengths = Growing[i32]()
defer lengths.close()
try lengths.fill(values.count, 2)
_ = try author.attribute(part.path, spec, "creaseIndices", "int[]", false, try array_of(ValueKind.int, indices.count, u8[]((u8*)indices.items.data, indices.count * 4)))
_ = try author.attribute(part.path, spec, "creaseLengths", "int[]", false, try array_of(ValueKind.int, lengths.count, u8[]((u8*)lengths.items.data, lengths.count * 4)))
_ = try author.attribute(part.path, spec, "creaseSharpnesses", "float[]", false, try array_of(ValueKind.float, values.count, u8[]((u8*)values.items.data, values.count * 4)))
indices.clear()
values.clear()
let corner = mesh.attribute_on("corner_sharpness", Domain.point)
if corner >= 0:
let entry = try mesh.attribute_entry(corner)
for at in 0..<part.point_count():
let sharpness = entry.number(part.point_at(at), 0)
if sharpness <= 0.0: continue
try indices.push((i32)at)
try values.push((f32)sharpness)
if values.count > 0:
_ = try author.attribute(part.path, spec, "cornerIndices", "int[]", false, try array_of(ValueKind.int, indices.count, u8[]((u8*)indices.items.data, indices.count * 4)))
_ = try author.attribute(part.path, spec, "cornerSharpnesses", "float[]", false, try array_of(ValueKind.float, values.count, u8[]((u8*)values.items.data, values.count * 4)))
indices.clear()
let hole = mesh.attribute_on("hole", Domain.face)
if hole >= 0:
let entry = try mesh.attribute_entry(hole)
let bits = Bits.of_bytes(entry.data.view(), entry.elements)
for at in 0..<part.faces.count:
if bits.get((usize)part.faces.items[at]): try indices.push((i32)at)
if indices.count > 0:
_ = try author.attribute(part.path, spec, "holeIndices", "int[]", false, try array_of(ValueKind.int, indices.count, u8[]((u8*)indices.items.data, indices.count * 4)))
func detail_number(mesh: const Mesh*, name: str, fallback: f64) -> f64:
let found = mesh.attribute_on(name, Domain.detail)
if found < 0: return fallback
return mesh.attribute_value(found, 0, 0) catch failure: recover fallback
## The part's `material` text as bindings.
func write_binding(work: MeshExport*, part: const MeshPart*, spec: usize) -> !:
let mesh = work.mesh
let found = mesh.attribute_on("material", Domain.face)
if found < 0: return
let entry = try mesh.attribute_entry(found)
var materials = Growing[u32]()
defer materials.close()
var faces_of = Growing[i32]()
defer faces_of.close()
var bound_faces: usize = 0
for at in 0..<part.faces.count:
let text = entry.text_at((usize)part.faces.items[at])
var which: i32 = -1
if text.length > 0:
let path = work.author.names.parse_path(text) catch failure: recover empty_path
if path != empty_path and work.author.names.is_prim(path) and work.author.names.is_absolute(path):
for known in 0..<materials.count:
if materials.items[known] == path: which = (i32)known
if which < 0:
which = (i32)materials.count
try materials.push(path)
bound_faces += 1
try faces_of.push(which)
if materials.count == 0: return
let author = work.author
if materials.count == 1 and bound_faces == part.faces.count:
try author.relationship(part.path, spec, "material:binding", materials.view())
try apply_binding_api(author, spec)
return
# The material subsets never overlap.
_ = try author.attribute(part.path, spec, "subsetFamily:materialBind:familyType", "token", true, Value.scalar(ValueKind.token, (u64)(try author.names.token("nonOverlapping"))))
var members = Growing[i32]()
defer members.close()
var name = Growing[u8]()
defer name.close()
for material in 0..<materials.count:
members.clear()
for at in 0..<faces_of.count:
if faces_of.items[at] == (i32)material: try members.push((i32)at)
name.clear()
try name.assign("material_".bytes)
try append_count(&name, material)
let subset = try write_subset(work, part, (str)name.view(), "face", members.view(), "materialBind")
let subset_spec = author.layer.find(subset) else continue
try author.relationship(subset, subset_spec, "material:binding", materials.items[material..<material + 1])
try apply_binding_api(author, subset_spec)
## Prepend MaterialBindingAPI to a prim's apiSchemas.
func apply_binding_api(author: Author*, spec: usize) -> !:
let list = try ListOp.create()
try author.layer.set(spec, author.layer.keys.api_schemas, Value.of_object(ValueKind.token_list_op, (void*)list))
try list.push(ListPart.prepended, ListItem(a = (u64)(try author.names.token("MaterialBindingAPI")), b = 0, offset = 0.0, scale = 1.0, custom = none))