dymokomi/luce-fbx
Source of release 0.12.1
0.12.1 / src / convert / attributes.lucb
## Layer elements as merged-mesh attributes (docs/MAPPING.md):
##
## | layer | attribute |
## |---|---|
## | Normal, Tangent, Binormal | `N`, `tangentu`, `tangentv` (then `N2`...) |
## | UV | `uv`, `uv2`, ... |
## | Color | `Cd` (RGB) and `Alpha`, then `Cd2`, `Alpha2`, ... |
## | Smoothing by polygon / by edge | face `smoothing_group` / edge group `sharp` |
## | EdgeCrease, VertexCrease | edge `crease`, point `corner_sharpness`, x10 |
## | Hole | face group `hole` |
## | Visibility by edge | edge group `hidden` |
##
## The domain follows the mapping: by polygon vertex is the corner domain,
## by vertex the point domain, by polygon (and all same) the face domain.
## When the merged sources disagree the corner domain holds them all.
## Sources without a layer leave their elements zero. Every fill runs in
## parallel chunks of each source's faces or points.
## One merged attribute and the layers that fill it.
struct Planned:
var kind: LayerKind
## The kind's n-th set (0 is the first).
var ordinal: usize
var domain: Domain
## Put every layer-backed attribute on `mesh`.
func put_layer_attributes(mesh: Mesh*, build: const MeshBuild*, geometries: const MeshGeometry[], options: const ImportOptions*, warnings: Warnings*) -> !:
var planned = Growing[Planned]()
defer planned.close()
try plan_attributes(build, geometries, options, &planned, warnings)
for plan in planned.view():
match plan.kind:
.normal: try put_numbers(mesh, build, geometries, plan, normal_names[plan.ordinal], 0, 3, 1.0)
.tangent: try put_numbers(mesh, build, geometries, plan, tangent_names[plan.ordinal], 0, 3, 1.0)
.binormal: try put_numbers(mesh, build, geometries, plan, binormal_names[plan.ordinal], 0, 3, 1.0)
.uv: try put_numbers(mesh, build, geometries, plan, uv_names[plan.ordinal], 0, 2, 1.0)
.color:
try put_numbers(mesh, build, geometries, plan, color_names[plan.ordinal], 0, 3, 1.0)
try put_numbers(mesh, build, geometries, plan, alpha_names[plan.ordinal], 3, 1, 1.0)
.vertex_crease: try put_numbers(mesh, build, geometries, plan, "corner_sharpness", 0, 1, 10.0)
.smoothing:
if plan.domain == Domain.edge: try put_edge_values(mesh, build, geometries, plan, "sharp", warnings)
else: try put_integers(mesh, build, geometries, plan, "smoothing_group")
.edge_crease: try put_edge_values(mesh, build, geometries, plan, "crease", warnings)
.visibility: try put_edge_values(mesh, build, geometries, plan, "hidden", warnings)
.hole: try put_face_group(mesh, build, geometries, plan, "hole")
_: continue
## Attribute names by set: the first set's, then the second's, ...
let normal_names: str[16] = ["N", "N2", "N3", "N4", "N5", "N6", "N7", "N8", "N9", "N10", "N11", "N12", "N13", "N14", "N15", "N16"]
let tangent_names: str[16] = ["tangentu", "tangentu2", "tangentu3", "tangentu4", "tangentu5", "tangentu6", "tangentu7", "tangentu8", "tangentu9", "tangentu10", "tangentu11", "tangentu12", "tangentu13", "tangentu14", "tangentu15", "tangentu16"]
let binormal_names: str[16] = ["tangentv", "tangentv2", "tangentv3", "tangentv4", "tangentv5", "tangentv6", "tangentv7", "tangentv8", "tangentv9", "tangentv10", "tangentv11", "tangentv12", "tangentv13", "tangentv14", "tangentv15", "tangentv16"]
let uv_names: str[16] = ["uv", "uv2", "uv3", "uv4", "uv5", "uv6", "uv7", "uv8", "uv9", "uv10", "uv11", "uv12", "uv13", "uv14", "uv15", "uv16"]
let color_names: str[16] = ["Cd", "Cd2", "Cd3", "Cd4", "Cd5", "Cd6", "Cd7", "Cd8", "Cd9", "Cd10", "Cd11", "Cd12", "Cd13", "Cd14", "Cd15", "Cd16"]
let alpha_names: str[16] = ["Alpha", "Alpha2", "Alpha3", "Alpha4", "Alpha5", "Alpha6", "Alpha7", "Alpha8", "Alpha9", "Alpha10", "Alpha11", "Alpha12", "Alpha13", "Alpha14", "Alpha15", "Alpha16"]
## Sets past the sixteenth of a kind are left out.
let most_sets: usize = 16
## Which attributes the sources' layers make, and on which domains.
func plan_attributes(build: const MeshBuild*, geometries: const MeshGeometry[], options: const ImportOptions*, planned: Growing[Planned]*, warnings: Warnings*) -> !:
for source in build.sources.view():
let geometry = &geometries[source.geometry]
for index in 0..<geometry.layers.count:
let layer = &geometry.layers.items[index]
if layer.kind == LayerKind.material: continue
if layer.kind == LayerKind.normal and not options.normals: continue
let ordinal = ordinal_of(geometry, layer)
if ordinal >= most_sets:
try warnings.add("Layer sets past the sixteenth of a kind were left out")
continue
let domain = domain_of(layer) else continue
var found = false
for slot in 0..<planned.count:
let entry = &planned.items[slot]
if entry.kind == layer.kind and entry.ordinal == ordinal:
found = true
if entry.domain != domain: entry.domain = merged_domain(entry.domain, domain)
if not found: try planned.push(Planned(kind = layer.kind, ordinal = ordinal, domain = domain))
## Whether a layer holds directions (normals, tangents, binormals).
func directional(kind: LayerKind) -> bool:
return kind == LayerKind.normal or kind == LayerKind.tangent or kind == LayerKind.binormal
## Where a layer's values land, or none for a mapping that cannot carry it.
func domain_of(layer: const Layer*) -> Domain?:
match layer.kind:
.edge_crease, .visibility:
if layer.mapping == Mapping.edge: return Domain.edge
return none
.smoothing:
if layer.mapping == Mapping.edge: return Domain.edge
if layer.mapping == Mapping.polygon or layer.mapping == Mapping.all_same: return Domain.face
return none
.hole:
if layer.mapping == Mapping.polygon or layer.mapping == Mapping.all_same: return Domain.face
return none
.vertex_crease:
if layer.mapping == Mapping.vertex: return Domain.point
return none
_:
match layer.mapping:
.polygon_vertex: return Domain.corner
.vertex: return Domain.point
.polygon, .all_same: return Domain.face
_: return none
## Two sources' domains for one attribute: the corner domain holds any
## point, face or corner values.
func merged_domain(a: Domain, b: Domain) -> Domain:
if a == b: return a
if a == Domain.edge or b == Domain.edge: return Domain.edge
return Domain.corner
## A layer's place among its geometry's layers of the same kind, by set.
func ordinal_of(geometry: const MeshGeometry*, layer: const Layer*) -> usize:
var ordinal: usize = 0
for other in geometry.layers.view():
if other.kind == layer.kind and other.set < layer.set: ordinal += 1
return ordinal
## The layer of `geometry` a planned attribute reads, if it has one.
func layer_for(geometry: const MeshGeometry*, plan: Planned) -> const Layer*?:
for index in 0..<geometry.layers.count:
let layer = &geometry.layers.items[index]
if layer.kind == plan.kind and ordinal_of(geometry, layer) == plan.ordinal: return layer
return none