use crate::{
colors::{self, blend, lerp, Color, ColorTable},
commands::{Command, Point, Rectangle, Style, Vector},
header::TvgHeader,
path::{Instruction, InstructionData, Path, Sweep},
TvgFile,
};
fn distance(p0: Point, p1: Point) -> f64 {
(p0 - p1).magnitude().abs()
}
fn rotation_matrix(angle: f64) -> [[f64; 2]; 2] {
let s = angle.sin();
let c = angle.cos();
[[c, -s], [s, c]]
}
fn apply_matrix(matrix: [[f64; 2]; 2], vector: Vector) -> Vector {
Vector {
x: vector.x * matrix[0][0] + vector.y * matrix[0][1],
y: vector.x * matrix[1][0] + vector.y * matrix[1][1],
}
}
fn apply_matrix_point(matrix: [[f64; 2]; 2], point: Point) -> Point {
Point {
x: point.x * matrix[0][0] + point.y * matrix[0][1],
y: point.x * matrix[1][0] + point.y * matrix[1][1],
}
}
fn lerp_f64(a: f64, b: f64, x: f64) -> f64 {
a + (b - a) * x
}
fn lerp_and_reduce(vals: &[f64], f: f64) -> Vec<f64> {
let mut result = Vec::with_capacity(vals.len() - 1);
for i in 0..(vals.len() - 1) {
result.push(lerp_f64(vals[i], vals[i + 1], f));
}
result
}
fn lerp_and_reduce_to_one(vals: &[f64], f: f64) -> f64 {
if vals.len() == 1 {
vals[0]
} else {
lerp_and_reduce_to_one(&lerp_and_reduce(vals, f), f)
}
}
/// A version of [`Point`] that uses usizes for a PixMap
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct UPoint {
x: usize,
y: usize,
}
impl UPoint {
fn new(x: usize, y: usize) -> UPoint {
Self { x, y }
}
}
struct FrameBuffer<C: Color> {
width: usize,
height: usize,
pixels: Box<[C]>,
scale_x: f64,
scale_y: f64,
}
impl<C: Color + Clone + Default> FrameBuffer<C> {
fn new(width: usize, height: usize, scale_x: f64, scale_y: f64) -> Self {
let pixel_count = width * height;
Self {
width,
height,
pixels: vec![C::default(); pixel_count].into_boxed_slice(),
scale_x,
scale_y,
}
}
fn point_to_upoint(&self, point: Point) -> UPoint {
todo!()
}
fn upoint_to_point(&self, upoint: UPoint) -> Point {
todo!()
}
/// Blends the new color with the given pixel. Returns `None` if the destination is invalid
fn set_pixel(&mut self, x: usize, y: usize, color: C) -> Option<()> {
if x >= self.width || y >= self.height {
return None;
}
let offset = y * self.width + x;
let destination_pixel = self.pixels.get_mut(offset)?;
blend(destination_pixel, &color);
Some(())
}
fn draw_line(
&mut self,
color_table: ColorTable<C>,
style: Style,
width_start: f64,
width_end: f64,
line_start: Point,
line_end: Point,
) -> Option<()> {
let mut min_x = usize::MAX;
let mut min_y = usize::MAX;
let mut max_x = usize::MIN;
let mut max_y = usize::MIN;
let max_width = f64::max(width_start, width_end);
let points = [line_start, line_end];
for pt in points {
min_x = usize::min(min_x, (self.scale_x * (pt.x - max_width)).floor() as usize);
min_y = usize::min(min_y, (self.scale_y * (pt.y - max_width)).floor() as usize);
max_x = usize::max(max_x, (self.scale_x * (pt.x - max_width)).floor() as usize);
max_y = usize::max(max_y, (self.scale_y * (pt.y - max_width)).floor() as usize);
}
// limit to framebuffer size
min_x = usize::min(min_x, self.width);
min_y = usize::min(min_y, self.height);
max_x = usize::min(max_x, self.width);
max_y = usize::min(max_y, self.height);
for y in min_y..=max_y {
for x in min_x..=max_x {
let point = self.upoint_to_point(UPoint { x, y });
let dist = todo!() as f64;
if dist >= 0.0 {
self.set_pixel(x, y, style.get_color_at(&color_table, point)?);
}
}
}
Some(())
}
}
#[derive(Debug, Default)]
struct PathMaker {
points: Vec<Point>,
width: Vec<f64>,
}
impl PathMaker {
fn new(width: f64, start: Point) -> Self {
let points = vec![start];
let width = vec![width];
Self { points, width }
}
fn render_line(&mut self, width: f64, to_point: Point) {
self.points.push(to_point);
self.width.push(width);
}
fn render_horizontal_line(&mut self, width: f64, x: f64) {
self.points.push(Point {
x,
y: self.points.last().unwrap().y,
});
self.width.push(width);
}
fn render_vertical_line(&mut self, width: f64, y: f64) {
self.points.push(Point {
x: self.points.last().unwrap().x,
y,
});
self.width.push(width);
}
fn render_cubic_bezier(
&mut self,
control_0: Point,
control_1: Point,
point: Point,
start_width: f64,
end_width: f64,
) {
const BEZIER_POLY_COUNT: usize = 16;
let previous = self.points.last().unwrap();
let oct0x = [previous.x, control_0.x, control_1.x, point.x];
let oct0y = [previous.y, control_0.y, control_1.y, point.y];
for i in 1..BEZIER_POLY_COUNT {
let f = i as f64 / BEZIER_POLY_COUNT as f64;
let x = lerp_and_reduce_to_one(&oct0x, f);
let y = lerp_and_reduce_to_one(&oct0y, f);
self.points.push(Point { x, y });
self.width.push(lerp_f64(start_width, end_width, f));
}
self.points.push(point);
self.width.push(end_width);
}
fn render_quadratic_bezier(
&mut self,
control: Point,
target: Point,
start_width: f64,
end_width: f64,
) {
const BEZIER_POLY_COUNT: usize = 16;
let previous = self.points.last().unwrap();
let oct0x = [previous.x, control.x, target.x];
let oct0y = [previous.y, control.y, target.y];
for i in 1..BEZIER_POLY_COUNT {
let f = i as f64 / BEZIER_POLY_COUNT as f64;
let x = lerp_and_reduce_to_one(&oct0x, f);
let y = lerp_and_reduce_to_one(&oct0y, f);
self.points.push(Point { x, y });
self.width.push(lerp_f64(start_width, end_width, f));
}
self.points.push(target);
self.width.push(end_width);
}
fn render_circle(
&mut self,
p0: Point,
p1: Point,
mut radius: f64,
large_arc: bool,
turn_left: bool,
end_width: f64,
) {
const CIRCLE_POLY_COUNT: usize = 100;
let start_width = *self.width.last().unwrap();
let left_side = turn_left == large_arc;
let delta = (p1 - p0).scale(0.5);
let midpoint = p0 + delta;
let radius_vec = if left_side {
Vector {
x: -delta.y,
y: delta.x,
}
} else {
Vector {
x: delta.y,
y: -delta.x,
}
};
let len_squared = radius_vec.x * radius_vec.x + radius_vec.y * radius_vec.y;
if (len_squared - 0.03 > radius * radius) || radius < 0.0 {
radius = len_squared.sqrt();
}
let to_center = radius_vec.scale(f64::max(0.0, radius * radius / len_squared - 1.0).sqrt());
let center = midpoint + to_center;
let angle = len_squared.sqrt().clamp(-1.0, 1.0).asin() * 2.0;
let arc = if large_arc {
std::f64::consts::TAU - angle
} else {
angle
};
let position = p0 - center;
for i in 0..CIRCLE_POLY_COUNT {
let arc = if turn_left { -arc } else { arc };
let step_matrix = rotation_matrix(i as f64 * arc / CIRCLE_POLY_COUNT as f64);
let point = center + apply_matrix(step_matrix, position);
self.points.push(point);
self.width.push(lerp_f64(
start_width,
end_width,
i as f64 / CIRCLE_POLY_COUNT as f64,
));
}
self.points.push(p1);
}
fn render_ellipse(
&mut self,
p0: Point,
p1: Point,
radius_x: f64,
radius_y: f64,
rotation: f64,
large_arc: bool,
turn_left: bool,
end_width: f64,
) {
let radius_min = distance(p0, p1) / 2.0;
let radius_max = (radius_x * radius_x + radius_y * radius_y).sqrt();
let upscale = if radius_max < radius_min {
radius_min / radius_max
} else {
1.0
};
let ratio = radius_x / radius_y;
let rotation = rotation_matrix(-rotation.to_radians());
let transform = [
[rotation[0][0] / upscale, rotation[0][1] / upscale],
[
rotation[1][0] / upscale * ratio,
rotation[1][1] / upscale * ratio,
],
];
let transform_back = [
[rotation[1][1] * upscale, -rotation[0][1] / ratio * upscale],
[-rotation[1][0] * upscale, rotation[0][0] / ratio * upscale],
];
let mut tmp = PathMaker::default();
tmp.render_circle(
apply_matrix_point(transform, p0),
apply_matrix_point(transform, p1),
radius_x * upscale,
large_arc,
turn_left,
end_width,
);
for i in 0..tmp.points.len() {
let point = tmp.points[i];
self.points.push(apply_matrix_point(transform_back, point));
self.width.push(tmp.width[i]);
}
}
fn close(&mut self, width: f64) {
self.points.push(self.points[0]);
self.width.push(width)
}
}
fn render_path(path: Path, width: f64) {
for segment in path.segments.iter() {
let mut path_maker = PathMaker::new(width, segment.start);
for instruction in segment.instructions.iter() {
let line_width = instruction
.line_width
.unwrap_or(*path_maker.width.last().unwrap());
let data = instruction.data;
match data {
InstructionData::Line { position } => path_maker.render_line(line_width, position),
InstructionData::HorizontalLine { x } => {
path_maker.render_horizontal_line(line_width, x)
}
InstructionData::VerticalLine { y } => {
path_maker.render_vertical_line(line_width, y)
}
InstructionData::CubicBezier {
control_0,
control_1,
point_1,
} => path_maker.render_cubic_bezier(
control_0,
control_1,
point_1,
*path_maker.width.last().unwrap(),
line_width,
),
InstructionData::ArcCircle {
large_arc,
sweep,
radius,
target,
} => path_maker.render_circle(
*path_maker.points.last().unwrap(),
target,
radius,
large_arc,
sweep == Sweep::Left,
line_width,
),
InstructionData::ArcEllipse {
large_arc,
sweep,
radius_x,
radius_y,
rotation,
target,
} => path_maker.render_ellipse(
*path_maker.points.last().unwrap(),
target,
radius_x,
radius_y,
rotation,
large_arc,
sweep == Sweep::Left,
line_width,
),
InstructionData::ClosePath => path_maker.close(line_width),
InstructionData::QuadraticBezier { control, target } => path_maker
.render_quadratic_bezier(
control,
target,
*path_maker.width.last().unwrap(),
line_width,
),
}
}
}
}
pub enum AntiAliasing {
X1 = 1,
X4 = 2,
X9 = 3,
X16 = 4,
X25 = 6,
X49 = 7,
X64 = 8,
}
pub fn render<C: Color + Clone + Default>(
file: &TvgFile<C>,
width: u32,
height: u32,
scale_x: f32,
scale_y: f32,
anti_alias: AntiAliasing,
) {
let mut framebuffer: FrameBuffer<C> = FrameBuffer::new(
width as usize,
height as usize,
scale_x.into(),
scale_y.into(),
);
let header = &file.header;
let color_table = &file.color_table;
for command in file.commands.iter() {
match command {
Command::EndOfDocument => break,
Command::FillPolygon {
fill_style,
polygon,
} => {
todo!()
}
Command::FillRectangles {
fill_style,
rectangles,
} => todo!(),
Command::FillPath { fill_style, path } => todo!(),
Command::DrawLines {
line_style,
line_width,
lines,
} => todo!(),
Command::DrawLineLoop {
line_style,
line_width,
points,
} => todo!(),
Command::DrawLineStrip {
line_style,
line_width,
points,
} => todo!(),
Command::DrawLinePath {
line_style,
line_width,
path,
} => todo!(),
Command::OutlineFillPolygon {
fill_style,
line_style,
line_width,
points,
} => todo!(),
Command::OutlineFillRectangles {
fill_style,
line_style,
line_width,
rectangles,
} => todo!(),
Command::OutlineFillPath {
fill_style,
line_style,
line_width,
path,
} => todo!(),
}
}
}
|
