use super::{filter_encode, index_encode, vertex_encode};
use crate::{workspace::checked_bytes, Error, Workspace};
use alloc::vec::Vec;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct VertexEncoding {
version: u8,
level: u8,
}
impl VertexEncoding {
pub const DEFAULT: Self = Self {
version: 1,
level: 2,
};
pub const fn new(version: u8, level: u8) -> Result<Self, Error> {
if version > 1 {
return Err(Error::UnsupportedVersion);
}
if level > 9 {
return Err(Error::InvalidParameter);
}
Ok(Self { version, level })
}
pub const fn version(self) -> u8 {
self.version
}
pub const fn level(self) -> u8 {
self.level
}
}
impl Default for VertexEncoding {
fn default() -> Self {
Self::DEFAULT
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct IndexEncoding {
version: u8,
}
impl IndexEncoding {
pub const DEFAULT: Self = Self { version: 1 };
pub const fn new(version: u8) -> Result<Self, Error> {
if version > 1 {
return Err(Error::UnsupportedVersion);
}
Ok(Self { version })
}
pub const fn version(self) -> u8 {
self.version
}
}
impl Default for IndexEncoding {
fn default() -> Self {
Self::DEFAULT
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ExpMode {
Separate,
SharedVector,
SharedComponent,
Clamped,
}
#[inline]
fn vertex_layout(count: usize, stride: usize) -> Result<usize, Error> {
if stride == 0 || stride > 256 || !stride.is_multiple_of(4) {
return Err(Error::InvalidLayout);
}
checked_bytes(count, stride)
}
#[inline]
pub fn encode_vertex_buffer_bound(count: usize, stride: usize) -> Result<usize, Error> {
if stride == 0 || stride > 256 || !stride.is_multiple_of(4) {
return Err(Error::InvalidLayout);
}
vertex_encode::bound(count, stride)
}
#[inline]
pub fn encode_index_buffer_bound(index_count: usize, vertex_count: usize) -> Result<usize, Error> {
if !index_count.is_multiple_of(3) {
return Err(Error::InvalidTopology);
}
index_encode::index_bound(index_count, vertex_count as u64)
}
#[inline]
pub fn encode_index_sequence_bound(
index_count: usize,
vertex_count: usize,
) -> Result<usize, Error> {
index_encode::sequence_bound(index_count, vertex_count as u64)
}
fn allocate(
bound: usize,
input: usize,
workspace: &mut Workspace,
encode: impl FnOnce(&mut [u8]) -> Result<usize, Error>,
) -> Result<Vec<u8>, Error> {
let mut work = workspace.begin();
let check = (|| {
workspace.account_codec(bound)?;
work.add(input)?;
work.add(bound)
})();
workspace.finish(&work);
check?;
let mut out = Vec::new();
out.try_reserve_exact(bound)
.map_err(|_| Error::AllocationFailed)?;
if out.capacity() != bound {
workspace.account_codec(out.capacity())?;
}
out.resize(bound, 0);
let used = encode(&mut out)?;
out.truncate(used);
Ok(out)
}
fn into(
bound: usize,
capacity: usize,
input: usize,
workspace: &mut Workspace,
encode: impl FnOnce() -> Result<usize, Error>,
) -> Result<usize, Error> {
let mut work = workspace.begin();
let result = (|| {
workspace.account_codec(0)?;
work.add(input)?;
work.add(bound.min(capacity))?;
encode()
})();
workspace.finish(&work);
result
}
pub fn encode_vertex_buffer(
vertices: &[u8],
count: usize,
stride: usize,
encoding: VertexEncoding,
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
let _ = workspace.begin();
if vertices.len() != vertex_layout(count, stride)? {
return Err(Error::InvalidLayout);
}
let bound = vertex_encode::bound(count, stride)?;
allocate(bound, vertices.len(), workspace, |out| {
vertex_encode::encode(
out,
vertices,
count,
stride,
encoding.version,
encoding.level,
)
})
}
pub fn encode_vertex_buffer_into(
destination: &mut [u8],
vertices: &[u8],
count: usize,
stride: usize,
encoding: VertexEncoding,
workspace: &mut Workspace,
) -> Result<usize, Error> {
let _ = workspace.begin();
if vertices.len() != vertex_layout(count, stride)? {
return Err(Error::InvalidLayout);
}
let bound = vertex_encode::bound(count, stride)?;
let capacity = destination.len();
into(bound, capacity, vertices.len(), workspace, || {
vertex_encode::encode(
destination,
vertices,
count,
stride,
encoding.version,
encoding.level,
)
})
}
fn max_vertices(indices: &[u32]) -> u64 {
if indices.is_empty() {
return 0;
}
u64::from(indices.iter().fold(0, |a, &b| a | b)) + 1
}
pub fn encode_index_buffer(
indices: &[u32],
encoding: IndexEncoding,
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
let _ = workspace.begin();
if !indices.len().is_multiple_of(3) {
return Err(Error::InvalidTopology);
}
let bound = index_encode::index_bound(indices.len(), max_vertices(indices))?;
let input = checked_bytes(indices.len(), 4)?;
allocate(bound, input, workspace, |out| {
index_encode::encode_index_buffer(out, indices, encoding.version)
})
}
pub fn encode_index_buffer_into(
destination: &mut [u8],
indices: &[u32],
encoding: IndexEncoding,
workspace: &mut Workspace,
) -> Result<usize, Error> {
let _ = workspace.begin();
if !indices.len().is_multiple_of(3) {
return Err(Error::InvalidTopology);
}
let bound = index_encode::index_bound(indices.len(), 1 << 32)?;
let input = checked_bytes(indices.len(), 4)?;
let capacity = destination.len();
into(bound, capacity, input, workspace, || {
index_encode::encode_index_buffer(destination, indices, encoding.version)
})
}
pub fn encode_index_sequence(
indices: &[u32],
encoding: IndexEncoding,
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
let _ = workspace.begin();
let bound = index_encode::sequence_bound(indices.len(), max_vertices(indices))?;
let input = checked_bytes(indices.len(), 4)?;
allocate(bound, input, workspace, |out| {
index_encode::encode_index_sequence(out, indices, encoding.version)
})
}
pub fn encode_index_sequence_into(
destination: &mut [u8],
indices: &[u32],
encoding: IndexEncoding,
workspace: &mut Workspace,
) -> Result<usize, Error> {
let _ = workspace.begin();
let bound = index_encode::sequence_bound(indices.len(), 1 << 32)?;
let input = checked_bytes(indices.len(), 4)?;
let capacity = destination.len();
into(bound, capacity, input, workspace, || {
index_encode::encode_index_sequence(destination, indices, encoding.version)
})
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Kind {
Oct,
Quat,
Exp(ExpMode),
Color,
}
fn filter_layout(
kind: Kind,
count: usize,
stride: usize,
bits: u32,
data: &[f32],
) -> Result<usize, Error> {
let (layout, floats, range) = match kind {
Kind::Oct | Kind::Color => (stride == 4 || stride == 8, 4, 2..=16),
Kind::Quat => (stride == 8, 4, 4..=16),
Kind::Exp(_) => (
stride > 0 && stride <= 256 && stride.is_multiple_of(4),
stride / 4,
1..=24,
),
};
if !layout {
return Err(Error::InvalidLayout);
}
if !range.contains(&bits)
|| (stride == 4 && bits > 8 && matches!(kind, Kind::Oct | Kind::Color))
{
return Err(Error::InvalidParameter);
}
if data.len() != checked_bytes(count, floats)? {
return Err(Error::InvalidLayout);
}
checked_bytes(count, stride)
}
fn filter_run(
kind: Kind,
out: &mut [u8],
stride: usize,
bits: u32,
data: &[f32],
) -> Result<(), Error> {
match kind {
Kind::Oct => filter_encode::oct(out, stride, bits, data),
Kind::Quat => filter_encode::quat(out, bits, data),
Kind::Color => filter_encode::color(out, stride, bits, data),
Kind::Exp(mode) => return filter_encode::exp(out, stride, bits, data, mode),
}
Ok(())
}
fn filter_into(
kind: Kind,
destination: &mut [u8],
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<(), Error> {
let mut work = workspace.begin();
let result = (|| {
let bytes = filter_layout(kind, count, stride, bits, data)?;
if destination.len() < bytes {
return Err(Error::BufferTooSmall);
}
workspace.account_codec(0)?;
work.add(data.len())?;
work.add(bytes / 4)?;
filter_run(kind, &mut destination[..bytes], stride, bits, data)
})();
workspace.finish(&work);
result
}
fn filter_vec(
kind: Kind,
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
let mut work = workspace.begin();
let check = (|| {
let bytes = filter_layout(kind, count, stride, bits, data)?;
workspace.account_codec(bytes)?;
work.add(data.len())?;
work.add(bytes / 4)?;
Ok(bytes)
})();
workspace.finish(&work);
let bytes = check?;
let mut out = Vec::new();
out.try_reserve_exact(bytes)
.map_err(|_| Error::AllocationFailed)?;
if out.capacity() != bytes {
workspace.account_codec(out.capacity())?;
}
out.resize(bytes, 0);
filter_run(kind, &mut out, stride, bits, data)?;
Ok(out)
}
pub fn encode_filter_oct(
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
filter_vec(Kind::Oct, count, stride, bits, data, workspace)
}
pub fn encode_filter_oct_into(
destination: &mut [u8],
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<(), Error> {
filter_into(Kind::Oct, destination, count, stride, bits, data, workspace)
}
pub fn encode_filter_quat(
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
filter_vec(Kind::Quat, count, stride, bits, data, workspace)
}
pub fn encode_filter_quat_into(
destination: &mut [u8],
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<(), Error> {
filter_into(
Kind::Quat,
destination,
count,
stride,
bits,
data,
workspace,
)
}
pub fn encode_filter_exp(
count: usize,
stride: usize,
bits: u32,
data: &[f32],
mode: ExpMode,
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
filter_vec(Kind::Exp(mode), count, stride, bits, data, workspace)
}
pub fn encode_filter_exp_into(
destination: &mut [u8],
count: usize,
stride: usize,
bits: u32,
data: &[f32],
mode: ExpMode,
workspace: &mut Workspace,
) -> Result<(), Error> {
filter_into(
Kind::Exp(mode),
destination,
count,
stride,
bits,
data,
workspace,
)
}
pub fn encode_filter_color(
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<Vec<u8>, Error> {
filter_vec(Kind::Color, count, stride, bits, data, workspace)
}
pub fn encode_filter_color_into(
destination: &mut [u8],
count: usize,
stride: usize,
bits: u32,
data: &[f32],
workspace: &mut Workspace,
) -> Result<(), Error> {
filter_into(
Kind::Color,
destination,
count,
stride,
bits,
data,
workspace,
)
}