Delete stuff

1 files changed, 0 insertions, 506 deletions

diff --git a/tvg/src/render.rs b/tvg/src/render.rs
deleted file mode 100644
index f8c15a1..0000000
--- a/tvg/src/render.rs
+++ /dev/null
@@ -1,506 +0,0 @@
-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!(),
-		}
-	}
-}