mod bitmap;
mod condition;
mod draw;
mod filter;
mod glyph;
mod mono;
mod tex;
mod text;
use std::cell::RefCell;
use std::fmt;
use std::rc::Rc;
use pltrs_codec::png::{self, EncodeError, ImageRef};
use pltrs_core::Path;
use pltrs_core::path::convert::SimplifySettings;
use pltrs_raster::{Mask, Painter, Pixmap, RasterError, Rgba8};
use crate::gc::ClipPath;
use crate::image::RgbaImage;
use crate::vector::PngMetadata;
pub use self::bitmap::{GlyphBitmap, GlyphShape, glyph_axis_aligned, render_glyph};
pltrs_core::thread_state! {
static TEXTS_AS_PATHS: RefCell<Option<Rc<dyn Fn() -> bool>>> = const { RefCell::new(None) };
}
pub fn set_texts_as_paths(rule: Option<Rc<dyn Fn() -> bool>>) {
TEXTS_AS_PATHS.set(rule);
}
fn texts_as_paths() -> bool {
TEXTS_AS_PATHS
.with_borrow(Clone::clone)
.is_some_and(|rule| rule())
}
#[derive(Debug)]
pub enum RasterBackendError {
Canvas(RasterError),
Dpi(f64),
Encode(EncodeError),
}
impl fmt::Display for RasterBackendError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Canvas(err) => write!(f, "invalid canvas: {err}"),
Self::Dpi(dpi) => write!(f, "dpi must be positive, got {dpi}"),
Self::Encode(err) => write!(f, "PNG encoding failed: {err}"),
}
}
}
impl std::error::Error for RasterBackendError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Canvas(err) => Some(err),
Self::Encode(err) => Some(err),
Self::Dpi(_) => None,
}
}
}
#[derive(Debug)]
struct CachedClip {
key: ClipPath,
mask: Mask,
}
#[derive(Debug)]
pub struct RasterRenderer {
pixmap: Pixmap,
painter: Painter,
size: (f64, f64),
dpi: f64,
simplify: SimplifySettings,
chunksize: usize,
clip_cache: Option<CachedClip>,
conditioned: Path,
flattened: Path,
set_aside: Vec<Option<Pixmap>>,
errors: Vec<RasterError>,
}
impl RasterRenderer {
pub fn new(width: f64, height: f64, dpi: f64) -> Result<Self, RasterBackendError> {
if !(dpi.is_finite() && dpi > 0.0) {
return Err(RasterBackendError::Dpi(dpi));
}
let pixmap = Pixmap::filled(width as u32, height as u32, Rgba8::TRANSPARENT_WHITE)
.map_err(RasterBackendError::Canvas)?;
Ok(Self {
pixmap,
painter: Painter::new(),
size: (width, height),
dpi,
simplify: SimplifySettings::default(),
chunksize: 0,
clip_cache: None,
conditioned: Path::default(),
flattened: Path::default(),
set_aside: Vec::new(),
errors: Vec::new(),
})
}
#[must_use]
pub fn with_simplify(mut self, settings: SimplifySettings) -> Self {
self.simplify = settings;
self
}
#[must_use]
pub fn with_path_chunksize(mut self, chunksize: usize) -> Self {
self.chunksize = chunksize;
self
}
pub fn pixmap(&self) -> &Pixmap {
&self.pixmap
}
pub fn pixmap_mut(&mut self) -> &mut Pixmap {
&mut self.pixmap
}
pub fn into_pixmap(self) -> Pixmap {
self.pixmap
}
pub fn to_image(&self) -> RgbaImage {
filter::image_of(self.pixmap.clone())
}
pub fn into_image(self) -> RgbaImage {
filter::image_of(self.pixmap)
}
pub fn to_png(&self) -> Result<Vec<u8>, RasterBackendError> {
self.to_png_with(&PngMetadata::none())
}
pub fn to_png_with(&self, metadata: &PngMetadata) -> Result<Vec<u8>, RasterBackendError> {
let image = ImageRef::rgba8(
self.pixmap.width(),
self.pixmap.height(),
self.pixmap.data(),
)
.map_err(RasterBackendError::Encode)?;
metadata
.apply_to(png::Encoder::new().dpi(self.dpi))
.encode(image)
.map_err(RasterBackendError::Encode)
}
pub fn clear(&mut self) {
self.pixmap.fill(Rgba8::TRANSPARENT_WHITE);
}
pub fn take_errors(&mut self) -> Vec<RasterError> {
std::mem::take(&mut self.errors)
}
fn record(&mut self, result: Result<(), RasterError>) {
if let Err(err) = result {
self.errors.push(err);
}
}
fn width(&self) -> u32 {
self.pixmap.width()
}
fn height(&self) -> u32 {
self.pixmap.height()
}
}
#[cfg(test)]
mod tests;