use std::io::{self, Read};
use std::ops::{Add, Mul, Sub};
use byteorder::ReadBytesExt;
use raise::yeet;
use crate::{
colors::{self, Color, ColorTable},
header::TvgHeader,
path::Path,
read_unit, read_varuint, Decode, TvgError,
};
/// A X and Y coordinate pair.
#[derive(Debug, Clone, Copy)]
pub struct Vector {
/// Horizontal distance of the point to the origin.
pub x: f64,
/// Vertical distance of the point to the origin.
pub y: f64,
}
impl Vector {
pub fn magnitude(&self) -> f64 {
(self.x * self.x + self.y * self.y).sqrt()
}
pub fn scale(&self, scale: f64) -> Vector {
Vector {
x: self.x * scale,
y: self.y * scale,
}
}
}
impl Mul for Vector {
type Output = f64;
fn mul(self, rhs: Self) -> Self::Output {
self.x * rhs.x + self.y * rhs.y
}
}
/// A X and Y coordinate pair.
#[derive(Debug, Clone, Copy)]
pub struct Point {
/// Horizontal distance of the point to the origin.
pub x: f64,
/// Vertical distance of the point to the origin.
pub y: f64,
}
impl Sub for Point {
type Output = Vector;
fn sub(self, rhs: Self) -> Self::Output {
Vector {
x: self.x - rhs.x,
y: self.y - rhs.y,
}
}
}
impl Add<Vector> for Point {
type Output = Self;
fn add(self, vector: Vector) -> Self::Output {
Self {
x: self.x + vector.x,
y: self.y + vector.y,
}
}
}
impl Decode for Point {
fn read(reader: &mut impl Read, header: &TvgHeader) -> io::Result<Self> {
Ok(Self {
x: read_unit(reader, header)?,
y: read_unit(reader, header)?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Rectangle {
/// Horizontal distance of the left side to the origin.
pub x: f64,
/// Vertical distance of the upper side to the origin.
pub y: f64,
/// Horizontal extent of the rectangle.
pub width: f64,
/// Vertical extent of the rectangle.
pub height: f64,
}
impl Decode for Rectangle {
fn read(reader: &mut impl Read, header: &TvgHeader) -> io::Result<Self> {
let x = 5;
Ok(Self {
x: read_unit(reader, header)?,
y: read_unit(reader, header)?,
width: read_unit(reader, header)?,
height: read_unit(reader, header)?,
})
}
}
#[derive(Debug, Clone, Copy)]
pub struct Line {
/// Start point of the line.
start: Point,
/// End point of the line.
end: Point,
}
impl Decode for Line {
fn read(reader: &mut impl Read, header: &TvgHeader) -> io::Result<Self> {
Ok(Self {
start: Point::read(reader, header)?,
end: Point::read(reader, header)?,
})
}
}
/// A command that can be encoded.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
enum CommandName {
/// Determines end of file.
EndOfDocument = 0,
/// Fills an N-gon.
FillPolygon = 1,
/// Fills a set of [`Rectangle`]s.
FillRectangles = 2,
/// Fills a free-form [`Path`].
FillPath = 3,
/// Draws a set of lines.
DrawLines = 4,
/// Draws the outline of a polygon.
DrawLineLoop = 5,
/// Draws a list of end-to-end lines.
DrawLineStrip = 6,
/// Draws a free-form [`Path`].
DrawLinePath = 7,
/// Draws a filled polygon with an outline.
OutlineFillPolygon = 8,
/// Draws several filled [`Rectangle`]s with an outline.
OutlineFillRectangles = 9,
/// This command combines the [`FillPath`] and [`DrawLinePath`] command
/// into one.
OutlineFillPath = 10,
}
impl TryFrom<u8> for CommandName {
type Error = TvgError;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
0 => Ok(Self::EndOfDocument),
1 => Ok(Self::FillPolygon),
2 => Ok(Self::FillRectangles),
3 => Ok(Self::FillPath),
4 => Ok(Self::DrawLines),
5 => Ok(Self::DrawLineLoop),
6 => Ok(Self::DrawLineStrip),
7 => Ok(Self::DrawLinePath),
8 => Ok(Self::OutlineFillPolygon),
9 => Ok(Self::OutlineFillRectangles),
10 => Ok(Self::OutlineFillPath),
v => Err(TvgError::InvalidCommand(v)),
}
}
}
/// The type of style the command uses as a primary style.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum StyleKind {
/// The shape is uniformly colored with a single color.
FlatColored = 0,
/// The shape is colored with a linear gradient.
LinearGradient = 1,
/// The shape is colored with a radial gradient.
RadialGradient = 2,
}
impl TryFrom<u8> for StyleKind {
type Error = TvgError;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
0 => Ok(Self::FlatColored),
1 => Ok(Self::LinearGradient),
2 => Ok(Self::RadialGradient),
_ => Err(TvgError::InvalidStyleKind),
}
}
}
/// The style kind, along with the colors and points used to render the style.
#[derive(Debug, Clone, Copy)]
pub enum Style {
/// The shape is uniformly colored with the color at `color_index` in the
/// [`ColorTable`].
FlatColored {
/// The index in the [`ColorTable`].
color_index: u32,
},
/// The gradient is formed by a mental line between `point_0` and
/// `point_1`.
///
/// The color at `point_0` is the color at `color_index_0` in the color
/// table. The color at `point_1` is the color at `color_index_1` in the
/// [`ColorTable`]. On the line, the color is interpolated between the two
/// points. Each point that is not on the line is orthogonally projected to
/// the line and the color at that point is sampled. Points that are not
/// projectable onto the line have either the color at `point_0` if they
/// are closed to `point_0` or vice versa for `point_1`.
LinearGradient {
/// The start point of the gradient.
point_0: Point,
/// The end point of the gradient.
point_1: Point,
/// The color at [`point_0`].
color_index_0: u32,
/// The color at [`point_1`].
color_index_1: u32,
},
/// The gradient is formed by a mental circle with the center at `point_0`
/// and `point_1` being somewhere on the circle outline. Thus, the radius
/// of said circle is the distance between `point_0` and `point_1`.
///
/// The color at `point_0` is the color at `color_index_0` in the color
/// table. The color on the circle outline is the color at `color_index_1`
/// in the [`ColorTable`]. If a sampled point is inside the circle, the
/// color is interpolated based on the distance to the center and the
/// radius. If the point is not in the circle itself, the color at
/// `color_index_1` is always taken.
RadialGradient {
/// The center point of the mental circle.
point_0: Point,
/// The end point of the gradient.
point_1: Point,
/// The color at `point_0`.
color_index_0: u32,
/// The color at `point_1`.
color_index_1: u32,
},
}
impl Style {
fn read(reader: &mut impl Read, header: &TvgHeader, kind: StyleKind) -> io::Result<Self> {
match kind {
StyleKind::FlatColored => Self::read_flat_colored(reader),
StyleKind::LinearGradient => Self::read_linear_gradient(reader, header),
StyleKind::RadialGradient => Self::read_radial_gradient(reader, header),
}
}
fn read_flat_colored(reader: &mut impl Read) -> io::Result<Self> {
Ok(Self::FlatColored {
color_index: read_varuint(reader)?,
})
}
fn read_linear_gradient(reader: &mut impl Read, header: &TvgHeader) -> io::Result<Self> {
Ok(Self::LinearGradient {
point_0: Point::read(reader, header)?,
point_1: Point::read(reader, header)?,
color_index_0: read_varuint(reader)?,
color_index_1: read_varuint(reader)?,
})
}
fn read_radial_gradient(reader: &mut impl Read, header: &TvgHeader) -> io::Result<Self> {
Ok(Self::RadialGradient {
point_0: Point::read(reader, header)?,
point_1: Point::read(reader, header)?,
color_index_0: read_varuint(reader)?,
color_index_1: read_varuint(reader)?,
})
}
fn linear_get_color_at<C: Color + Clone>(
&self,
color_table: &ColorTable<C>,
point: Point,
) -> Option<C> {
let Self::LinearGradient {
point_0,
point_1,
color_index_0,
color_index_1 } = self else { panic!() };
// TODO remove these unwraps
let color_0 = color_table.get(*color_index_0 as usize)?;
let color_1 = color_table.get(*color_index_1 as usize)?;
let direction = *point_1 - *point_0;
let delta = point - *point_0;
if direction * delta <= 0.0 {
return Some(color_0.clone());
} else if direction * (point - *point_1) >= 0.0 {
return Some(color_1.clone());
}
let gradient_length = direction.magnitude();
let proj = (direction * delta) / (direction * direction);
let gradient_position = direction.scale(proj).magnitude();
let f = gradient_position / gradient_length;
Some(colors::lerp(color_0, color_1, f))
}
fn radial_get_color_at<C: Color>(
&self,
color_table: &ColorTable<C>,
point: Point,
) -> Option<C> {
let Self::RadialGradient {
point_0,
point_1,
color_index_0,
color_index_1 } = self else { panic!() };
// TODO remove these unwraps
let color_0 = color_table.get(*color_index_0 as usize)?;
let color_1 = color_table.get(*color_index_1 as usize)?;
let distance_max = (*point_1 - *point_0).magnitude();
let distance_is = (point - *point_0).magnitude();
let f = distance_is / distance_max;
Some(colors::lerp(color_0, color_1, f))
}
pub fn get_color_at<C: Color + Clone>(
&self,
color_table: &ColorTable<C>,
point: Point,
) -> Option<C> {
match self {
Self::FlatColored { color_index } => color_table.get(*color_index as usize).cloned(),
Self::LinearGradient { .. } => self.linear_get_color_at(color_table, point),
Self::RadialGradient { .. } => self.radial_get_color_at(color_table, point),
}
}
}
/// TinyVG files contain a sequence of draw commands that must be executed in
/// the defined order to get the final result. Each draw command adds a new 2D
/// primitive to the graphic.
#[derive(Debug, Clone)]
pub enum Command {
/// If this command is read, the TinyVG file has ended.
///
/// This command must have prim_style_kind to be set to 0, so the last byte
/// of every TinyVG file is `0x00`. Every byte after this command is
/// considered not part of the TinyVG data and can be used for other
/// purposes like metadata or similar.
EndOfDocument,
/// Fills a polygon with N [`Point`]s.
///
/// The number of points must be at least 3. Files that encode a lower
/// value must be discarded as ”invalid” by a conforming implementation.
///
/// The polygon specified in polygon must be drawn using the even-odd rule.
/// That means that if for any point to be inside the polygon, a line to
/// infinity must cross an odd number of polygon segments.
FillPolygon {
/// The style that is used to fill the polygon.
fill_style: Style,
/// The points of the polygon.
polygon: Box<[Point]>,
},
/// Fills a list of [`Rectangle`]s.
///
/// The rectangles must be drawn first to last, which is the order they
/// appear in the file.
FillRectangles {
/// The style that is used to fill all rectangles.
fill_style: Style,
/// The list of rectangles to be filled.
rectangles: Box<[Rectangle]>,
},
/// Fills a [`Path`].
///
/// For the filling, all path segments are considered a polygon each (drawn
/// with even-odd rule) that, when overlap, also perform the even odd rule.
/// This allows the user to carve out parts of the path and create
/// arbitrarily shaped surfaces.
FillPath {
/// The style that is used to fill the path.
fill_style: Style,
/// A [`Path`] with `segment_count` segments.
path: Path,
},
/// Draws a set of [`Line`]s.
///
/// Each line is `line_width` units wide, and at least a single display
/// pixel. This means that line_width of 0 is still visible, even though
/// only marginally. This allows very thin outlines.
DrawLines {
/// The style that is used to draw the all lines.
line_style: Style,
/// The width of the lines.
line_width: f64,
/// The list of lines.
lines: Box<[Line]>,
},
/// Draws a polygon.
///
/// Each line is `line_width` units wide. The lines are drawn between
/// consecutive points as well as the first and the last point.
DrawLineLoop {
/// The style that is used to draw the all lines.
line_style: Style,
/// The width of the line.
line_width: f64,
/// The points of the polygon.
points: Box<[Point]>,
},
/// Draws a list of consecutive lines.
///
/// The lines are drawn between consecutive points, but contrary to
/// [`DrawLineLoop`], the first and the last point are not connected.
DrawLineStrip {
/// The style that is used to draw the all rectangles.
line_style: Style,
/// The width of the line.
line_width: f64,
/// The points of the line strip.
points: Box<[Point]>,
},
/// Draws a [`Path`].
///
/// The outline of the path is `line_width` units wide.
DrawLinePath {
/// The style that is used to draw the path.
line_style: Style,
/// The width of the line.
line_width: f64,
/// A path with `segment_count` segments.
path: Path,
},
/// Fills a polygon and draws an outline at the same time.
///
/// This command is a combination of [`FillPolygon`] and [`DrawLineLoop`].
/// It first performs a [`FillPolygon`] with the `fill_style`, then
/// performs [`DrawLineLoop`] with `line_style` and `line_width`.
///
/// The outline commands use a reduced number of elements. The maximum
/// number of points is 64.
OutlineFillPolygon {
/// The style that is used to fill the polygon.
fill_style: Style,
/// The style that is used to draw the outline of the polygon.
line_style: Style,
/// The width of the line.
line_width: f64,
/// The set of points of this polygon.
points: Box<[Point]>,
},
/// Fills and outlines a list of [`Rectangle`]s.
///
/// For each rectangle, it is first filled, then its outline is drawn, then
/// the next rectangle is drawn.
///
/// The outline commands use a reduced number of elements, the maximum
/// number of points is 64.
OutlineFillRectangles {
/// The style that is used to fill the rectangles.
fill_style: Style,
/// The style that is used to draw the outline of the rectangles.
line_style: Style,
/// The width of the line.
line_width: f64,
/// The list of rectangles to be drawn.
rectangles: Box<[Rectangle]>,
},
/// Fills a path and draws an outline at the same time.
///
/// This command is a combination of [`FillPath`] and [`DrawLinePath`]. It
/// first performs a [`FillPath`] with the `fill_style`, then performs
/// [`DrawLinePath`] with `line_style` and `line_width`.
OutlineFillPath {
/// The style that is used to fill the path.
fill_style: Style,
/// The style that is used to draw the outline of the path.
line_style: Style,
/// The width of the line.
line_width: f64,
/// The path that should be drawn.
path: Path,
},
}
/// The header is different for outline commands, so we use this as a helper
struct OutlineHeader {
count: u32,
fill_style: Style,
line_style: Style,
line_width: f64,
}
impl OutlineHeader {
fn read(
reader: &mut impl Read,
header: &TvgHeader,
prim_style_kind: StyleKind,
) -> Result<Self, TvgError> {
// the count and secondary style kind are stores in the same byte
let byte = reader.read_u8()?;
let count = (byte & 0b0011_1111) as u32 + 1;
let sec_style_kind = StyleKind::try_from((byte & 0b1100_0000) >> 6)?;
let fill_style = Style::read(reader, header, prim_style_kind)?;
let line_style = Style::read(reader, header, sec_style_kind)?;
let line_width = read_unit(reader, header)?;
Ok(Self {
count,
fill_style,
line_style,
line_width,
})
}
}
impl Command {
pub fn read(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
// the command name and primary style kind are stores in the same byte
let byte = reader.read_u8()?;
let command = CommandName::try_from(byte & 0b0011_1111)?;
let style_kind = StyleKind::try_from((byte & 0b1100_0000) >> 6)?;
match command {
CommandName::EndOfDocument => Self::end_of_document(style_kind),
CommandName::FillPolygon => Self::read_fill_polygon(reader, header, style_kind),
CommandName::FillRectangles => Self::read_fill_rectangles(reader, header, style_kind),
CommandName::FillPath => Self::read_fill_path(reader, header, style_kind),
CommandName::DrawLines => Self::read_draw_lines(reader, header, style_kind),
CommandName::DrawLineLoop => Self::read_draw_line_loop(reader, header, style_kind),
CommandName::DrawLineStrip => Self::read_draw_line_strip(reader, header, style_kind),
CommandName::DrawLinePath => Self::read_draw_line_path(reader, header, style_kind),
CommandName::OutlineFillPolygon => {
Self::read_outline_fill_polygon(reader, header, style_kind)
}
CommandName::OutlineFillRectangles => {
Self::read_outline_fill_rectangles(reader, header, style_kind)
}
CommandName::OutlineFillPath => {
Self::read_outline_fill_path(reader, header, style_kind)
}
}
}
pub fn is_end_of_document(&self) -> bool {
matches!(self, Self::EndOfDocument)
}
fn read_command_header(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> io::Result<(u32, Style)> {
// every command adds one to the count
let count = read_varuint(reader)? + 1;
let style = Style::read(reader, header, style_kind)?;
Ok((count, style))
}
fn end_of_document(style_kind: StyleKind) -> Result<Self, TvgError> {
if style_kind != StyleKind::FlatColored {
Err(TvgError::InvalidEndOfDocument(style_kind as u8))
} else {
Ok(Self::EndOfDocument)
}
}
fn read_fill_polygon(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (point_count, fill_style) = Self::read_command_header(reader, header, style_kind)?;
if point_count < 3 {
yeet!(TvgError::InvalidPolygon(point_count));
}
let polygon = Point::read_multiple(reader, header, point_count)?;
Ok(Self::FillPolygon {
fill_style,
polygon,
})
}
fn read_fill_rectangles(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (rectangle_count, fill_style) = Self::read_command_header(reader, header, style_kind)?;
let rectangles = Rectangle::read_multiple(reader, header, rectangle_count)?;
Ok(Self::FillRectangles {
fill_style,
rectangles,
})
}
fn read_fill_path(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (segment_count, fill_style) = Self::read_command_header(reader, header, style_kind)?;
let path = Path::read(reader, header, segment_count)?;
Ok(Self::FillPath { fill_style, path })
}
fn read_draw_lines(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (line_count, line_style) = Self::read_command_header(reader, header, style_kind)?;
let line_width = read_unit(reader, header)?;
let lines = Line::read_multiple(reader, header, line_count)?;
Ok(Self::DrawLines {
line_style,
line_width,
lines,
})
}
fn read_draw_line_loop(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (point_count, line_style) = Self::read_command_header(reader, header, style_kind)?;
let line_width = read_unit(reader, header)?;
let points = Point::read_multiple(reader, header, point_count)?;
Ok(Self::DrawLineLoop {
line_style,
line_width,
points,
})
}
fn read_draw_line_strip(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (point_count, line_style) = Self::read_command_header(reader, header, style_kind)?;
let line_width = read_unit(reader, header)?;
let points = Point::read_multiple(reader, header, point_count)?;
Ok(Self::DrawLineStrip {
line_style,
line_width,
points,
})
}
fn read_draw_line_path(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let (segment_count, line_style) = Self::read_command_header(reader, header, style_kind)?;
let line_width = read_unit(reader, header)?;
let path = Path::read(reader, header, segment_count)?;
Ok(Self::DrawLinePath {
line_style,
line_width,
path,
})
}
fn read_outline_fill_polygon(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let OutlineHeader {
count: segment_count,
fill_style,
line_style,
line_width,
} = OutlineHeader::read(reader, header, style_kind)?;
let points = Point::read_multiple(reader, header, segment_count)?;
Ok(Self::OutlineFillPolygon {
fill_style,
line_style,
line_width,
points,
})
}
fn read_outline_fill_rectangles(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let OutlineHeader {
count: rect_count,
fill_style,
line_style,
line_width,
} = OutlineHeader::read(reader, header, style_kind)?;
let rectangles = Rectangle::read_multiple(reader, header, rect_count)?;
Ok(Self::OutlineFillRectangles {
fill_style,
line_style,
line_width,
rectangles,
})
}
fn read_outline_fill_path(
reader: &mut impl Read,
header: &TvgHeader,
style_kind: StyleKind,
) -> Result<Self, TvgError> {
let OutlineHeader {
count: segment_count,
fill_style,
line_style,
line_width,
} = OutlineHeader::read(reader, header, style_kind)?;
let path = Path::read(reader, header, segment_count)?;
Ok(Self::OutlineFillPath {
fill_style,
line_style,
line_width,
path,
})
}
}
|
