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