Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-fbx

Source of release 0.12.2

0.12.2 / 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_fbx.kernel import Document, Scene, Hierarchy, Kind, Animation, ImportOptions, Warnings, import_document, read_file, write_file, ExportOptions, encode_set
from luce_std import math, parallel
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
    parallel.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, &notes) 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]