dymokomi/luce-fbx
Source of release 0.12.1
0.12.1 / tools / fbxdump / main.lucb
## fbxdump: what luce-fbx reads from a file, in the canonical text the ufbx
## parity oracle prints (lines of `file`, `settings`, `node`, `mesh`, `pos`,
## `attr`, `mat`, `curve`; numbers as %.6g). A local parity script compares
## the two over a corpus of FBX files. Fields are separated by tabs.
##
## fbxdump FILE [--time SECONDS] [--rest] [--save OUT [--instances] [--keep] [--7500] [--raw]]
##
## --time evaluates animation at a time; --rest leaves blend shapes and
## skins out. --save also writes what it imported (merged; with shared
## meshes as instances, or every model's own with --keep) to OUT with the
## writer, at 7400 or 7500, its arrays deflated or (--raw) not.
import c
import memory
from luce_geocore.core import parallel as pool
from luce_fbx.kernel import Document, Scene, Hierarchy, Kind, Animation, ImportOptions, Warnings, import_document, read_file, write_file, ExportOptions, encode_set
from luce_std import math
import strings
from luce_geocore.geocore import Matrix4, Vector3, Mesh
from luce_geocore.kernel import GeometrySet, Attribute, Domain, DataType, Float3, Curves, set_mesh, curves_type, dispose_set
from luce_geocore.core.growing import Growing
pub func main(arguments: str[]) -> i32!:
if arguments.length < 2:
print("usage: fbxdump FILE")
return 2
pool.warm()
let data = try read_file(arguments[1])
defer free(data) in memory.heap
var document = Document.parse(data) catch failure:
print(f"error {failure.message}")
return 1
defer document.close()
var scene = Scene.of(&document) catch failure:
print(f"error {failure.message}")
return 1
defer scene.close()
var time = math.nan
var rest = false
var save = ""
var keep = false
var instances = false
var version: u32 = 0
var deflate = true
for at in 2..<arguments.length:
if arguments[at] == "--time" and at + 1 < arguments.length: time = try strings.parse_f64(arguments[at + 1])
if arguments[at] == "--rest": rest = true
if arguments[at] == "--save" and at + 1 < arguments.length: save = arguments[at + 1]
if arguments[at] == "--keep": keep = true
if arguments[at] == "--instances": instances = true
if arguments[at] == "--7500": version = 7500
if arguments[at] == "--raw": deflate = false
var animation = scene.animation() catch failure:
print(f"error {failure.message}")
return 1
defer animation.close()
var animated: const Animation*? = none
if not math.is_nan(time): animated = &animation
var hierarchy = scene.hierarchy(animated, time) catch failure:
print(f"error {failure.message}")
return 1
defer hierarchy.close()
print(f"file\tversion={document.version}\tascii={0 if document.binary else 1}")
let s = scene.settings
var meters: u8[32] = ---
var rate: u8[32] = ---
print(f"settings\tup={s.up.text()}\tfront={s.front.text()}\tunit={g(s.meters, meters)}\tfps={g(s.frame_rate, rate)}")
for model in 1..<(u32)hierarchy.models.count:
let entry = &hierarchy.models.items[(usize)model]
var numbers: u8[512] = ---
let matrix = matrix_text(&entry.world, numbers)
let inherit = (u8)entry.inherit
print(f"node\t{hierarchy.path(model)}\tkind={scene.model_kind(entry.object)}\tinherit={inherit}\tworld={matrix}")
# The imported mesh, every model merged (no instances), by path.
var warnings = Warnings()
defer warnings.close()
let options = ImportOptions(keep_hierarchy = false, instancing = false, convert_units = false, normals = true, time = time, deform = not rest)
let set = import_document(&document, &options, &warnings) catch failure:
print(f"error import {failure.message}")
return 1
defer dispose_set(set)
if let mesh = set_mesh(set): try dump_mesh(mesh)
if let found = set.find(curves_type()): try dump_curves((const Curves*)found)
if save.length > 0:
let saving = ImportOptions(keep_hierarchy = keep, instancing = instances, convert_units = false, normals = true, time = time, deform = not rest)
let shared = import_document(&document, &saving, &warnings) catch failure:
print(f"error import {failure.message}")
return 1
defer dispose_set(shared)
var notes = Warnings()
defer notes.close()
let export_options = ExportOptions(version = version, deflate = deflate)
let bytes = encode_set(shared, &export_options, ¬es) catch failure:
print(f"error save {failure.message}")
return 1
defer free(bytes) in memory.heap
try write_file(save, bytes)
let text = (str)notes.text.view()
if text.length > 0: print(f"saved with warnings: {text}")
return 0
## Per path: its curves' kind (nurbs or line) and control point count.
func dump_curves(curves: const Curves*) -> !:
let store = curves.store()
let path_index = store.find("path", 2)
if path_index < 0: return
let paths = store.entry((usize)path_index)
let type_index = store.find("curve_type", 2)
let count = curves.curve_count()
var done = Growing[i32]()
defer done.close()
for curve in 0..<count:
let key = text_index(paths, curve)
var skip = false
for earlier in done.view(): skip = skip or earlier == key
if skip: continue
try done.push(key)
var points: usize = 0
var nurbs = false
for other in curve..<count:
if text_index(paths, other) != key: continue
points += curves.range(other).1
if type_index >= 0: nurbs = store.entry((usize)type_index).number(other, 0) == 2.0
let kind = "nurbs" if nurbs else "line"
print(f"curve\t{paths.text_at(curve)}\tkind={kind}\tpoints={points}")
## Per model path: face and corner counts, the used points' world
## positions, each attribute summed over the path's corners, and faces per
## material.
func dump_mesh(mesh: const Mesh*) -> !:
let path_index = mesh.find_attribute("path", 2)
if path_index < 0: return
let paths = try mesh.attribute_entry(path_index)
let offsets = mesh.offset_span()
let corners = mesh.corner_span()
let points = mesh.point_span()
let origin = mesh.position_origin()
let faces = offsets.length - 1
# Faces of each path, in face order; paths in first-face order.
var order = Growing[u32]()
defer order.close()
for face in 0..<faces: try order.push((u32)face)
var seen = Growing[u8]()
defer seen.close()
try seen.fill(points.length, 0)
var face: usize = 0
var done = Growing[i32]()
defer done.close()
while face < faces:
let key = text_index(paths, face)
var skip = false
for earlier in done.view(): skip = skip or earlier == key
if skip:
face += 1
continue
try done.push(key)
let path = paths.text_at(face)
var count: usize = 0
var corner_total: usize = 0
var used: usize = 0
var sum: f64[3] = [0.0, 0.0, 0.0]
var low: f64[3] = [1.0e300, 1.0e300, 1.0e300]
var high: f64[3] = [-1.0e300, -1.0e300, -1.0e300]
for other in face..<faces:
if text_index(paths, other) != key: continue
count += 1
for corner in (usize)offsets[other]..<(usize)offsets[other + 1]:
corner_total += 1
let point = (usize)corners[corner]
if seen.items[point] != 0: continue
seen.items[point] = 1
used += 1
let p = points[point]
let world: f64[3] = [(f64)p.x + origin.x, (f64)p.y + origin.y, (f64)p.z + origin.z]
for k in 0..<(usize)3:
sum[k] += world[k]
if world[k] < low[k]: low[k] = world[k]
if world[k] > high[k]: high[k] = world[k]
print(f"mesh\t{path}\tfaces={count}\tcorners={corner_total}")
var numbers: u8[256] = ---
print(f"pos\t{path}\tn={used}\tsum={triple(sum, numbers)}")
try dump_attributes(mesh, paths, key, path, offsets, corners)
try dump_materials(mesh, paths, key, path)
face += 1
func text_index(attribute: const Attribute*, element: usize) -> i32:
return memory.read[i32]((void*)&attribute.data.view()[element * 4])
## Each float attribute of the mesh summed over the path's corners (point
## and face values once per corner).
func dump_attributes(mesh: const Mesh*, paths: const Attribute*, key: i32, path: str, offsets: const i32[], corners: const i32[]) -> !:
let faces = offsets.length - 1
for index in 0..<mesh.attribute_count():
let attribute = try mesh.attribute_entry(index)
if attribute.kind != DataType.float32 or attribute.is_group(): continue
let domain = attribute.domain
if domain == Domain.edge or domain == Domain.detail: continue
var sum: f64[4] = [0.0, 0.0, 0.0, 0.0]
var n: usize = 0
for face in 0..<faces:
if text_index(paths, face) != key: continue
for corner in (usize)offsets[face]..<(usize)offsets[face + 1]:
var element = corner
if domain == Domain.point: element = (usize)corners[corner]
if domain == Domain.face: element = face
for k in 0..<attribute.width: sum[k] += attribute.number(element, k)
n += 1
var text: u8[256] = ---
var used: usize = 0
for k in 0..<attribute.width:
if k > 0:
text[used] = ','
used += 1
var number: u8[32] = ---
let part = g(sum[k], number)
memory.copy(text[used..], part.bytes, part.length)
used += part.length
print(f"attr\t{path}\t{attribute.name()}\tn={n}\tsum={(str)text[..<used]}")
## Faces per material name among the path's faces, names in first-face
## order, faces without a material left out.
func dump_materials(mesh: const Mesh*, paths: const Attribute*, key: i32, path: str) -> !:
let index = mesh.find_attribute("material", 2)
if index < 0: return
let materials = try mesh.attribute_entry(index)
let faces = materials.elements
var names = Growing[i32]()
defer names.close()
var counts = Growing[usize]()
defer counts.close()
for face in 0..<faces:
if text_index(paths, face) != key: continue
let name = text_index(materials, face)
if materials.text_at(face).length == 0: continue
var slot = names.count
for at in 0..<names.count:
if names.items[at] == name: slot = at
if slot == names.count:
try names.push(name)
try counts.push(0)
counts.items[slot] += 1
if names.count == 0: return
var line = Growing[u8]()
defer line.close()
for at in 0..<names.count:
if at > 0: try line.push('|')
var first_face: usize = 0
while text_index(materials, first_face) != names.items[at]: first_face += 1
for byte in materials.text_at(first_face).bytes: try line.push(byte)
var digits: u8[32] = ---
for byte in (try strings.format(digits, f":{counts.items[at]}")).bytes: try line.push(byte)
print(f"mat\t{path}\t{(str)line.view()}")
func triple(values: f64[3], out: u8[]) -> str:
var used: usize = 0
for k in 0..<3:
if k > 0:
out[used] = ','
used += 1
var number: u8[32] = ---
let part = g(values[k], number)
memory.copy(out[used..], part.bytes, part.length)
used += part.length
return (str)out[..<used]
extern func snprintf(output: u8*, size: usize, format: c.str, ...) -> i32
## A number as C's %.6g prints it, in `out`.
func g(value: f64, out: u8[]) -> str:
let written = snprintf(out.data, out.length, "%.6g", value + 0.0)
return (str)out[..<(usize)written]
## The 12 numbers of an affine matrix, column by column, comma separated.
func matrix_text(m: const Matrix4*, out: u8[]) -> str:
let columns: Vector3[4] = [m.x, m.y, m.z, m.translation]
var used: usize = 0
for column in 0..<4:
let values: f64[3] = [columns[column].x, columns[column].y, columns[column].z]
for row in 0..<3:
if column > 0 or row > 0:
out[used] = ','
used += 1
var number: u8[32] = ---
let text = g(values[row], number)
memory.copy(out[used..], text.bytes, text.length)
used += text.length
return (str)out[..<used]