Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-fbx

Source of release 0.12.2

0.12.2 / src / writer / mesh_out.lucb

## A mesh as Geometry objects, one per `path` (docs/MAPPING.md, "Writing"):
## each part's points in first-use order (placed back at the mesh origin, as
## f64 Vertices), PolygonVertexIndex (a face's last corner as ~index),
## Edges (each edge's first polygon vertex, only when an edge layer is
## written) and a layer element per attribute FBX has one for:
##
## | Attribute | Layer element |
## |---|---|
## | `N`, `N2`, ... | Normal (Direct) |
## | `tangentu*`, `tangentv*` | Tangent, Binormal (Direct) |
## | `uv`, `uv2`, ... | UV (Direct) |
## | `Cd*` with `Alpha*` | Color, RGBA (Direct) |
## | face `smoothing_group`, else edge group `sharp` | Smoothing (ByPolygon / ByEdge, 0 sharp) |
## | edge `crease`, point `corner_sharpness` | EdgeCrease, VertexCrease (/ 10) |
## | face group `hole`, edge group `hidden` | Hole, Visibility (0 hidden) |
## | face text `material` | Material (IndexToDirect into the model's materials) |
##
## The mapping follows the domain: point ByVertice, corner ByPolygonVertex,
## face ByPolygon, edge ByEdge. Layer values are f32 (positions f64). A mesh
## with neither normals nor smoothing is written flat (Smoothing ByPolygon,
## all 0), as geocore shows it.

## One Geometry's share of the mesh: global element ids in local order.
struct MeshPart:
    var path_index: i32
    var faces: Growing[i32]
    var points: Growing[i32]
    var corners: Growing[i32]
    var edges: Growing[i32]
    ## Each local edge's first local polygon vertex.
    var edge_corners: Growing[i32]
    ## Each local polygon vertex's local point.
    var corner_points: Growing[i32]

    func close():
        self.faces.close()
        self.points.close()
        self.corners.close()
        self.edges.close()
        self.edge_corners.close()
        self.corner_points.close()

func new_part(path_index: i32) -> MeshPart:
    return MeshPart(path_index = path_index, faces = Growing[i32](), points = Growing[i32](), corners = Growing[i32](), edges = Growing[i32](), edge_corners = Growing[i32](), corner_points = Growing[i32]())

func close_parts(parts: Growing[MeshPart]*):
    for at in 0..<parts.count: parts.items[at].close()
    parts.close()

## Numbering scratch shared by a mesh's parts: global point and edge to
## local, stamped by part.
struct Numbering:
    var point_local: i32[]
    var point_stamp: i32[]
    var edge_local: i32[]
    var edge_stamp: i32[]

    func release():
        if self.point_local.length > 0: free(self.point_local) in memory.heap
        if self.point_stamp.length > 0: free(self.point_stamp) in memory.heap
        if self.edge_local.length > 0: free(self.edge_local) in memory.heap
        if self.edge_stamp.length > 0: free(self.edge_stamp) in memory.heap

## Write `mesh`'s parts as Geometry objects; their attachments go to the
## export's list.
func prepare_mesh(job: Export*, mesh: const Mesh*) -> !:
    if mesh.face_count() == 0: return
    var parts = Growing[MeshPart]()
    defer close_parts(&parts)
    let path_at = mesh.attribute_on("path", Domain.face)
    let paths: const Attribute*? = (try mesh.attribute_entry(path_at)) if path_at >= 0 else none
    try split_parts(mesh, paths, &parts)
    let edges = needs_edges(mesh)
    let edge_total = (usize)try mesh.edge_count() if edges else 0
    let point_total = (usize)mesh.point_count()
    var numbering = Numbering(point_local = empty_ints32(), point_stamp = empty_ints32(), edge_local = empty_ints32(), edge_stamp = empty_ints32())
    defer numbering.release()
    numbering.point_local = try new i32[point_total] --- in memory.heap
    numbering.point_stamp = try new i32[point_total] --- in memory.heap
    numbering.edge_local = try new i32[edge_total] --- in memory.heap
    numbering.edge_stamp = try new i32[edge_total] --- in memory.heap
    for at in 0..<point_total: numbering.point_stamp[at] = -1
    for at in 0..<edge_total: numbering.edge_stamp[at] = -1
    try note_left_out(job, mesh)
    for at in 0..<parts.count:
        let part = &parts.items[at]
        try number_part(mesh, part, (i32)at, &numbering, parts.count == 1, edges)
        var path = ""
        if let entry = paths: path = entry.text_at((usize)part.faces.items[0])
        let geometry = job.new_id()
        let first_material = job.material_refs.count
        try write_geometry(job, mesh, part, geometry, leaf_name(path, "mesh"), edges)
        let start = job.names.count
        for byte in path.bytes: try job.names.push(byte)
        try job.attaches.push(Attach(path_start = start, path_length = path.length, fallback = "mesh", geometry = geometry, kind = 1, first_material = first_material, material_count = job.material_refs.count - first_material))

## Faces grouped by `path` text (first appearance order), or all together.
func split_parts(mesh: const Mesh*, paths: const Attribute*?, parts: Growing[MeshPart]*) -> !:
    let faces = (usize)mesh.face_count()
    if paths == none:
        try parts.push(new_part(-1))
        let all = &parts.items[0].faces
        try all.fill(faces, 0)
        for face in 0..<faces: all.items[face] = (i32)face
        return
    let entry = paths else return
    var part_of = Growing[i32]()
    defer part_of.close()
    for face in 0..<faces:
        let text = (i32)entry.number(face, 0)
        let slot = (usize)(text + 1)
        if part_of.count <= slot: try part_of.extend(slot + 1, -1)
        if part_of.items[slot] < 0:
            part_of.items[slot] = (i32)parts.count
            try parts.push(new_part(text))
        try parts.items[(usize)part_of.items[slot]].faces.push((i32)face)

## The part's points, corners and edges in first-use order; a part of
## the whole mesh keeps the mesh's own point order (unused points too).
func number_part(mesh: const Mesh*, part: MeshPart*, id: i32, numbering: Numbering*, whole: bool, with_edges: bool) -> !:
    let offsets = mesh.offset_span()
    let corners = mesh.corner_span()
    var none_yet: i32[]
    let corner_edges = (try mesh.corner_edge_span()) if with_edges else none_yet
    # Sized up front, then written in place: at most one entry per corner.
    var total: usize = 0
    for face in part.faces.view(): total += (usize)(offsets[(usize)face + 1] - offsets[(usize)face])
    let point_room = (usize)mesh.point_count() if whole else total
    try part.points.reserve(point_room)
    try part.corners.fill(total, 0)
    try part.corner_points.fill(total, 0)
    try part.edges.reserve(total)
    try part.edge_corners.reserve(total)
    var points: usize = 0
    var edges: usize = 0
    if whole:
        # The whole mesh: points, corners and corner points as they are;
        # only the edges' first uses are found.
        let point_count = (usize)mesh.point_count()
        for point in 0..<point_count: part.points.items[point] = (i32)point
        part.points.count = point_count
        for corner in 0..<total: part.corners.items[corner] = (i32)corner
        memory.copy(part.corner_points.items, corners, total)
        if not with_edges: return
        let edge_items = part.edges.items
        let edge_corner_items = part.edge_corners.items
        for corner in 0..<total:
            let edge = (usize)corner_edges[corner]
            if numbering.edge_stamp[edge] != id:
                numbering.edge_stamp[edge] = id
                edge_items[edges] = (i32)edge
                edge_corner_items[edges] = (i32)corner
                edges += 1
        part.edges.count = edges
        part.edge_corners.count = edges
        return
    let point_items = part.points.items
    let edge_items = part.edges.items
    let edge_corner_items = part.edge_corners.items
    let corner_items = part.corners.items
    let corner_point_items = part.corner_points.items
    var at: usize = 0
    for face in part.faces.view():
        for corner in offsets[(usize)face]..<offsets[(usize)face + 1]:
            let point = (usize)corners[(usize)corner]
            if numbering.point_stamp[point] != id:
                numbering.point_stamp[point] = id
                numbering.point_local[point] = (i32)points
                point_items[points] = (i32)point
                points += 1
            if with_edges:
                let edge = (usize)corner_edges[(usize)corner]
                if numbering.edge_stamp[edge] != id:
                    numbering.edge_stamp[edge] = id
                    numbering.edge_local[edge] = (i32)edges
                    edge_items[edges] = (i32)edge
                    edge_corner_items[edges] = (i32)at
                    edges += 1
            corner_items[at] = corner
            corner_point_items[at] = numbering.point_local[point]
            at += 1
    part.points.count = points
    part.edges.count = edges
    part.edge_corners.count = edges

## One Geometry: points, polygons, edges and layer elements.
func write_geometry(job: Export*, mesh: const Mesh*, part: const MeshPart*, id: i64, name: str, edges: bool) -> !:
    let tree = &job.tree
    try tree.begin("Geometry")
    try tree.int64(id)
    try tree.object_name(name, "Geometry")
    try tree.string("Mesh")
    try tree.leaf_int32("GeometryVersion", 124)
    # Vertices, placed back at the mesh origin in f64.
    let origin = mesh.position_origin()
    let positions = mesh.point_span()
    let points = part.points.count
    let vertices = try new u8[points * 24] --- in memory.heap
    var placing = VertexWork(positions = positions, points = part.points.view(), origin = origin, out = f64[]((f64*)vertices.data, points * 3))
    try parallel.for_each_range(points, 65536, (void*)&placing, place_vertices)
    try tree.begin("Vertices")
    try tree.array('d', points * 3, vertices)
    tree.end()
    # Polygons: the face's last corner as ~index.
    let offsets = mesh.offset_span()
    let total = part.corners.count
    let indices = try new u8[total * 4] --- in memory.heap
    let out = i32[]((i32*)indices.data, total)
    memory.copy(out, part.corner_points.view(), total)
    var at: usize = 0
    for face in part.faces.view():
        at += (usize)(offsets[(usize)face + 1] - offsets[(usize)face])
        out[at - 1] = -out[at - 1] - 1
    try tree.begin("PolygonVertexIndex")
    try tree.array('i', total, indices)
    tree.end()
    if edges:
        try tree.begin("Edges")
        try tree.ints(part.edge_corners.view())
        tree.end()
    var layers = LayerList()
    defer layers.close()
    try write_layers(job, mesh, part, &layers)
    try write_layer_table(tree, &layers)
    tree.end()
    job.geometry_count += 1

## Vertices placed back at the mesh origin, in parallel chunks.
struct VertexWork:
    var positions: const Float3[]
    var points: const i32[]
    var origin: Vector3
    var out: f64[]

func place_vertices(context: void*, first: usize, end: usize, worker: usize):
    let work = (VertexWork*)context
    let origin = work.origin
    for at in first..<end:
        let p = work.positions[(usize)work.points[at]]
        work.out[at * 3] = (f64)p.x + origin.x
        work.out[at * 3 + 1] = (f64)p.y + origin.y
        work.out[at * 3 + 2] = (f64)p.z + origin.z

## Whether `mesh` has an edge attribute written as a layer (by edge:
## creases, visibility, sharp edges when there are no smoothing groups),
## which needs the Edges array.
func needs_edges(mesh: const Mesh*) -> bool:
    let edge = (i64)(u8)Domain.edge
    if mesh.find_attribute("crease", edge) >= 0 or mesh.find_attribute("hidden", edge) >= 0: return true
    return mesh.find_attribute("sharp", edge) >= 0 and mesh.attribute_on("smoothing_group", Domain.face) < 0

func empty_ints32() -> i32[]:
    var none_yet: i32[]
    return none_yet