dymokomi/luce-fbx
Source of release 0.12.2
0.12.2 / src / writer / layers_out.lucb
## A mesh part's layer elements (the table in mesh_out.lucb) and the Layer
## nodes naming them: layer k lists every element of set k.
import strings
let layer_types: str[11] = ["LayerElementNormal", "LayerElementTangent", "LayerElementBinormal", "LayerElementUV", "LayerElementColor", "LayerElementSmoothing", "LayerElementEdgeCrease", "LayerElementVertexCrease", "LayerElementHole", "LayerElementVisibility", "LayerElementMaterial"]
let normal_layer: u8 = 0
let tangent_layer: u8 = 1
let binormal_layer: u8 = 2
let uv_layer: u8 = 3
let color_layer: u8 = 4
let smoothing_layer: u8 = 5
let edge_crease_layer: u8 = 6
let vertex_crease_layer: u8 = 7
let hole_layer: u8 = 8
let visibility_layer: u8 = 9
let material_layer: u8 = 10
## The elements written, as (type, set).
struct LayerList:
var entries: Growing[(u8, i32)]
func init():
self.entries = Growing[(u8, i32)]()
func close():
self.entries.close()
## Set index of `name` as `base` + an optional number 2..16 ("uv" 0,
## "uv3" 2), or -1 when it is not.
func set_of(name: str, base: str) -> i32:
if name.length < base.length or (str)name.bytes[..<base.length] != base: return -1
if name.length == base.length: return 0
var number: i32 = 0
for byte in name.bytes[base.length..]:
if byte < '0' or byte > '9' or number > 100: return -1
number = number * 10 + (i32)(byte - '0')
return number - 1 if number >= 2 and number <= 16 else -1
## A number attribute of at least `width` components (array attributes are not: FBX
## layers hold one value per element).
func numeric(entry: const Attribute*, width: usize) -> bool:
return not entry.is_group() and not entry.is_ragged() and entry.kind != DataType.text and entry.width >= width
## Whether a mesh attribute is written (as a layer, a material or the model
## structure) or bookkeeping.
func written(entry: const Attribute*) -> bool:
let name = entry.name()
if name == "path" or name == "material" or name.length == 0 or name.bytes[0] == '.': return true
if set_of(name, "N") >= 0 or set_of(name, "tangentu") >= 0 or set_of(name, "tangentv") >= 0: return numeric(entry, 3)
if set_of(name, "uv") >= 0: return numeric(entry, 2)
if set_of(name, "Cd") >= 0: return numeric(entry, 3)
if set_of(name, "Alpha") >= 0: return numeric(entry, 1)
match name:
"smoothing_group": return entry.domain == Domain.face and numeric(entry, 1)
"crease": return entry.domain == Domain.edge and numeric(entry, 1)
"corner_sharpness": return entry.domain == Domain.point and numeric(entry, 1)
"sharp", "hidden": return entry.domain == Domain.edge and entry.is_group()
"hole": return entry.domain == Domain.face and entry.is_group()
_: return false
## A warning for each attribute FBX has no layer for.
func note_left_out(job: Export*, mesh: const Mesh*) -> !:
for index in 0..<(usize)mesh.attribute_count():
let entry = try mesh.attribute_entry((i64)index)
if written(entry): continue
var line: u8[256] = ---
if entry.is_ragged(): try job.warnings.add(try strings.format(line, f"FBX has no layer for array attributes; the mesh attribute {entry.name()} was left out"))
else: try job.warnings.add(try strings.format(line, f"FBX has no layer for the mesh attribute {entry.name()}; it was left out"))
## The part's elements of `domain`, in local order.
func elements_of(part: const MeshPart*, domain: Domain) -> const i32[]:
match domain:
.point: return part.points.view()
.corner: return part.corners.view()
.face: return part.faces.view()
.edge: return part.edges.view()
_:
var none_yet: i32[]
return none_yet
func mapping_of(domain: Domain) -> str:
match domain:
.point: return "ByVertice"
.corner: return "ByPolygonVertex"
.face: return "ByPolygon"
.edge: return "ByEdge"
_: return "AllSame"
## Element `at` of the part's `domain` list (detail: element 0).
func element_at(elements: const i32[], domain: Domain, at: usize) -> usize:
return 0 if domain == Domain.detail else (usize)elements[at]
func element_count(elements: const i32[], domain: Domain) -> usize:
return 1 if domain == Domain.detail else elements.length
## Open a layer element: type, set, version, name, mapping, reference.
func open_layer(tree: Tree*, layers: LayerList*, kind: u8, set: i32, name: str, domain: Domain, indexed: bool) -> !:
try tree.begin(layer_types[(usize)kind])
try tree.int32(set)
try tree.leaf_int32("Version", 101)
try tree.leaf_string("Name", name)
try tree.leaf_string("MappingInformationType", mapping_of(domain))
try tree.leaf_string("ReferenceInformationType", "IndexToDirect" if indexed else "Direct")
try layers.entries.push((kind, set))
## An array of f32 values named `key` (`raw` taken). Layer values are
## written in single precision whatever the attribute holds: what FBX
## consumers keep, and half the bytes of f64.
func real_array(tree: Tree*, key: str, raw: u8[]) -> !:
try tree.begin(key)
try tree.array('f', raw.length // 4, raw)
tree.end()
## `width` components of `entry` per element (missing ones 0), times
## `scale`, as f32; a float column is read directly, in parallel chunks.
func gathered(entry: const Attribute*, elements: const i32[], width: usize, scale: f64) -> u8[]!:
let count = element_count(elements, entry.domain)
let raw = try new u8[count * width * 4] --- in memory.heap
let out = f32[]((f32*)raw.data, count * width)
let direct = entry.width >= width and entry.domain != Domain.detail
if direct and entry.kind == DataType.float32 and entry.data.view().length >= entry.elements * entry.width * 4:
var work = GatherWork(elements = elements, stride = entry.width, width = width, scale = scale, doubles = no_doubles(), singles = f32[]((f32*)entry.data.view().data, entry.elements * entry.width), out = out)
try parallel.for_each_range(count, 65536, (void*)&work, gather_chunk)
return raw
if direct and entry.kind == DataType.float64 and entry.data.view().length >= entry.elements * entry.width * 8:
var work = GatherWork(elements = elements, stride = entry.width, width = width, scale = scale, doubles = f64[]((f64*)entry.data.view().data, entry.elements * entry.width), singles = no_singles(), out = out)
try parallel.for_each_range(count, 65536, (void*)&work, gather_chunk)
return raw
for at in 0..<count:
let element = element_at(elements, entry.domain, at)
for k in 0..<width:
out[at * width + k] = (f32)(entry.number(element, k) * scale) if k < entry.width else 0.0
return raw
## A float column's values gathered by element into f32.
struct GatherWork:
var elements: const i32[]
var stride: usize
var width: usize
var scale: f64
var doubles: const f64[]
var singles: const f32[]
var out: f32[]
func gather_chunk(context: void*, first: usize, end: usize, worker: usize):
let work = (GatherWork*)context
let width = work.width
let stride = work.stride
if work.doubles.length > 0:
for at in first..<end:
let base = (usize)work.elements[at] * stride
for k in 0..<width: work.out[at * width + k] = (f32)(work.doubles[base + k] * work.scale)
return
let factor = (f32)work.scale
for at in first..<end:
let base = (usize)work.elements[at] * stride
for k in 0..<width: work.out[at * width + k] = work.singles[base + k] * factor
func no_doubles() -> f64[]:
var none_yet: f64[]
return none_yet
func no_singles() -> f32[]:
var none_yet: f32[]
return none_yet
## A float layer: Normals, Tangents, Binormals or UV.
func float_layer(tree: Tree*, layers: LayerList*, part: const MeshPart*, entry: const Attribute*, kind: u8, set: i32, name: str, key: str, width: usize) -> !:
let elements = elements_of(part, entry.domain)
try open_layer(tree, layers, kind, set, name, entry.domain, false)
try real_array(tree, key, try gathered(entry, elements, width, 1.0))
tree.end()
## A color layer: RGBA from `Cd*` and its `Alpha*` (1 without one).
func color_out(tree: Tree*, layers: LayerList*, mesh: const Mesh*, part: const MeshPart*, entry: const Attribute*, set: i32) -> !:
let elements = elements_of(part, entry.domain)
let count = element_count(elements, entry.domain)
var alpha: const Attribute*? = none
var alpha_name: u8[16] = ---
let found = mesh.attribute_on(try strings.format(alpha_name, f"Alpha{set + 1}") if set > 0 else "Alpha", entry.domain)
if found >= 0: alpha = try mesh.attribute_entry(found)
let raw = try new u8[count * 16] --- in memory.heap
let out = f32[]((f32*)raw.data, count * 4)
for at in 0..<count:
let element = element_at(elements, entry.domain, at)
for k in 0..<(usize)3: out[at * 4 + k] = (f32)entry.number(element, k)
var a = entry.number(element, 3) if entry.width >= 4 else 1.0
if let values = alpha: a = values.number(element, 0)
out[at * 4 + 3] = (f32)a
try open_layer(tree, layers, color_layer, set, entry.name(), entry.domain, false)
try real_array(tree, "Colors", raw)
tree.end()
## An integer layer with one value per element: `values` taken.
func int_layer(tree: Tree*, layers: LayerList*, kind: u8, domain: Domain, key: str, values: u8[], count: usize) -> !:
try open_layer(tree, layers, kind, 0, "", domain, false)
try tree.begin(key)
try tree.array('i', count, values)
tree.end()
tree.end()
## A group's membership per element as i32: `inside` for members, else
## `outside`.
func group_values(entry: const Attribute*, elements: const i32[], inside: i32, outside: i32) -> u8[]!:
let raw = try new u8[elements.length * 4] --- in memory.heap
let out = i32[]((i32*)raw.data, elements.length)
for at in 0..<elements.length:
out[at] = inside if entry.number((usize)elements[at], 0) != 0.0 else outside
return raw
## Every layer element of the part.
func write_layers(job: Export*, mesh: const Mesh*, part: const MeshPart*, layers: LayerList*) -> !:
let tree = &job.tree
var normals = false
var smoothing: const Attribute*? = none
var sharp: const Attribute*? = none
for index in 0..<(usize)mesh.attribute_count():
let entry = try mesh.attribute_entry((i64)index)
if not written(entry): continue
let name = entry.name()
if set_of(name, "N") >= 0:
try float_layer(tree, layers, part, entry, normal_layer, set_of(name, "N"), "", "Normals", 3)
normals = true
elif set_of(name, "tangentu") >= 0: try float_layer(tree, layers, part, entry, tangent_layer, set_of(name, "tangentu"), "", "Tangents", 3)
elif set_of(name, "tangentv") >= 0: try float_layer(tree, layers, part, entry, binormal_layer, set_of(name, "tangentv"), "", "Binormals", 3)
elif set_of(name, "uv") >= 0: try float_layer(tree, layers, part, entry, uv_layer, set_of(name, "uv"), name, "UV", 2)
elif set_of(name, "Cd") >= 0: try color_out(tree, layers, mesh, part, entry, set_of(name, "Cd"))
elif name == "smoothing_group": smoothing = entry
elif name == "sharp": sharp = entry
elif name == "crease":
let elements = part.edges.view()
try open_layer(tree, layers, edge_crease_layer, 0, "", Domain.edge, false)
try real_array(tree, "EdgeCrease", try gathered(entry, elements, 1, 0.1))
tree.end()
elif name == "corner_sharpness":
let elements = part.points.view()
try open_layer(tree, layers, vertex_crease_layer, 0, "", Domain.point, false)
try real_array(tree, "VertexCrease", try gathered(entry, elements, 1, 0.1))
tree.end()
elif name == "hole": try int_layer(tree, layers, hole_layer, Domain.face, "Hole", try group_values(entry, part.faces.view(), 1, 0), part.faces.count)
elif name == "hidden": try int_layer(tree, layers, visibility_layer, Domain.edge, "Visibility", try group_values(entry, part.edges.view(), 0, 1), part.edges.count)
# Smoothing: the face groups, else the sharp edges, else flat when
# there are no normals either (geocore shows such a mesh flat).
if let groups = smoothing:
let raw = try new u8[part.faces.count * 4] --- in memory.heap
let out = i32[]((i32*)raw.data, part.faces.count)
for at in 0..<part.faces.count: out[at] = (i32)groups.number((usize)part.faces.items[at], 0)
try int_layer(tree, layers, smoothing_layer, Domain.face, "Smoothing", raw, part.faces.count)
elif let edges = sharp:
try int_layer(tree, layers, smoothing_layer, Domain.edge, "Smoothing", try group_values(edges, part.edges.view(), 0, 1), part.edges.count)
elif not normals:
let raw = try new u8[part.faces.count * 4] --- in memory.heap
let out = i32[]((i32*)raw.data, part.faces.count)
for at in 0..<part.faces.count: out[at] = 0
try int_layer(tree, layers, smoothing_layer, Domain.face, "Smoothing", raw, part.faces.count)
try write_materials(job, mesh, part, layers)
## The Material layer: each face's index into the part's materials (its
## `material` texts in first-use order, "" as "default"), AllSame when one;
## none when every face's text is "".
func write_materials(job: Export*, mesh: const Mesh*, part: const MeshPart*, layers: LayerList*) -> !:
let found = mesh.attribute_on("material", Domain.face)
if found < 0: return
let entry = try mesh.attribute_entry(found)
if entry.kind != DataType.text: return
var local_of = Growing[i32]()
defer local_of.close()
var texts = Growing[i32]()
defer texts.close()
let raw = try new u8[part.faces.count * 4] --- in memory.heap
var taken = false
errdefer:
if not taken: free(raw) in memory.heap
let out = i32[]((i32*)raw.data, part.faces.count)
for at in 0..<part.faces.count:
let face = (usize)part.faces.items[at]
let text = (i32)entry.number(face, 0)
let slot = (usize)(text + 1)
if local_of.count <= slot: try local_of.extend(slot + 1, -1)
if local_of.items[slot] < 0:
local_of.items[slot] = (i32)texts.count
try texts.push((i32)face)
out[at] = local_of.items[slot]
if texts.count == 1 and entry.text_at((usize)texts.items[0]).length == 0:
free(raw) in memory.heap
taken = true
return
for face in texts.view():
let name = entry.text_at((usize)face)
try job.material_refs.push(try job.material(name if name.length > 0 else "default"))
let tree = &job.tree
let uniform = texts.count == 1
try open_layer(tree, layers, material_layer, 0, "", Domain.detail if uniform else Domain.face, true)
try tree.begin("Materials")
taken = true
if uniform:
# One index for every face.
free(raw) in memory.heap
let one = try new u8[4] --- in memory.heap
memory.write[i32]((void*)&one[0], 0)
try tree.array('i', 1, one)
else: try tree.array('i', part.faces.count, raw)
tree.end()
tree.end()
## The Layer nodes: layer k holds each element type's set k.
func write_layer_table(tree: Tree*, layers: const LayerList*) -> !:
var most: i32 = -1
for entry in layers.entries.view():
if entry.1 > most: most = entry.1
for layer in 0..<most + 1:
try tree.begin("Layer")
try tree.int32(layer)
try tree.leaf_int32("Version", 100)
for entry in layers.entries.view():
if entry.1 != layer: continue
try tree.begin("LayerElement")
try tree.leaf_string("Type", layer_types[(usize)entry.0])
try tree.leaf_int32("TypedIndex", layer)
tree.end()
tree.end()