use std::rc::Rc;
use super::geometry::{PaintPoint, PaintRect, PaintSize, PaintTransform, PaintTranslation};
use super::images::{InlineRasterImage, RasterSampling, RenderedImageSource};
use super::paths::{RenderedGradient, RenderedPath, RenderedPathClip, RenderedPathClipPath};
use crate::image_store::ImageId;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PaintPatternTiling {
pub tile_size: PaintSize,
pub step: PaintSize,
pub origin: PaintPoint,
}
impl PaintPatternTiling {
pub fn new(tile_size: PaintSize, step: PaintSize, origin: PaintPoint) -> Self {
Self {
tile_size,
step,
origin,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct RenderedImagePattern {
pub background: bool,
pub(crate) source: RenderedImageSource,
pub(in crate::document) rect: PaintRect,
pub tiling: PaintPatternTiling,
pub(crate) sampling: RasterSampling,
clip: Option<RenderedPathClip>,
transform: PaintTransform,
}
#[allow(dead_code)]
impl RenderedImagePattern {
pub(crate) fn single_tile_from_image(image: super::images::RenderedImage) -> Self {
let rect = image.rect;
Self {
background: image.background,
source: image.source,
rect,
tiling: PaintPatternTiling::new(rect.size, rect.size, rect.origin),
sampling: image.sampling,
clip: None,
transform: image.transform.unwrap_or_else(PaintTransform::identity),
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn from_paint_rect(
rect: PaintRect,
background: bool,
tiling: PaintPatternTiling,
pixel_width: u32,
pixel_height: u32,
sampling: impl Into<RasterSampling>,
rgb: Rc<[u8]>,
alpha: Option<Rc<[u8]>>,
) -> Self {
Self {
background,
source: RenderedImageSource::Inline {
raster: InlineRasterImage {
pixel_width,
pixel_height,
natural_size: crate::units::CssPixelSize::new(pixel_width, pixel_height),
color_space: crate::color::RasterColorSpace::SRGB,
sample_depth: crate::image_store::RasterSampleDepth::Eight,
rgb,
alpha,
},
source_rect: None,
},
rect,
tiling,
sampling: sampling.into(),
clip: None,
transform: PaintTransform::identity(),
}
}
pub fn x(&self) -> f32 {
self.rect.origin.x
}
pub fn y(&self) -> f32 {
self.rect.origin.y
}
pub fn width(&self) -> f32 {
self.rect.size.width
}
pub fn height(&self) -> f32 {
self.rect.size.height
}
pub(crate) fn paint_rect(&self) -> PaintRect {
self.rect
}
pub(crate) fn with_clip(mut self, clip: RenderedPathClip) -> Self {
self.clip = Some(clip);
self
}
pub(crate) fn with_intersected_clip(mut self, clip: RenderedPathClip) -> Self {
if let Some(existing) = &mut self.clip {
existing
.additional_clips
.push(RenderedPathClipPath::new(clip.commands, clip.fill_rule));
existing.additional_clips.extend(clip.additional_clips);
} else {
self.clip = Some(clip);
}
self
}
pub(crate) fn with_source_rect(mut self, source_rect: Option<RenderedImageSourceRect>) -> Self {
if let RenderedImageSource::Inline {
source_rect: current,
..
} = &mut self.source
{
*current = source_rect;
}
self
}
pub(crate) fn clip(&self) -> Option<&RenderedPathClip> {
self.clip.as_ref()
}
pub(crate) fn transform(&self) -> PaintTransform {
self.transform
}
pub(crate) fn with_image_id(mut self, image_id: Option<ImageId>) -> Self {
if let Some(image_id) = image_id {
let RenderedImageSource::Inline { raster, .. } = &self.source else {
return self;
};
self.source = RenderedImageSource::Stored {
image_id,
source_rect: RenderedImageSourceRect {
x: 0,
y: 0,
width: raster.pixel_width,
height: raster.pixel_height,
},
pixel_width: raster.pixel_width,
pixel_height: raster.pixel_height,
};
}
self
}
pub(crate) fn with_raster_color_space(
mut self,
color_space: crate::color::RasterColorSpace,
) -> Self {
if let RenderedImageSource::Inline { raster, .. } = &mut self.source {
raster.color_space = color_space;
}
self
}
pub(crate) fn with_raster_sample_depth(
mut self,
sample_depth: crate::image_store::RasterSampleDepth,
) -> Self {
if let RenderedImageSource::Inline { raster, .. } = &mut self.source {
raster.sample_depth = sample_depth;
}
self
}
pub(in crate::document) fn translated(mut self, offset: PaintTranslation) -> Self {
self.rect = offset.transform_rect(&self.rect);
self.tiling.origin = offset.transform_point(self.tiling.origin);
if let Some(clip) = &mut self.clip {
for command in &mut clip.commands {
command.translate(offset);
}
for nested_clip in &mut clip.additional_clips {
for command in &mut nested_clip.commands {
command.translate(offset);
}
}
}
self
}
pub(in crate::document) fn translated_geometry_preserving_tile_origin(
mut self,
offset: PaintTranslation,
) -> Self {
self.rect = offset.transform_rect(&self.rect);
translate_pattern_clip(&mut self.clip, offset);
self
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct RenderedGradientPattern {
pub(crate) rect: PaintRect,
pub(crate) tiling: PaintPatternTiling,
pub(crate) gradient: RenderedGradient,
clip: Option<RenderedPathClip>,
transform: PaintTransform,
}
#[allow(dead_code)]
impl RenderedGradientPattern {
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
rect: PaintRect,
tiling: PaintPatternTiling,
gradient: RenderedGradient,
clip: Option<RenderedPathClip>,
) -> Self {
Self {
rect,
tiling,
gradient,
clip,
transform: PaintTransform::identity(),
}
}
pub(crate) fn paint_rect(&self) -> PaintRect {
self.rect
}
pub(crate) fn paint_bounds(&self) -> PaintRect {
self.transform
.apply_clip_to_aabb(super::geometry::PaintClip::from_paint_rect(self.rect))
.paint_rect()
}
pub(crate) fn transform(&self) -> PaintTransform {
self.transform
}
#[cfg(test)]
pub(crate) fn transformed(mut self, transform: PaintTransform) -> Self {
self.transform = transform.multiply(self.transform);
self
}
pub fn x(&self) -> f32 {
self.rect.origin.x
}
pub fn y(&self) -> f32 {
self.rect.origin.y
}
pub fn width(&self) -> f32 {
self.rect.size.width
}
pub fn height(&self) -> f32 {
self.rect.size.height
}
pub(crate) fn clip(&self) -> Option<&RenderedPathClip> {
self.clip.as_ref()
}
pub(crate) fn with_intersected_clip(mut self, clip: RenderedPathClip) -> Self {
if let Some(existing) = &mut self.clip {
existing
.additional_clips
.push(RenderedPathClipPath::new(clip.commands, clip.fill_rule));
existing.additional_clips.extend(clip.additional_clips);
} else {
self.clip = Some(clip);
}
self
}
pub(in crate::document) fn translated(mut self, offset: PaintTranslation) -> Self {
if self.transform != PaintTransform::identity() {
self.transform = PaintTransform::translate(offset).multiply(self.transform);
return self;
}
self.rect = offset.transform_rect(&self.rect);
self.tiling.origin = offset.transform_point(self.tiling.origin);
self.gradient.transform =
PaintTransform::translate(offset).multiply(self.gradient.transform);
if let Some(clip) = &mut self.clip {
for command in &mut clip.commands {
command.translate(offset);
}
for nested in &mut clip.additional_clips {
for command in &mut nested.commands {
command.translate(offset);
}
}
}
self
}
pub(in crate::document) fn translated_geometry_preserving_tile_origin(
mut self,
offset: PaintTranslation,
) -> Self {
self.rect = offset.transform_rect(&self.rect);
translate_pattern_clip(&mut self.clip, offset);
self
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct RenderedSvgPattern {
pub(crate) rect: PaintRect,
pub(crate) tiling: PaintPatternTiling,
pub(crate) paths: Vec<RenderedPath>,
clip: Option<RenderedPathClip>,
transform: PaintTransform,
}
impl RenderedSvgPattern {
#[allow(clippy::too_many_arguments)]
pub(crate) fn new(
rect: PaintRect,
tiling: PaintPatternTiling,
paths: Vec<RenderedPath>,
clip: Option<RenderedPathClip>,
) -> Self {
Self {
rect,
tiling,
paths,
clip,
transform: PaintTransform::identity(),
}
}
pub(crate) fn paint_rect(&self) -> PaintRect {
self.rect
}
pub(crate) fn clip(&self) -> Option<&RenderedPathClip> {
self.clip.as_ref()
}
pub(crate) fn with_intersected_clip(mut self, clip: RenderedPathClip) -> Self {
if let Some(existing) = &mut self.clip {
existing
.additional_clips
.push(RenderedPathClipPath::new(clip.commands, clip.fill_rule));
existing.additional_clips.extend(clip.additional_clips);
} else {
self.clip = Some(clip);
}
self
}
pub(crate) fn transform(&self) -> PaintTransform {
self.transform
}
pub(in crate::document) fn translated(mut self, offset: PaintTranslation) -> Self {
self.rect = offset.transform_rect(&self.rect);
self.tiling.origin = offset.transform_point(self.tiling.origin);
if let Some(clip) = &mut self.clip {
for command in &mut clip.commands {
command.translate(offset);
}
for nested in &mut clip.additional_clips {
for command in &mut nested.commands {
command.translate(offset);
}
}
}
self
}
pub(in crate::document) fn translated_geometry_preserving_tile_origin(
mut self,
offset: PaintTranslation,
) -> Self {
self.rect = offset.transform_rect(&self.rect);
translate_pattern_clip(&mut self.clip, offset);
self
}
}
fn translate_pattern_clip(clip: &mut Option<RenderedPathClip>, offset: PaintTranslation) {
if let Some(clip) = clip {
for command in &mut clip.commands {
command.translate(offset);
}
for nested_clip in &mut clip.additional_clips {
for command in &mut nested_clip.commands {
command.translate(offset);
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RenderedImageSourceRect {
pub x: u32,
pub y: u32,
pub width: u32,
pub height: u32,
}
impl RenderedImageSourceRect {
pub fn x(&self) -> u32 {
self.x
}
pub fn y(&self) -> u32 {
self.y
}
pub fn width(&self) -> u32 {
self.width
}
pub fn height(&self) -> u32 {
self.height
}
}