dymokomi/luce-ply
Source of release 0.1.0
## PLY to a GeometrySet. The `vertex` element gives the points: `x y z` the
## positions, and every other property a point attribute of its name, except
## these groups: `nx ny nz` become `N`, `red green blue` (or `diffuse_*`)
## become `Cd` (integers scaled to 0..1) with `alpha` as `Alpha`, and `u v`,
## `s t`, `texture_u texture_v` or `texture_s texture_t` become `uv`. A
## `face` element with a `vertex_indices` (or `vertex_index`) list makes the
## points a mesh, its other properties face attributes and a `texcoord` list
## corner `uv`; without faces the points are a point cloud. Every other
## element's scalar properties become detail arrays named `element.property`.
##
## 3D Gaussian splat files (a vertex element with `f_dc_0..2`, `opacity`,
## `scale_0..2` and `rot_0..3`) keep those raw PLY names, which luce-geocore's
## Bake GSplats turns into the splat conventions. Their `f_rest_*` are
## channel-major (coefficient i of channel c is `f_rest_{c * n + i}`); they
## become one array attribute `f_rest` of RGB items, coefficient-major (item
## i is coefficient i + 1 of red, green and blue), the layout of `sh`. Their
## all-zero normals are dropped.
import memory
from luce_std import math, utf8
from luce_geocore.geocore import Vector3, Mesh
from luce_geocore.core.growing import Growing
from luce_geocore.core.shared import Column
from luce_geocore.kernel import Float3, Attribute, Domain, DataType, GeometrySet, AttributeStore, assembled, put_attribute, mesh_dispose, empty_set, dispose_set, mesh_component, points_component, cloud_assembled, set_put_detail
from header import Header, Property, parse_header
from scalars import Scalar, is_float
from body import Sink, Lane, decode_element
from warnings import Warnings
import compressed
import errors
## The GeometrySet of the PLY file in `data`; what was left out is added to
## `warnings`. The caller disposes of the set.
pub func decode(data: const u8[], warnings: Warnings*) -> GeometrySet*!:
var header = try parse_header(data)
defer header.close()
if compressed.is_compressed(&header):
return try compressed.decode(&header, data, warnings)
let geometry = try empty_set()
errdefer dispose_set(geometry)
var points = Points()
defer points.close()
var faces = Faces()
defer faces.close()
let vertex = header.find("vertex")
var face = header.find("face")
if face >= 0 and header.property((usize)face, "vertex_indices") < 0 and header.property((usize)face, "vertex_index") < 0:
try warnings.add("The face element has no vertex_indices list; it is kept as detail arrays")
face = -1
var at = header.body
for element in 0..<header.elements.count:
if (i64)element == vertex:
at = try read_points(&header, element, data, at, &points, warnings)
elif (i64)element == face:
at = try read_faces(&header, element, data, at, &faces, warnings)
else:
at = try read_details(&header, element, data, at, geometry, warnings)
if faces.read and faces.counts.count > 0:
let mesh = try faces.assemble(&points, warnings)
try geometry.put(mesh_component(), (void*)mesh)
elif points.count > 0:
let attributes = try points.store()
# cloud_assembled takes the positions and the attributes, even on failure.
let cloud = try cloud_assembled(points.positions.take(), points.origin, attributes)
try geometry.put(points_component(), (void*)cloud)
return geometry
# mark: Attributes being filled
## Attributes whose columns the decoder fills, owned until they are handed on.
struct Pending:
var attributes: Growing[Attribute]
## Keep `attribute` and return its column's first byte.
func add(attribute: Attribute) -> u8*!:
var owned = attribute
self.attributes.push(owned) catch failure:
owned.release()
error(failure.code, failure.message)
return owned.data.span().data
## A new attribute of `kind` (`width` components per element), kept.
func create(name: str, domain: Domain, kind: DataType, width: usize, elements: usize) -> u8*!:
return try self.add(try Attribute.create(name, domain, kind, width, elements))
func index_of(name: str) -> i64:
for at in 0..<self.attributes.count:
if self.attributes.items[at].name() == name: return (i64)at
return -1
func remove(index: usize):
self.attributes.items[index].release()
for at in index + 1..<self.attributes.count: self.attributes.items[at - 1] = self.attributes.items[at]
self.attributes.count -= 1
func close():
for at in 0..<self.attributes.count: self.attributes.items[at].release()
self.attributes.close()
## One sink per property of an element, closed together.
struct Sinks:
var items: Growing[Sink]
static func of(count: usize) -> Sinks!:
var sinks = Sinks()
errdefer sinks.close()
for at in 0..<count:
_ = at
try sinks.items.push(Sink())
return sinks
func close():
for at in 0..<self.items.count: self.items.items[at].close()
self.items.close()
## The column type and sink lane a scalar property is kept in: every value
## exactly (uint32 needs int64; there is no unsigned type).
func column_kind(kind: Scalar) -> (DataType, Lane):
match kind:
.int8: return (DataType.int8, Lane.int8)
.uint8, .int16, .uint16, .int32: return (DataType.int32, Lane.int32)
.uint32: return (DataType.int64, Lane.int64)
.float32: return (DataType.float32, Lane.float32)
_: return (DataType.float64, Lane.float64)
## The factor that brings a color channel of `kind` to 0..1.
func color_scale(kind: Scalar) -> f64:
if kind == Scalar.uint16 or kind == Scalar.int16: return 1.0 / 65535.0
return 1.0 if is_float(kind) else 1.0 / 255.0
## Whether `name` can name an attribute.
func usable(name: str) -> bool:
return name.length > 0 and name.length <= 64 and name != "P"
## The indices of a group of scalar properties named `names`, when every one
## is there; claims them in `taken`.
func group(properties: const Property[], names: const str[], found: i64[], taken: bool[]) -> bool:
for at in 0..<names.length:
found[at] = -1
for index in 0..<properties.length:
if properties[index].name == names[at] and not properties[index].is_list and not taken[index]: found[at] = (i64)index
if found[at] < 0: return false
for at in 0..<names.length: taken[(usize)found[at]] = true
return true
## Plan the attributes of an element's properties not yet `taken`: the
## groups (N, Cd and Alpha, uv) and then one attribute per scalar property.
## List properties are kept in their sinks for `finish_lists`.
func plan_attributes(properties: const Property[], domain: Domain, rows: usize, sinks: Sink[], taken: bool[], pending: Pending*, warnings: Warnings*) -> !:
var found: i64[4]
let normal_names: str[3] = ["nx", "ny", "nz"]
if group(properties, normal_names, found, taken):
let data = try pending.create("N", domain, DataType.float32, 3, rows)
for lane in 0..<(usize)3: sinks[(usize)found[lane]] = Sink(data = data + lane * 4, lane = Lane.float32, stride = 12)
let color_names: str[3] = ["red", "green", "blue"]
let diffuse_names: str[3] = ["diffuse_red", "diffuse_green", "diffuse_blue"]
if group(properties, color_names, found, taken) or group(properties, diffuse_names, found, taken):
let data = try pending.create("Cd", domain, DataType.float32, 3, rows)
for lane in 0..<(usize)3:
let index = (usize)found[lane]
sinks[index] = Sink(data = data + lane * 4, lane = Lane.float32, stride = 12, scale = color_scale(properties[index].kind))
let alpha_names: str[1] = ["alpha"]
let diffuse_alpha: str[1] = ["diffuse_alpha"]
if group(properties, alpha_names, found, taken) or group(properties, diffuse_alpha, found, taken):
let index = (usize)found[0]
sinks[index] = Sink(data = try pending.create("Alpha", domain, DataType.float32, 1, rows), lane = Lane.float32, stride = 4, scale = color_scale(properties[index].kind))
let uv_names: str[8] = ["u", "v", "s", "t", "texture_u", "texture_v", "texture_s", "texture_t"]
for pair in 0..<(usize)4:
if group(properties, uv_names[pair * 2..<pair * 2 + 2], found, taken):
let data = try pending.create("uv", domain, DataType.float32, 2, rows)
sinks[(usize)found[0]] = Sink(data = data, lane = Lane.float32, stride = 8)
sinks[(usize)found[1]] = Sink(data = data + 4, lane = Lane.float32, stride = 8)
break
for index in 0..<properties.length:
if taken[index]: continue
let property = &properties[index]
if not usable(property.name):
try warnings.add("Skipped a PLY property whose name cannot name an attribute")
taken[index] = true
continue
if property.is_list:
sinks[index].keep = true
continue
let (kind, lane) = column_kind(property.kind)
let data = try pending.create(property.name, domain, kind, 1, rows)
sinks[index] = Sink(data = data, lane = lane, stride = lane_bytes(lane))
taken[index] = true
## Bytes of one value of `lane`.
func lane_bytes(lane: Lane) -> usize:
match lane:
.int8: return 1
.float32, .int32: return 4
_: return 8
## Array attributes from the kept list properties not `taken`: f32 items
## for float lists, i32 otherwise, one array per row (rows `kept` only,
## when given).
func finish_lists(properties: const Property[], domain: Domain, sinks: Sink[], taken: const bool[], kept: const bool[], pending: Pending*) -> !:
for index in 0..<properties.length:
if taken[index] or not properties[index].is_list or not sinks[index].keep: continue
let sink = &sinks[index]
let floats = is_float(properties[index].kind)
let counts = sink.counts.view()
var rows: usize = 0
var items: usize = 0
for row in 0..<counts.length:
if kept.length > 0 and not kept[row]: continue
rows += 1
items += (usize)counts[row]
var offsets = try Column[u8].allocate((rows + 1) * 4)
errdefer offsets.release()
var values = try Column[u8].allocate(items * 4)
errdefer values.release()
let bounds = offsets.span()
let out = values.span()
var row_out: usize = 0
var item_out: usize = 0
var item_in: usize = 0
memory.write[u32]((void*)&bounds[0], 0)
for row in 0..<counts.length:
let count = (usize)counts[row]
if kept.length > 0 and not kept[row]:
item_in += count
continue
for item in 0..<count:
if floats: memory.write[f32]((void*)&out[(item_out + item) * 4], sink.floats.items[item_in + item])
else: memory.write[i32]((void*)&out[(item_out + item) * 4], sink.integers.items[item_in + item])
item_in += count
item_out += count
row_out += 1
memory.write[u32]((void*)&bounds[row_out * 4], (u32)item_out)
_ = try pending.add(try Attribute.ragged(properties[index].name, domain, DataType.float32 if floats else DataType.int32, 1, offsets.take(), values.take()))
# mark: Points
## The vertex element's positions and attributes.
struct Points:
var count: usize = 0
var positions: Column[Float3]
var origin: Vector3
var pending: Pending
## The attributes as a store (taken from `pending`).
func store() -> AttributeStore!:
var store = AttributeStore()
errdefer store.close()
let count = self.pending.attributes.count
self.pending.attributes.count = 0
for at in 0..<count:
store.put(self.pending.attributes.items[at]) catch failure:
for rest in at + 1..<count: self.pending.attributes.items[rest].release()
error(failure.code, failure.message)
return store
func close():
self.positions.release()
self.pending.close()
## The properties of a 3DGS splat file, when `properties` are one: the
## number of `f_rest_*` (0, 9, 24 or 45), else -1.
func splat_rest(properties: const Property[]) -> i64:
let required: str[11] = ["f_dc_0", "f_dc_1", "f_dc_2", "opacity", "scale_0", "scale_1", "scale_2", "rot_0", "rot_1", "rot_2", "rot_3"]
for name in required:
var present = false
for property in properties: present = present or (property.name == name and not property.is_list)
if not present: return -1
var rest: usize = 0
var name_buffer: u8[16]
while rest < 45:
let name = rest_name(name_buffer, rest)
var present = false
for property in properties: present = present or (property.name == name and not property.is_list)
if not present: break
rest += 1
return (i64)rest if rest == 0 or rest == 9 or rest == 24 or rest == 45 else -1
## "f_rest_{index}" in `buffer`.
pub func rest_name(buffer: u8[], index: usize) -> str:
let prefix = "f_rest_"
memory.copy(buffer[..<prefix.length], prefix.bytes, prefix.length)
var length = prefix.length
if index >= 10:
buffer[length] = (u8)(48 + index // 10)
length += 1
buffer[length] = (u8)(48 + index % 10)
return (str)buffer[..<length + 1]
func read_points(header: const Header*, element: usize, data: const u8[], at: usize, points: Points*, warnings: Warnings*) -> usize!:
let properties = header.properties_of(element)
let rows = header.elements.items[element].count
points.count = rows
var sinks = try Sinks.of(properties.length)
defer sinks.close()
let sink = sinks.items.items[..<sinks.items.count]
var taken_storage = Growing[bool]()
defer taken_storage.close()
try taken_storage.fill(properties.length, false)
let taken = taken_storage.items[..<properties.length]
# Positions: f32 straight into the column, or through f64 to pick an origin.
var found: i64[4]
let position_names: str[3] = ["x", "y", "z"]
if not group(properties, position_names, found, taken): error(errors.invalid, "the PLY vertex element has no x, y and z")
points.positions = try Column[Float3].allocate(rows)
var precise = Growing[f64]()
defer precise.close()
var wide = false
for lane in 0..<(usize)3: wide = wide or properties[(usize)found[lane]].kind == Scalar.float64
let base = (u8*)points.positions.span().data
if wide:
try precise.fill(rows * 3, 0.0)
for lane in 0..<(usize)3: sink[(usize)found[lane]] = Sink(data = (u8*)precise.items.data + lane * 8, lane = Lane.float64, stride = 24)
else:
for lane in 0..<(usize)3: sink[(usize)found[lane]] = Sink(data = base + lane * 4, lane = Lane.float32, stride = 12)
# A splat file's spherical harmonics, interleaved as they are read.
let rest = splat_rest(properties)
if rest > 0:
let count = (usize)rest
let per_channel = count // 3
var offsets = try Column[u8].allocate((rows + 1) * 4)
errdefer offsets.release()
let bounds = offsets.span()
for row in 0..<rows + 1: memory.write[u32]((void*)&bounds[row * 4], (u32)(row * per_channel))
var values = try Column[u8].allocate(rows * count * 4)
errdefer values.release()
let items = try points.pending.add(try Attribute.ragged("f_rest", Domain.point, DataType.float32, 3, offsets.take(), values.take()))
var name_buffer: u8[16]
for index in 0..<count:
let channel = index // per_channel
let coefficient = index % per_channel
let property = (usize)header.property(element, rest_name(name_buffer, index))
sink[property] = Sink(data = items + (coefficient * 3 + channel) * 4, lane = Lane.float32, stride = count * 4)
taken[property] = true
try plan_attributes(properties, Domain.point, rows, sink, taken, &points.pending, warnings)
let next = try decode_element(header, element, data, at, sink)
var no_rows: bool[]
try finish_lists(properties, Domain.point, sink, taken, no_rows, &points.pending)
if wide:
points.origin = middle(precise.view())
let out = points.positions.span()
let values = precise.view()
for row in 0..<rows:
out[row] = Float3((f32)(values[row * 3] - points.origin.x), (f32)(values[row * 3 + 1] - points.origin.y), (f32)(values[row * 3 + 2] - points.origin.z))
if rest >= 0: drop_zero_normals(&points.pending)
return next
## The middle of the bounds of xyz triples (zero for none).
func middle(values: const f64[]) -> Vector3:
if values.length == 0: return Vector3()
var low: f64[3] = [values[0], values[1], values[2]]
var high: f64[3] = [values[0], values[1], values[2]]
for row in 0..<values.length // 3:
for lane in 0..<(usize)3:
low[lane] = math.min(low[lane], values[row * 3 + lane])
high[lane] = math.max(high[lane], values[row * 3 + lane])
return Vector3((low[0] + high[0]) * 0.5, (low[1] + high[1]) * 0.5, (low[2] + high[2]) * 0.5)
## Splat files carry placeholder normals of zero; drop them.
func drop_zero_normals(pending: Pending*):
let index = pending.index_of("N")
if index < 0: return
let bytes = pending.attributes.items[(usize)index].data.view()
for at in 0..<bytes.length // 4:
if memory.read[u32]((const void*)&bytes[at * 4]) != 0: return
pending.remove((usize)index)
# mark: Faces
## The face element: each face's corner count and points, and attributes.
struct Faces:
var read: bool = false
var counts: Growing[u32]
var corners: Growing[i32]
var texcoords: Growing[u32]
var texcoord_items: Growing[f32]
var pending: Pending
## Faces kept (three corners or more), by face row.
var kept: Growing[bool]
## The mesh of these faces over `points` (their columns taken).
func assemble(points: Points*, warnings: Warnings*) -> Mesh*!:
let point_count = points.count
let rows = self.counts.count
var faces: usize = 0
var corner_total: usize = 0
var dropped = false
var at: usize = 0
for row in 0..<rows:
let size = (usize)self.counts.items[row]
for corner in at..<at + size:
let index = self.corners.items[corner]
if index < 0 or (usize)index >= point_count: error(errors.invalid, "a PLY face names a vertex that does not exist")
at += size
let keep = size >= 3
dropped = dropped or not keep
if keep:
faces += 1
corner_total += size
if dropped: try warnings.add("Dropped PLY faces with fewer than three vertices")
var offsets = try Column[i32].allocate(faces + 1)
defer offsets.release()
var corners = try Column[i32].allocate(corner_total)
defer corners.release()
var triangles = try Column[i32].allocate(corner_total * 3 - faces * 6)
defer triangles.release()
let triangle_span = triangles.span()
# -1: geocore ear-clips each face.
for slot in 0..<triangle_span.length: triangle_span[slot] = -1
try self.kept.fill(rows, false)
let offset_span = offsets.span()
let corner_span = corners.span()
var face_out: usize = 0
var corner_out: usize = 0
at = 0
for row in 0..<rows:
let size = (usize)self.counts.items[row]
if size >= 3:
self.kept.items[row] = true
offset_span[face_out] = (i32)corner_out
memory.copy(corner_span[corner_out..<corner_out + size], self.corners.items[at..<at + size], size)
face_out += 1
corner_out += size
at += size
offset_span[faces] = (i32)corner_out
var no_normals: Column[Float3]
var no_precise: Column[Vector3]
let mesh = try assembled(points.positions.take(), points.origin, offsets.take(), corners.take(), triangles.take(), no_normals, no_precise)
errdefer mesh_dispose(mesh)
let kept = self.kept.items[..<rows]
var empty_rows: bool[]
try hand_on(&points.pending, mesh, empty_rows, 0)
try hand_on(&self.pending, mesh, kept if dropped else empty_rows, faces)
try self.put_texcoords(mesh, kept, corner_total, warnings)
return mesh
## Corner `uv` from the `texcoord` lists, when every kept face has two
## numbers per corner.
func put_texcoords(mesh: Mesh*, kept: const bool[], corner_total: usize, warnings: Warnings*) -> !:
if self.texcoords.count == 0: return
for row in 0..<kept.length:
if kept[row] and (usize)self.texcoords.items[row] != (usize)self.counts.items[row] * 2:
try warnings.add("Skipped PLY texcoord lists that do not hold two numbers per corner")
return
var attribute = try Attribute.create("uv", Domain.corner, DataType.float32, 2, corner_total)
let out = attribute.data.span()
var item: usize = 0
var corner: usize = 0
for row in 0..<kept.length:
let count = (usize)self.texcoords.items[row]
if kept[row]:
for at in 0..<count: memory.write[f32]((void*)&out[(corner * 2 + at) * 4], self.texcoord_items.items[item + at])
corner += count // 2
item += count
# put_attribute takes the attribute, releasing it on failure.
try put_attribute(mesh, attribute)
func close():
self.counts.close()
self.corners.close()
self.texcoords.close()
self.texcoord_items.close()
self.pending.close()
self.kept.close()
## Put every pending attribute on `mesh`, in order; with `kept`, array
## (non-ragged) ones keep only those rows, `count` of them.
func hand_on(pending: Pending*, mesh: Mesh*, kept: const bool[], count: usize) -> !:
let total = pending.attributes.count
pending.attributes.count = 0
for at in 0..<total:
var attribute = pending.attributes.items[at]
if kept.length > 0 and not attribute.is_ragged():
let compacted = compact(&attribute, kept, count) catch failure:
for rest in at..<total: pending.attributes.items[rest].release()
error(failure.code, failure.message)
attribute.release()
attribute = compacted
put_attribute(mesh, attribute) catch failure:
for rest in at + 1..<total: pending.attributes.items[rest].release()
error(failure.code, failure.message)
## `attribute`'s rows marked in `kept`, `count` of them, in a new attribute.
func compact(attribute: const Attribute*, kept: const bool[], count: usize) -> Attribute!:
var result = try Attribute.create(attribute.name(), attribute.domain, attribute.kind, attribute.width, count)
let tuple = attribute.tuple_bytes()
let source = attribute.data.view()
let out = result.data.span()
var row_out: usize = 0
for row in 0..<kept.length:
if not kept[row]: continue
memory.copy(out[row_out * tuple..<(row_out + 1) * tuple], source[row * tuple..<(row + 1) * tuple], tuple)
row_out += 1
result.role = attribute.role
return result
func read_faces(header: const Header*, element: usize, data: const u8[], at: usize, faces: Faces*, warnings: Warnings*) -> usize!:
let properties = header.properties_of(element)
let rows = header.elements.items[element].count
var sinks = try Sinks.of(properties.length)
defer sinks.close()
let sink = sinks.items.items[..<sinks.items.count]
var taken_storage = Growing[bool]()
defer taken_storage.close()
try taken_storage.fill(properties.length, false)
let taken = taken_storage.items[..<properties.length]
var indices = header.property(element, "vertex_indices")
if indices < 0: indices = header.property(element, "vertex_index")
if not properties[(usize)indices].is_list or is_float(properties[(usize)indices].kind): error(errors.invalid, "PLY vertex_indices must be a list of integers")
sink[(usize)indices].keep = true
taken[(usize)indices] = true
let texcoord = header.property(element, "texcoord")
if texcoord >= 0 and properties[(usize)texcoord].is_list:
sink[(usize)texcoord].keep = true
taken[(usize)texcoord] = true
try plan_attributes(properties, Domain.face, rows, sink, taken, &faces.pending, warnings)
let next = try decode_element(header, element, data, at, sink)
# Rows with fewer than three corners are dropped later; list attributes skip them now.
var kept = Growing[bool]()
defer kept.close()
for row in 0..<rows: try kept.push(sink[(usize)indices].counts.items[row] >= 3)
try finish_lists(properties, Domain.face, sink, taken, kept.view(), &faces.pending)
faces.read = true
swap_growing[u32](&faces.counts, &sink[(usize)indices].counts)
swap_growing[i32](&faces.corners, &sink[(usize)indices].integers)
if texcoord >= 0 and properties[(usize)texcoord].is_list:
let source = &sink[(usize)texcoord]
swap_growing[u32](&faces.texcoords, &source.counts)
if source.integers.count > 0:
for value in source.integers.view(): try faces.texcoord_items.push((f32)value)
else:
swap_growing[f32](&faces.texcoord_items, &source.floats)
return next
## Exchange two growing arrays' storage.
func swap_growing[T](a: Growing[T]*, b: Growing[T]*):
let held = *a
*a = *b
*b = held
# mark: Other elements
## Element `element`'s scalar properties as detail arrays `element.property`.
func read_details(header: const Header*, element: usize, data: const u8[], at: usize, geometry: GeometrySet*, warnings: Warnings*) -> usize!:
let properties = header.properties_of(element)
let rows = header.elements.items[element].count
var sinks = try Sinks.of(properties.length)
defer sinks.close()
let sink = sinks.items.items[..<sinks.items.count]
var pending = Pending()
defer pending.close()
let element_name = header.elements.items[element].name
var name_buffer: u8[160]
for index in 0..<properties.length:
let property = &properties[index]
if property.is_list:
try warnings.add("Left out list properties of PLY elements other than vertex and face")
continue
let length = element_name.length + 1 + property.name.length
if length > 64:
try warnings.add("Left out PLY properties whose element.property name is longer than 64 bytes")
continue
memory.copy(name_buffer[..<element_name.length], element_name.bytes, element_name.length)
name_buffer[element_name.length] = '.'
memory.copy(name_buffer[element_name.length + 1..<length], property.name.bytes, property.name.length)
let floats = is_float(property.kind)
var offsets = try Column[u8].allocate(8)
errdefer offsets.release()
let bounds = offsets.span()
memory.write[u32]((void*)&bounds[0], 0)
memory.write[u32]((void*)&bounds[4], (u32)rows)
var values = try Column[u8].allocate(rows * 4)
errdefer values.release()
let target = try pending.add(try Attribute.ragged((str)name_buffer[..<length], Domain.detail, DataType.float32 if floats else DataType.int32, 1, offsets.take(), values.take()))
if (property.kind == Scalar.uint32 or property.kind == Scalar.float64):
try warnings.add("PLY uint and double properties of other elements are kept as 32-bit detail arrays")
sink[index] = Sink(data = target, lane = Lane.float32 if floats else Lane.int32, stride = 4)
let next = try decode_element(header, element, data, at, sink)
let total = pending.attributes.count
pending.attributes.count = 0
for index in 0..<total:
set_put_detail(geometry, pending.attributes.items[index]) catch failure:
for rest in index + 1..<total: pending.attributes.items[rest].release()
error(failure.code, failure.message)
return next