pub mod affine;
mod canvas;
mod exact;
pub mod fields;
pub mod helpers;
mod raster;
mod render;
use std::sync::Arc;
use unityrs_core::limits::{ChargeError, Meter};
use unityrs_meshdecode::{MeshError, Processed};
use crate::contain::Payload;
use crate::decode::{DecodeError, Image};
pub use canvas::Sheet;
pub use fields::{
AtlasKey, Guid, Pptr, RenderData, SpriteFields, atlas_render_data, select_render_data,
};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SpriteData {
pub texture_rect: [f64; 4],
pub settings_raw: u64,
pub pixels_to_units: f64,
}
const _: () = crate::send_sync::<SpriteData>();
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PackingMode {
Tight,
Rectangle,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Rotation {
None,
FlipHorizontal,
FlipVertical,
Rotate180,
Rotate90,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Settings {
pub packed: bool,
pub packing_mode: PackingMode,
pub packing_rotation: Rotation,
pub mesh_type: u8,
}
const _: () = crate::send_sync::<Settings>();
const _: () = crate::send_sync::<PackingMode>();
const _: () = crate::send_sync::<Rotation>();
impl Settings {
pub fn parse(raw: u64) -> Result<Self, SpriteError> {
let packing_mode = if (raw >> 1) & 1 == 0 {
PackingMode::Tight
} else {
PackingMode::Rectangle
};
let rotation = (raw >> 2) & 0xF;
let packing_rotation = match rotation {
0 => Rotation::None,
1 => Rotation::FlipHorizontal,
2 => Rotation::FlipVertical,
3 => Rotation::Rotate180,
4 => Rotation::Rotate90,
other => return Err(SpriteError::Rotation(other)),
};
Ok(Self {
packed: raw & 1 == 1,
packing_mode,
packing_rotation,
mesh_type: u8::from((raw >> 6) & 1 == 1),
})
}
}
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum SpriteError {
#[error("Coordinate 'right' is less than 'left'")]
CropRightLeft,
#[error("Coordinate 'lower' is less than 'upper'")]
CropLowerUpper,
#[error("cannot convert float NaN to integer")]
RoundNan,
#[error("cannot convert float infinity to integer")]
RoundInfinity,
#[error(
"Image size ({pixels} pixels) exceeds limit of 178956970 pixels, could be decompression bomb DOS attack."
)]
DecompressionBomb {
pixels: String,
},
#[error("signed integer is {}", if *above { "greater than maximum" } else { "less than minimum" })]
CIntOverflow {
above: bool,
},
#[error("Python int too large to convert to C long")]
CLongOverflow,
#[error("Pillow refuses an image wider than 536870910 pixels")]
ImageTooWide,
#[error(
"Cannot cast ufunc 'solve1' input 1 from dtype('O') to dtype('float64') with casting rule 'same_kind'"
)]
SolveCast,
#[error("{0} is not a valid SpritePackingRotation")]
Rotation(u64),
#[error("size mismatch")]
AlphaSizeMismatch,
#[error("wrong number of bands")]
AlphaBandCount,
#[error("the sprite renderer is not verified on a sheet of mode {mode}")]
UnverifiedMode {
mode: &'static str,
},
#[error("No vertices found in sprite mesh!")]
NoVertices,
#[error("{}", unpack_message(*expected, *got))]
Unpack {
expected: usize,
got: Option<usize>,
},
#[error("{} index out of range", if *tuple { "tuple" } else { "list" })]
Index {
tuple: bool,
},
#[error("Can't process 3d sprites!")]
Sprite3d,
#[error("No triangles found in mesh!")]
NoTriangles,
#[error("No UV coordinates found in sprite mesh!")]
NoUv,
#[error("Width and height must be >= 0")]
NegativeSize,
#[error("the atlas has no render data for the sprite's m_RenderDataKey")]
NoAtlasData,
#[error("the sprite's m_SpriteAtlas does not resolve")]
AtlasUnresolved,
#[error("the sprite's {0} is missing or of another type")]
Malformed(&'static str),
#[error(transparent)]
Mesh(#[from] MeshError),
#[error("the sprite's {what} is past the renderer's bound")]
TooLarge {
what: &'static str,
},
#[error(transparent)]
Charge(#[from] ChargeError),
#[error("the sprite's render panicked: {}", .0.message())]
Panicked(Payload),
}
const _: () = crate::send_sync::<SpriteError>();
fn unpack_message(expected: usize, got: Option<usize>) -> String {
match got {
Some(n) => format!("not enough values to unpack (expected {expected}, got {n})"),
None => format!("too many values to unpack (expected {expected})"),
}
}
impl SpriteError {
#[must_use]
pub fn python(&self) -> Option<(&'static str, String)> {
let class = match self {
Self::CropRightLeft
| Self::CropLowerUpper
| Self::RoundNan
| Self::Rotation(_)
| Self::Unpack { .. }
| Self::Sprite3d
| Self::NoTriangles
| Self::NoUv
| Self::NegativeSize
| Self::AlphaSizeMismatch
| Self::AlphaBandCount => "ValueError",
Self::RoundInfinity | Self::CIntOverflow { .. } | Self::CLongOverflow => {
"OverflowError"
}
Self::DecompressionBomb { .. } => "DecompressionBombError",
Self::NoVertices => "AssertionError",
Self::Index { .. } => "IndexError",
Self::SolveCast => "UFuncTypeError",
Self::ImageTooWide => return Some(("MemoryError", String::new())),
Self::NoAtlasData => return Some(("StopIteration", String::new())),
Self::Mesh(e) => return e.python(),
Self::Malformed(_)
| Self::UnverifiedMode { .. }
| Self::AtlasUnresolved
| Self::TooLarge { .. }
| Self::Charge(_)
| Self::Panicked(_) => {
return None;
}
};
Some((class, self.to_string()))
}
}
impl From<DecodeError> for SpriteError {
fn from(e: DecodeError) -> Self {
match e {
DecodeError::Panicked { payload } => Self::Panicked(payload),
DecodeError::Charge(c) => Self::Charge(c),
_ => Self::Malformed("decode"),
}
}
}
pub fn render<'p>(
sheet: &Sheet<'_>,
data: &SpriteData,
mesh: impl FnOnce() -> Result<Processed<'p>, MeshError>,
meter: &Arc<Meter>,
) -> Result<Image, SpriteError> {
render::render(sheet, data, mesh, meter)
}
pub(crate) fn contained<T>(f: impl FnOnce() -> T) -> Result<T, SpriteError> {
crate::contain(std::panic::AssertUnwindSafe(|| Ok(f()))).map_err(SpriteError::from)
}