dymokomi/luce-ply
Source of release 0.1.0
## PLY's scalar types and how their bytes read and write, in either byte
## order. Values pass through f64, which holds every PLY scalar exactly.
import memory
from luce_std import math
## The eight PLY scalar types (`char` or `int8`, ..., `double` or `float64`).
pub enum Scalar as u8:
int8 = 0
uint8 = 1
int16 = 2
uint16 = 3
int32 = 4
uint32 = 5
float32 = 6
float64 = 7
## Bytes of one value of `kind`.
pub func size_of(kind: Scalar) -> usize:
match kind:
.int8, .uint8: return 1
.int16, .uint16: return 2
.float64: return 8
_: return 4
## Whether `kind` is a float type.
pub func is_float(kind: Scalar) -> bool:
return kind == Scalar.float32 or kind == Scalar.float64
## The type a header names, by its classic or sized name.
pub func scalar_named(name: str) -> Scalar?:
if name == "char" or name == "int8": return Scalar.int8
if name == "uchar" or name == "uint8": return Scalar.uint8
if name == "short" or name == "int16": return Scalar.int16
if name == "ushort" or name == "uint16": return Scalar.uint16
if name == "int" or name == "int32": return Scalar.int32
if name == "uint" or name == "uint32": return Scalar.uint32
if name == "float" or name == "float32": return Scalar.float32
if name == "double" or name == "float64": return Scalar.float64
return none
## The classic name a writer uses for `kind`.
pub func scalar_name(kind: Scalar) -> str:
match kind:
.int8: return "char"
.uint8: return "uchar"
.int16: return "short"
.uint16: return "ushort"
.int32: return "int"
.uint32: return "uint"
.float32: return "float"
_: return "double"
## The 16-bit value at `at`, swapped when `swap`.
pub inline func load16(at: const u8*, swap: bool) -> u16:
let value = memory.read[u16]((const void*)at)
if not swap: return value
return (value >> 8) | (value << 8)
pub inline func load32(at: const u8*, swap: bool) -> u32:
let value = memory.read[u32]((const void*)at)
if not swap: return value
return swap32(value)
pub inline func load64(at: const u8*, swap: bool) -> u64:
let value = memory.read[u64]((const void*)at)
if not swap: return value
return ((u64)swap32((u32)value) << 32) | (u64)swap32((u32)(value >> 32))
## `value` with its four bytes reversed.
pub inline func swap32(value: u32) -> u32:
return (value >> 24) | ((value >> 8) & 0xFF00) | ((value << 8) & 0xFF0000) | (value << 24)
## The value of `kind` at `at` (swapped when `swap`), as f64.
pub inline func load(at: const u8*, kind: Scalar, swap: bool) -> f64:
match kind:
.int8: return (f64)(i8)at[0]
.uint8: return (f64)at[0]
.int16: return (f64)(i16)load16(at, swap)
.uint16: return (f64)load16(at, swap)
.int32: return (f64)(i32)load32(at, swap)
.uint32: return (f64)load32(at, swap)
.float32: return (f64)f32.bits(load32(at, swap))
_: return f64.bits(load64(at, swap))
## Write `value` as `kind` at `at` (swapped when `swap`). Integers round to
## the nearest and clamp to the type's range; NaN becomes 0.
pub inline func store(at: u8*, kind: Scalar, swap: bool, value: f64):
match kind:
.int8: at[0] = (u8)(i8)clamped(value, -128.0, 127.0)
.uint8: at[0] = (u8)clamped(value, 0.0, 255.0)
.int16: store16(at, (u16)(i16)clamped(value, -32768.0, 32767.0), swap)
.uint16: store16(at, (u16)clamped(value, 0.0, 65535.0), swap)
.int32: store32(at, (u32)(i32)clamped(value, -2147483648.0, 2147483647.0), swap)
.uint32: store32(at, (u32)clamped(value, 0.0, 4294967295.0), swap)
.float32: store32(at, ((f32)value).bits(), swap)
_: store64(at, value.bits(), swap)
inline func clamped(value: f64, low: f64, high: f64) -> f64:
if not (value == value): return 0.0
let rounded = math.round(value)
if rounded < low: return low
if rounded > high: return high
return rounded
pub inline func store16(at: u8*, value: u16, swap: bool):
memory.write[u16]((void*)at, (value >> 8) | (value << 8) if swap else value)
pub inline func store32(at: u8*, value: u32, swap: bool):
memory.write[u32]((void*)at, swap32(value) if swap else value)
pub inline func store64(at: u8*, value: u64, swap: bool):
if not swap:
memory.write[u64]((void*)at, value)
return
memory.write[u64]((void*)at, ((u64)swap32((u32)value) << 32) | (u64)swap32((u32)(value >> 32)))