Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-fbx

Source of release 0.12.1

0.12.1 / 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.
func numeric(entry: const Attribute*, width: usize) -> bool:
    return not entry.is_group() 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] = ---
        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)
        pool.parallel_for(count, 65536, gather_chunk, (void*)&work)
        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)
        pool.parallel_for(count, 65536, gather_chunk, (void*)&work)
        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):
    let work = (GatherWork*)(context else return)
    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.find_attribute(try strings.format(alpha_name, f"Alpha{set + 1}") if set > 0 else "Alpha", (i64)(u8)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.find_attribute("material", (i64)(u8)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()