// Ported from meshoptimizer 1.3.0 (src/vertexcodec.cpp): MIT License, Copyright (c) 2016-2026
// Arseny Kapoulkine. See NOTICE.
///|
const VERTEX_HEADER : Int32 = 0xa0
///|
const VERTEX_BLOCK_SIZE_BYTES : Int32 = 8192
///|
const VERTEX_BLOCK_MAX_SIZE : Int32 = 256
///|
const BYTE_GROUP_SIZE : Int32 = 16
///|
/// Bytes a byte group may read (16 deltas of 4 bits with all 16 sentinels), checked
/// before each group so a group's reads stay inside the input.
const BYTE_GROUP_DECODE_LIMIT : Int32 = 24
///|
/// Bits per delta for a group's 2-bit header: v0 headers index 0..3, v1 headers
/// index 4 + control (0 or 1) onwards, as `decodeBytesSimd`'s `hshift`.
let group_bits : FixedArray[Int32] = [0, 2, 4, 8, 0, 1, 2, 4, 8]
///|
fn vertex_block_size(vertex_size : Int32) -> Int32 {
let result = (VERTEX_BLOCK_SIZE_BYTES / vertex_size) &
(BYTE_GROUP_SIZE - 1).lnot()
if result < VERTEX_BLOCK_MAX_SIZE {
result
} else {
VERTEX_BLOCK_MAX_SIZE
}
}
///|
/// `meshopt_decodeVertexBuffer` on `source[start:end]` into `target`; `vertex_size` is a
/// multiple of 4 up to 256 and `target` holds `count * vertex_size` bytes.
fn decode_vertex_buffer(
target : FixedArray[Byte],
count : Int32,
vertex_size : Int32,
source : FixedArray[Byte],
start : Int32,
end : Int32,
) -> Bool {
if end - start < 1 {
return false
}
let header = source[start].to_int()
if (header & 0xf0) != VERTEX_HEADER {
return false
}
let version = header & 0x0f
if version > 1 {
return false
}
let tail_size = vertex_size + (if version == 0 { 0 } else { vertex_size / 4 })
let tail_min = if version == 0 { 32 } else { 24 }
let tail_pad = if tail_size < tail_min { tail_min } else { tail_size }
let mut data = start + 1
if end - data < tail_pad {
return false
}
let tail = end - tail_size
let last = FixedArray::make(256, b'\x00')
for i in 0.. Int32 {
let aligned = (vertex_count + BYTE_GROUP_SIZE - 1) &
(BYTE_GROUP_SIZE - 1).lnot()
let control_size = if version == 0 { 0 } else { vertex_size / 4 }
let mut data = start
if end - data < control_size {
return -1
}
let control = data
data += control_size
for k = 0; k < vertex_size; k = k + 4 {
let ctrl_byte = if version == 0 {
0
} else {
source[control + k / 4].to_int()
}
for j in 0..<4 {
let ctrl = (ctrl_byte >> (j * 2)) & 3
let base = j * aligned
if ctrl == 3 {
// The SIMD decoder over-copies a whole aligned run, so it asks for that much.
if end - data < aligned {
return -1
}
for i in 0..
decode_deltas8(
buffer,
aligned,
target,
out + k,
vertex_count,
vertex_size,
last,
k,
)
1 =>
decode_deltas16(
buffer,
aligned,
target,
out + k,
vertex_count,
vertex_size,
last,
k,
)
2 =>
decode_deltas_xor(
buffer,
aligned,
target,
out + k,
vertex_count,
vertex_size,
last,
k,
(32 - (channel >> 4)) & 31,
)
_ => return -1
}
}
let final_ = out + (vertex_count - 1) * vertex_size
for i in 0.. Int32 {
let header_size = (size / BYTE_GROUP_SIZE + 3) / 4
if end - start < header_size {
return -1
}
let header = start
let mut data = start + header_size
for i = 0; i < size; i = i + BYTE_GROUP_SIZE {
if end - data < BYTE_GROUP_DECODE_LIMIT {
return -1
}
let group = i / BYTE_GROUP_SIZE
let h = (source[header + group / 4].to_int() >> (group % 4 * 2)) & 3
data = decode_bytes_group(
source,
data,
buffer,
base + i,
group_bits[bits + h],
)
}
data
}
///|
/// `decodeBytesGroup`: 16 deltas of `bits` bits, a delta of all ones (in 1, 2 and 4 bits)
/// being a sentinel for a byte that follows. The caller checked 24 bytes remain.
fn decode_bytes_group(
source : FixedArray[Byte],
data : Int32,
buffer : FixedArray[Byte],
out : Int32,
bits : Int32,
) -> Int32 {
match bits {
0 => {
for m in 0..<16 {
buffer[out + m] = b'\x00'
}
data
}
8 => {
for m in 0..<16 {
buffer[out + m] = source[data + m]
}
data + 16
}
_ => {
let sentinel = (1 << bits) - 1
let per_byte = 8 / bits
let mut extra = data + 16 * bits / 8
for m in 0..<16 {
let byte = source[data + m / per_byte].to_int()
// 1-bit deltas run from the low bit up; wider ones from the high bits down.
let shift = if bits == 1 {
m % 8
} else {
8 - bits - m % per_byte * bits
}
let enc = (byte >> shift) & sentinel
if enc == sentinel {
buffer[out + m] = source[extra]
extra += 1
} else {
buffer[out + m] = enc.to_byte()
}
}
extra
}
}
}
///|
/// Byte deltas (channel 0): zigzag differences from the previous vertex's bytes.
fn decode_deltas8(
buffer : FixedArray[Byte],
stride : Int32,
target : FixedArray[Byte],
out : Int32,
vertex_count : Int32,
vertex_size : Int32,
last : FixedArray[Byte],
k : Int32,
) -> Unit {
for j in 0..<4 {
let mut p = last[k + j].to_int()
let mut o = out + j
for i in 0..> 1)) + p
target[o] = p.to_byte()
p = p & 0xff
o += vertex_size
}
}
}
///|
/// 16-bit deltas (channel 1): zigzag differences of little-endian pairs.
fn decode_deltas16(
buffer : FixedArray[Byte],
stride : Int32,
target : FixedArray[Byte],
out : Int32,
vertex_count : Int32,
vertex_size : Int32,
last : FixedArray[Byte],
k : Int32,
) -> Unit {
for j = 0; j < 4; j = j + 2 {
let mut p = last[k + j].to_int() | (last[k + j + 1].to_int() << 8)
let mut o = out + j
for i in 0..> 1)) + p) & 0xffff
target[o] = p.to_byte()
target[o + 1] = (p >> 8).to_byte()
o += vertex_size
}
}
}
///|
/// 32-bit XOR deltas (channel 2): each word rotated left by `rot` and XORed with the
/// previous vertex's.
fn decode_deltas_xor(
buffer : FixedArray[Byte],
stride : Int32,
target : FixedArray[Byte],
out : Int32,
vertex_count : Int32,
vertex_size : Int32,
last : FixedArray[Byte],
k : Int32,
rot : Int32,
) -> Unit {
let mut p = last[k].to_uint() |
(last[k + 1].to_uint() << 8) |
(last[k + 2].to_uint() << 16) |
(last[k + 3].to_uint() << 24)
let mut o = out
for i in 0..> ((32 - rot) & 31))) ^ p
target[o] = p.to_byte()
target[o + 1] = (p >> 8).to_byte()
target[o + 2] = (p >> 16).to_byte()
target[o + 3] = (p >> 24).to_byte()
o += vertex_size
}
}