Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ply

Source of release 0.1.0

0.1.0 / src / reader.lucb

## 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