3pp-mirror/penpot
1
0
Fork 0
mirror of https://github.com/penpot/penpot.git synced 2025-05-29 01:36:12 +02:00
Code Issues Projects Releases Packages Wiki Activity

♻️ Refactor raw gradient data into wasm module

Browse source
This commit is contained in:
Belén Albeza 2025-04-29 15:03:19 +02:00
parent 8e18a0880e
commit 875e019d4f
2 changed files with 157 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

164
render-wasm/src/shapes/fills.rs
View file

@ -3,118 +3,37 @@ use skia_safe::{self as skia, Rect};
use super::Color;
use crate::uuid::Uuid;
const MAX_GRADIENT_STOPS: usize = 16;
const BASE_GRADIENT_DATA_SIZE: usize = 28;
const RAW_GRADIENT_DATA_SIZE: usize =
BASE_GRADIENT_DATA_SIZE + RAW_STOP_DATA_SIZE * MAX_GRADIENT_STOPS;
#[derive(Debug)]
#[repr(C)]
pub struct RawGradientData {
start_x: f32,
start_y: f32,
end_x: f32,
end_y: f32,
opacity: f32,
width: f32,
stop_count: u8,
_padding: [u8; 3],
stops: [RawStopData; MAX_GRADIENT_STOPS],
}
impl From<[u8; RAW_GRADIENT_DATA_SIZE]> for RawGradientData {
fn from(bytes: [u8; RAW_GRADIENT_DATA_SIZE]) -> Self {
Self {
start_x: f32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
start_y: f32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]),
end_x: f32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]),
end_y: f32::from_le_bytes([bytes[12], bytes[13], bytes[14], bytes[15]]),
opacity: f32::from_le_bytes([bytes[16], bytes[17], bytes[18], bytes[19]]),
width: f32::from_le_bytes([bytes[20], bytes[21], bytes[22], bytes[23]]),
stop_count: bytes[24],
_padding: [0; 3],
// FIXME: 2025-04-22: use `array_chunks` once the next release is out
// and we update our devenv.
// See https://github.com/rust-lang/rust/issues/74985
stops: bytes[28..]
.chunks_exact(RAW_STOP_DATA_SIZE)
.map(|chunk| RawStopData::try_from(chunk).unwrap())
.collect::<Vec<_>>()
.try_into()
.unwrap(),
}
}
}
impl RawGradientData {
pub fn start(&self) -> (f32, f32) {
(self.start_x, self.start_y)
}
pub fn end(&self) -> (f32, f32) {
(self.end_x, self.end_y)
}
pub fn opacity(&self) -> f32 {
self.opacity
}
pub fn width(&self) -> f32 {
self.width
}
}
pub const RAW_STOP_DATA_SIZE: usize = 8;
#[derive(Debug)]
#[repr(C)]
pub struct RawStopData {
color: u32,
offset: f32,
}
impl RawStopData {
pub fn color(&self) -> skia::Color {
skia::Color::from(self.color)
}
pub fn offset(&self) -> f32 {
self.offset
}
}
impl From<[u8; RAW_STOP_DATA_SIZE]> for RawStopData {
fn from(bytes: [u8; RAW_STOP_DATA_SIZE]) -> Self {
Self {
color: u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]),
offset: f32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]),
}
}
}
// FIXME: We won't need this once we use `array_chunks`. See comment above.
impl TryFrom<&[u8]> for RawStopData {
type Error = String;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
let data: [u8; RAW_STOP_DATA_SIZE] = bytes
.try_into()
.map_err(|_| "Invalid stop data".to_string())?;
Ok(RawStopData::from(data))
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct Gradient {
colors: Vec<Color>,
offsets: Vec<f32>,
opacity: f32,
start: (f32, f32),
end: (f32, f32),
opacity: f32,
width: f32,
colors: Vec<Color>,
offsets: Vec<f32>,
}
impl Gradient {
pub fn new(
start: (f32, f32),
end: (f32, f32),
opacity: f32,
width: f32,
stops: &[(Color, f32)],
) -> Self {
let mut gradient = Gradient {
start,
end,
opacity,
colors: vec![],
offsets: vec![],
width,
};
gradient.add_stops(stops);
gradient
}
fn add_stops(&mut self, stops: &[(Color, f32)]) {
let colors = stops.iter().map(|(color, _)| *color);
let offsets = stops.iter().map(|(_, offset)| *offset);
@ -175,43 +94,6 @@ impl Gradient {
}
}
impl From<RawGradientData> for Gradient {
fn from(raw_gradient: RawGradientData) -> Self {
let stops = raw_gradient
.stops
.iter()
.take(raw_gradient.stop_count as usize)
.map(|stop| (stop.color(), stop.offset()))
.collect::<Vec<_>>();
let mut gradient = Gradient {
start: raw_gradient.start(),
end: raw_gradient.end(),
opacity: raw_gradient.opacity(),
colors: vec![],
offsets: vec![],
width: raw_gradient.width(),
};
gradient.add_stops(&stops);
gradient
}
}
impl TryFrom<&[u8]> for Gradient {
type Error = String;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
let raw_gradient_bytes: [u8; RAW_GRADIENT_DATA_SIZE] = bytes[0..RAW_GRADIENT_DATA_SIZE]
.try_into()
.map_err(|_| "Invalid gradient data".to_string())?;
let gradient = RawGradientData::from(raw_gradient_bytes).into();
Ok(gradient)
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct ImageFill {
id: Uuid,