Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-fbx

Source of release 0.12.1

0.12.1 / src / convert / fill.lucb

## Filling one merged attribute from each source's layer, in parallel
## chunks: every output element finds the layer element its mapping names
## (the polygon vertex, its point, its face, or element 0 for all-same),
## then the value through the layer's index when it has one. Out-of-range
## indices leave the element zero, as ufbx clamps nothing but reads nothing
## past the values.

struct FillWork:
    var geometry: const MeshGeometry*
    var build: const MeshBuild*
    var source: const Source*
    var layer: const Layer*
    var domain: Domain
    ## Numbers: `components` of each value from component `first`, times
    ## `scale`, `components` per output element.
    var out: f32[]
    var first: usize
    var components: usize
    var scale: f32
    ## Integers: one i32 per element.
    var integers: i32[]
    ## Bits: set where the value is nonzero (`when_zero`: where it is zero).
    var bits: u64[]
    var when_zero: bool
    ## Output chunks: faces, or points for the point domain.
    var chunk: usize
    ## A skinned mesh's directions turn with its points' skin matrices:
    ## 1 as normals, 2 as tangents, 0 not.
    var turn: u8

## Elements per fill chunk.
let fill_grain: usize = 8192

## A float attribute of `components` from the layers of a planned kind.
func put_numbers(mesh: Mesh*, build: const MeshBuild*, geometries: const MeshGeometry[], plan: Planned, name: str, first: usize, components: usize, scale: f32) -> !:
    # Nothing fails between here and put_attribute, which takes the
    # attribute even when it fails.
    var attribute = try Attribute.create(name, plan.domain, DataType.float32, components, element_count(build, plan.domain))
    let out = f32[]((f32*)attribute.data.span().data, element_count(build, plan.domain) * components)
    for at in 0..<out.length: out[at] = 0.0
    var no_integers: i32[]
    var no_bits: u64[]
    for source in build.sources.view():
        let geometry = &geometries[source.geometry]
        let layer = layer_for(geometry, plan) else continue
        if layer.width < first + components: continue
        var turn: u8 = 0
        if geometry.world_space and directional(plan.kind): turn = 1 if plan.kind == LayerKind.normal else 2
        var work = FillWork(geometry, build, &source, layer, plan.domain, out, first, components, scale, no_integers, no_bits, false, 0, turn)
        run_fill(&work)
    try put_attribute(mesh, attribute)

## An int32 attribute of one component from the layers of a planned kind.
func put_integers(mesh: Mesh*, build: const MeshBuild*, geometries: const MeshGeometry[], plan: Planned, name: str) -> !:
    let count = element_count(build, plan.domain)
    var attribute = try Attribute.create(name, plan.domain, DataType.int32, 1, count)
    let out = i32[]((i32*)attribute.data.span().data, count)
    for at in 0..<out.length: out[at] = 0
    var no_floats: f32[]
    var no_bits: u64[]
    for source in build.sources.view():
        let geometry = &geometries[source.geometry]
        let layer = layer_for(geometry, plan) else continue
        var work = FillWork(geometry, build, &source, layer, plan.domain, no_floats, 0, 1, 1.0, out, no_bits, false, 0, 0)
        run_fill(&work)
    try put_attribute(mesh, attribute)

## A face group of the faces whose layer value is nonzero.
func put_face_group(mesh: Mesh*, build: const MeshBuild*, geometries: const MeshGeometry[], plan: Planned, name: str) -> !:
    var attribute = try Attribute.group(name, Domain.face, build.faces)
    let bytes = attribute.data.span()
    let bits = u64[]((u64*)bytes.data, bytes.length // 8)
    var no_floats: f32[]
    var no_integers: i32[]
    for source in build.sources.view():
        let geometry = &geometries[source.geometry]
        let layer = layer_for(geometry, plan) else continue
        var work = FillWork(geometry, build, &source, layer, Domain.face, no_floats, 0, 1, 1.0, no_integers, bits, false, 0, 0)
        run_fill(&work)
    try put_attribute(mesh, attribute)

func element_count(build: const MeshBuild*, domain: Domain) -> usize:
    match domain:
        .point: return build.points
        .corner: return build.corner_total
        _: return build.faces

## Fill `work`'s source into its output, in parallel chunks.
func run_fill(work: FillWork*):
    if work.domain == Domain.point:
        let count = work.geometry.point_count()
        pool.run((count + fill_grain - 1) // fill_grain, fill_points, (void*)work)
        return
    let faces = work.source.face_end - work.source.face_base
    let chunks = (faces + fill_grain - 1) // fill_grain
    if work.bits.length > 0:
        # Neighbouring chunks may share a word of bits: one thread.
        for index in 0..<chunks: fill_faces((void*)work, index)
        return
    pool.run(chunks, fill_faces, (void*)work)

func fill_points(context: void*?, index: usize):
    let work = (FillWork*)(context else return)
    let count = work.geometry.point_count()
    let first = index * fill_grain
    let end = first + fill_grain if count - first > fill_grain else count
    for point in first..<end:
        write_value(work, work.source.point_base + point, point, point)

## Chunk `index` of the source's merged faces: each face's value, or each
## of its corners'.
func fill_faces(context: void*?, index: usize):
    let work = (FillWork*)(context else return)
    let source = work.source
    let face_source = work.build.face_source.view()
    let offsets = work.build.offsets.view()
    let corner_source = work.build.corner_source.view()
    let indices = work.geometry.indices
    let first = source.face_base + index * fill_grain
    let end = first + fill_grain if source.face_end - first > fill_grain else source.face_end
    let mapping = work.layer.mapping
    if work.domain == Domain.corner and mapping == Mapping.polygon_vertex and work.turn == 0 and work.bits.length == 0 and work.integers.length == 0:
        fill_corner_numbers(work, first, end)
        return
    for face in first..<end:
        let from_face = (usize)face_source[face]
        if work.domain == Domain.face:
            let first_point = (usize)point_at(indices, (usize)corner_source[(usize)offsets[face]])
            write_value(work, face, from_face if mapping == Mapping.polygon else 0, first_point)
            continue
        for corner in (usize)offsets[face]..<(usize)offsets[face + 1]:
            let vertex = (usize)corner_source[corner]
            var element: usize = 0
            match mapping:
                .polygon_vertex: element = vertex
                .vertex: element = (usize)point_at(indices, vertex)
                .polygon: element = from_face
                _: element = 0
            write_value(work, corner, element, (usize)point_at(indices, vertex))

## Faces `first..<end` of a corner layer by polygon vertex, as write_value
## would fill them, in one loop (the common case: normals, UVs, colors).
func fill_corner_numbers(work: FillWork*, first: usize, end: usize):
    let layer = work.layer
    let count = layer.value_count()
    if count == 0: return
    let offsets = work.build.offsets.view()
    let corner_source = work.build.corner_source.view()
    let values = layer.values
    let index = layer.index
    let width = layer.width
    let from_component = work.first
    let components = work.components
    let scale = work.scale
    let out = work.out
    for corner in (usize)offsets[first]..<(usize)offsets[end]:
        var value = (usize)corner_source[corner]
        if index.length > 0:
            let indexed = index[value] if value < index.length else -1
            value = (usize)indexed if indexed >= 0 else count - 1
        if value >= count: value = count - 1
        let base = value * width + from_component
        for k in 0..<components: out[corner * components + k] = values[base + k] * scale

## Write the layer value of `element` (through its index) as output element
## `at`.
func write_value(work: FillWork*, at: usize, element: usize, point: usize):
    let layer = work.layer
    let value = layer.value_of(element) else return
    if work.bits.length > 0:
        let set = (layer.integers[value] == 0) == work.when_zero
        if set: work.bits[at // 64] = work.bits[at // 64] | ((u64)1 << (u64)(at % 64))
        return
    if work.integers.length > 0:
        work.integers[at] = layer.integers[value]
        return
    let components = work.components
    let base = value * layer.width + work.first
    if work.turn != 0 and components == 3:
        let v = Vector3((f64)layer.values[base], (f64)layer.values[base + 1], (f64)layer.values[base + 2])
        let turned = skinned_direction(work.geometry.deformation.linear.view(), point, v, work.turn == 1)
        work.out[at * 3] = (f32)turned.x
        work.out[at * 3 + 1] = (f32)turned.y
        work.out[at * 3 + 2] = (f32)turned.z
        return
    for k in 0..<components:
        work.out[at * components + k] = layer.values[base + k] * work.scale