use std::io::Read;
use byteorder::ReadBytesExt;
use num_enum::TryFromPrimitive;
use raise::yeet;
use crate::{header::TvgHeader, read_unit, read_varuint, Decode, Point, TvgError};
/// Returns an error if the padding isn't zero
fn check_padding(padding: u8) -> Result<(), TvgError> {
if padding != 0 {
yeet!(TvgError::NonZeroPadding(padding))
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive)]
#[repr(u8)]
enum Sweep {
Right = 0,
Left = 1,
}
/// An instruction to move a hypothetical "pen".
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive)]
#[repr(u8)]
enum InstructionKind {
/// A straight line is drawn from the current point to a new point.
Line = 0,
/// A straight horizontal line is drawn from the current point to a new x
/// coordinate.
HorizontalLine = 1,
/// A straight vertical line is drawn from the current point to a new y
/// coordiante.
VerticalLine = 2,
/// A cubic Bézier curve is drawn from the current point to a new point.
CubicBezier = 3,
/// A circle segment is drawn from current point to a new point.
ArcCircle = 4,
/// An ellipse segment is drawn from current point to a new point.
ArcEllipse = 5,
/// The path is closed, and a straight line is drawn to the starting point.
ClosePath = 6,
/// A quadratic Bézier curve is drawn from the current point to a new point.
QuadraticBezier = 7,
}
#[derive(Debug, Clone, Copy)]
enum InstructionData {
/// The line instruction draws a straight line to the position.
Line {
/// The end point of the line.
position: Point,
},
/// The horizontal line instruction draws a straight horizontal line to a
/// given x coordinate.
HorizontalLine {
/// The new x coordinate.
x: f64,
},
/// The vertical line instruction draws a straight vertical line to a given
/// y coordinate.
VerticalLine {
/// The new y coordinate.
y: f64,
},
/// The cubic bezier instruction draws a Bézier curve with two control
/// points.
///
/// The curve is drawn between the current location and `point_1` with
/// `control_0` being the first control point and `control_1` being the
/// second one.
CubicBezier {
/// The first control point.
control_0: Point,
/// The second control point.
control_1: Point,
/// The end point of the Bézier curve.
point_1: Point,
},
/// Draws a circle segment between the current and the target point.
///
/// The `radius` field determines the radius of the circle. If the distance
/// between the current point and `target` is larger than `radius`, the
/// distance is used as the radius.
ArcCircle {
/// If `true`, the large portion of the circle segment is drawn.
large_arc: bool,
/// Determines if the circle segment is left- or right bending.
sweep: Sweep,
/// The radius of the circle.
radius: f64,
/// The end point of the circle segment.
target: Point,
},
/// Draws an ellipse segment between the current and the target point.
///
/// The `radius_x` and `radius_y` fields determine the both radii of the
/// ellipse. If the distance between the current point and target is not
/// enough to fit any ellipse segment between the two points, `radius_x`
/// and `radius_y` are scaled uniformly so that it fits exactly.
ArcEllipse {
/// If `true`, the large portion of the ellipse segment is drawn.
large_arc: bool,
/// Determines if the ellipse segment is left- or right bending.
sweep: Sweep,
/// The radius of the ellipse segment in the horizontal direction.
radius_x: f64,
/// The radius of the ellipse segment in the vertical direction.
radius_y: f64,
/// The rotation of the ellipse in mathematical negative direction, in
/// degrees.
rotation: f64,
/// The end point of the ellipse segment.
target: Point,
},
/// A straight line is drawn to the start location of the current segment.
/// This instruction doesn’t have additional data encoded.
ClosePath,
/// The quadratic bezier instruction draws a Bézier curve with a single
/// control point.
///
/// The curve is drawn between the current location and `point_1` with
/// control being the control point.
QuadraticBezier {
/// The control point.
control: Point,
/// The end point of the Bézier curve.
target: Point,
},
}
impl InstructionData {
fn read(
reader: &mut impl Read,
header: &TvgHeader,
kind: InstructionKind,
) -> Result<Self, TvgError> {
match kind {
InstructionKind::Line => Self::read_line(reader, header),
InstructionKind::HorizontalLine => Self::read_horizontal_line(reader, header),
InstructionKind::VerticalLine => Self::read_vertical_line(reader, header),
InstructionKind::CubicBezier => Self::read_cubic_bezier(reader, header),
InstructionKind::ArcCircle => Self::read_arc_circle(reader, header),
InstructionKind::ArcEllipse => Self::read_arc_ellipse(reader, header),
InstructionKind::ClosePath => Ok(Self::ClosePath),
InstructionKind::QuadraticBezier => Self::read_quadratic_bezier(reader, header),
}
}
fn read_line(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
Ok(Self::Line {
position: Point::read(reader, header)?,
})
}
fn read_horizontal_line(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
Ok(Self::HorizontalLine {
x: read_unit(reader, header)?,
})
}
fn read_vertical_line(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
Ok(Self::VerticalLine {
y: read_unit(reader, header)?,
})
}
fn read_cubic_bezier(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
Ok(Self::CubicBezier {
control_0: Point::read(reader, header)?,
control_1: Point::read(reader, header)?,
point_1: Point::read(reader, header)?,
})
}
fn read_arc_header(
reader: &mut impl Read,
header: &TvgHeader,
) -> Result<(bool, Sweep), TvgError> {
// large_arc and sweep are stored in the same byte
let byte = reader.read_u8()?;
let large_arc = (byte & 1) != 0;
let sweep = match byte & 2 {
0 => Sweep::Left,
_ => Sweep::Right,
};
check_padding((byte & 0b1111_1100) >> 2)?;
Ok((large_arc, sweep))
}
fn read_arc_circle(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
let (large_arc, sweep) = Self::read_arc_header(reader, header)?;
let radius = read_unit(reader, header)?;
let target = Point::read(reader, header)?;
Ok(Self::ArcCircle {
large_arc,
sweep,
radius,
target,
})
}
fn read_arc_ellipse(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
let (large_arc, sweep) = Self::read_arc_header(reader, header)?;
let radius_x = read_unit(reader, header)?;
let radius_y = read_unit(reader, header)?;
let rotation = read_unit(reader, header)?;
let target = Point::read(reader, header)?;
Ok(Self::ArcEllipse {
large_arc,
sweep,
radius_x,
radius_y,
rotation,
target,
})
}
fn read_quadratic_bezier(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
Ok(Self::QuadraticBezier {
control: Point::read(reader, header)?,
target: Point::read(reader, header)?,
})
}
}
#[derive(Debug, Clone)]
struct Instruction {
/// The width of the line the "pen" makes, if it makes one at all.
line_width: Option<f64>,
/// The arguments to the instruction.
data: InstructionData,
}
impl Instruction {
fn read(reader: &mut impl Read, header: &TvgHeader) -> Result<Self, TvgError> {
let byte = reader.read_u8()?;
let instruction_kind =
InstructionKind::try_from_primitive(byte & 0b0000_0111).expect("invalid instruction");
let has_line_width = (byte & 0b0001_0000) != 0;
check_padding((byte & 0b0000_1000) >> 3)?;
check_padding((byte & 0b1110_0000) >> 5)?;
let line_width = has_line_width
.then(|| read_unit(reader, header))
.transpose()?;
let data = InstructionData::read(reader, header, instruction_kind)?;
Ok(Self { line_width, data })
}
}
#[derive(Debug, Clone)]
struct Segment {
/// The starting point of the segment.
start: Point,
/// The list of instructions for tha segment.
instructions: Box<[Instruction]>,
}
impl Segment {
fn read(
reader: &mut impl Read,
header: &TvgHeader,
segment_length: u32,
) -> Result<Self, TvgError> {
let start = Point::read(reader, header)?;
let mut instructions = Vec::with_capacity(segment_length as usize);
for _ in 0..segment_length {
instructions.push(Instruction::read(reader, header)?)
}
Ok(Segment {
start,
instructions: instructions.into_boxed_slice(),
})
}
}
/// Paths describe instructions to create complex 2D graphics.
///
/// Each path segment generates a shape by moving a ”pen” around. The path this
/// ”pen” takes is the outline of our segment. Each segment, the ”pen” starts
/// at a defined position and is moved by instructions. Each instruction will
/// leave the ”pen” at a new position. The line drawn by our ”pen” is the
/// outline of the shape.
#[derive(Debug, Clone)]
pub struct Path {
segments: Box<[Segment]>,
}
impl Path {
pub(crate) fn read(
reader: &mut impl Read,
header: &TvgHeader,
segment_count: u32,
) -> Result<Self, TvgError> {
let mut segment_lengths = Vec::with_capacity(segment_count as usize);
for _ in 0..segment_count {
segment_lengths.push(read_varuint(reader)? + 1);
}
let mut segments = Vec::with_capacity(segment_count as usize);
for segment_length in segment_lengths {
segments.push(Segment::read(reader, header, segment_length)?);
}
Ok(Self {
segments: segments.into_boxed_slice(),
})
}
}
|
