use super::{
CameraUniform, Vec2, Vertex, exact_markers, logical_stroke_branches_are_stable, range_abs,
range_dot, range_negate, range_vector_add, range_vector_scale, rounded_f32_add_range,
rounded_f32_division_range, rounded_f32_product_range, shader_direction_dot_range,
stroke_safe_unit_range, tessellated_vertex_base_screen_ranges,
};
type Ranges = [(f64, f64); 2];
type ScreenProof = (Ranges, bool);
#[derive(Clone, Copy, PartialEq, Eq)]
struct VertexKey([u32; 16]);
impl VertexKey {
fn new(vertex: Vertex) -> Self {
Self(
[
vertex.world_position[0],
vertex.world_position[1],
vertex.world_offset[0],
vertex.world_offset[1],
vertex.screen_offset[0],
vertex.screen_offset[1],
vertex.depth,
vertex.previous_direction[0],
vertex.previous_direction[1],
vertex.next_direction[0],
vertex.next_direction[1],
vertex.normal_distance,
vertex.tangent_distance,
vertex.miter_limit,
vertex.stroke_role,
vertex.stroke_parameter,
]
.map(f32::to_bits),
)
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
struct DirectionKey([u32; 4]);
impl DirectionKey {
fn new(vertex: Vertex) -> Self {
Self(
[
vertex.previous_direction[0],
vertex.previous_direction[1],
vertex.next_direction[0],
vertex.next_direction[1],
]
.map(f32::to_bits),
)
}
}
#[derive(Clone, Copy)]
struct DirectionProof {
next_tangent: Ranges,
previous_normal: Ranges,
next_normal: Ranges,
turn_sign: f32,
miter: Option<(Ranges, (f64, f64))>,
}
impl DirectionProof {
fn new(vertex: Vertex, uniform: CameraUniform) -> Option<Self> {
let previous_source = Vec2::new(vertex.previous_direction[0], vertex.previous_direction[1]);
let next_source = Vec2::new(vertex.next_direction[0], vertex.next_direction[1]);
let previous_projected = [
shader_direction_dot_range(
uniform.world_to_screen_x,
previous_source,
previous_source,
)?,
shader_direction_dot_range(
uniform.world_to_screen_y,
previous_source,
previous_source,
)?,
];
let next_projected = if vertex.previous_direction == vertex.next_direction {
previous_projected
} else {
[
shader_direction_dot_range(uniform.world_to_screen_x, next_source, next_source)?,
shader_direction_dot_range(uniform.world_to_screen_y, next_source, next_source)?,
]
};
let previous_tangent = stroke_safe_unit_range(previous_projected)?;
let next_tangent = if vertex.previous_direction == vertex.next_direction {
previous_tangent
} else {
stroke_safe_unit_range(next_projected)?
};
let previous_normal = [range_negate(previous_tangent[1]), previous_tangent[0]];
let next_normal = [range_negate(next_tangent[1]), next_tangent[0]];
let turn = if vertex.previous_direction == vertex.next_direction {
(0.0, 0.0)
} else {
rounded_f32_add_range(
rounded_f32_product_range(previous_tangent[0], next_tangent[1])?,
rounded_f32_product_range(previous_tangent[1], next_tangent[0])?,
true,
)?
};
let turn_sign = if turn.0 > 0.0 {
1.0
} else if turn.1 < 0.0 {
-1.0
} else if vertex.previous_direction == vertex.next_direction {
0.0
} else {
return None;
};
let combined_normal = [
rounded_f32_add_range(previous_normal[0], next_normal[0], false)?,
rounded_f32_add_range(previous_normal[1], next_normal[1], false)?,
];
let miter = stroke_safe_unit_range(combined_normal);
let miter = miter.and_then(|miter| {
let denominator = range_dot(miter, next_normal)?;
if denominator.0 <= 0.001 && denominator.1 >= -0.001 {
return None;
}
let reciprocal = rounded_f32_division_range((1.0, 1.0), denominator)?;
Some((miter, reciprocal))
});
Some(Self {
next_tangent,
previous_normal,
next_normal,
turn_sign,
miter,
})
}
fn screen(self, vertex: Vertex, base: Ranges) -> Option<ScreenProof> {
let Self {
next_tangent,
previous_normal,
next_normal,
turn_sign,
miter,
} = self;
let miter_state = miter.and_then(|(miter, reciprocal)| {
let multiple = range_abs(reciprocal);
let limit = f64::from(vertex.miter_limit);
let within_limit = if multiple.1 <= limit {
true
} else if multiple.0 > limit {
false
} else {
return None;
};
let scalar = rounded_f32_product_range(
reciprocal,
(
f64::from(vertex.normal_distance),
f64::from(vertex.normal_distance),
),
)?;
Some((range_vector_scale(miter, scalar)?, within_limit))
});
let normal_scalar = (
f64::from(vertex.normal_distance),
f64::from(vertex.normal_distance),
);
let tangent_scalar = (
f64::from(vertex.tangent_distance),
f64::from(vertex.tangent_distance),
);
let next_normal_offset = range_vector_scale(next_normal, normal_scalar)?;
let previous_normal_offset = range_vector_scale(previous_normal, normal_scalar)?;
let tangent_offset = range_vector_scale(next_tangent, tangent_scalar)?;
let mut inactive_candidate = false;
let mut extrusion = range_vector_add(next_normal_offset, tangent_offset)?;
if (1.0..=3.0).contains(&vertex.stroke_role) {
if turn_sign == 0.0 {
extrusion = next_normal_offset;
} else {
let side = vertex.normal_distance.signum();
let outer_side = -turn_sign;
if side * outer_side <= 0.0 {
extrusion = miter_state
.filter(|state| state.1)
.map_or([(0.0, 0.0); 2], |state| state.0);
} else if vertex.stroke_role == 2.0 && miter_state.is_some_and(|state| state.1) {
extrusion = miter_state?.0;
} else if vertex.stroke_parameter < 0.0 {
extrusion = previous_normal_offset;
} else {
extrusion = next_normal_offset;
}
}
extrusion = range_vector_add(extrusion, tangent_offset)?;
} else if vertex.stroke_role >= 4.0 {
let inner = matches!(vertex.stroke_role as i32, 5 | 7 | 9);
let side = vertex.normal_distance.signum();
let candidate_side = if inner { -side } else { side };
let mut active = turn_sign != 0.0 && candidate_side * -turn_sign > 0.0;
if matches!(vertex.stroke_role as i32, 6 | 7) {
active &= miter_state.is_none_or(|state| !state.1);
}
if !active {
inactive_candidate = true;
extrusion = [(0.0, 0.0); 2];
} else if inner {
extrusion = miter_state
.filter(|state| state.1)
.map_or([(0.0, 0.0); 2], |state| state.0);
} else if vertex.stroke_role == 8.0 {
let side_range = (f64::from(candidate_side), f64::from(candidate_side));
let start = range_vector_scale(previous_normal, side_range)?;
let finish = range_vector_scale(next_normal, side_range)?;
let amount = f64::from(vertex.stroke_parameter);
let mixed = range_vector_add(
range_vector_scale(start, (1.0 - amount, 1.0 - amount))?,
range_vector_scale(finish, (amount, amount))?,
)?;
extrusion = range_vector_scale(
stroke_safe_unit_range(mixed)?,
(
f64::from(vertex.normal_distance.abs()),
f64::from(vertex.normal_distance.abs()),
),
)?;
} else if vertex.stroke_parameter < 0.0 {
extrusion = previous_normal_offset;
} else {
extrusion = next_normal_offset;
}
} else if miter_state.is_some_and(|state| state.1) {
extrusion = range_vector_add(miter_state?.0, tangent_offset)?;
}
let screen = range_vector_add(base, extrusion)?;
let screen_offset = [
(
f64::from(vertex.screen_offset[0]),
f64::from(vertex.screen_offset[0]),
),
(
f64::from(vertex.screen_offset[1]),
f64::from(vertex.screen_offset[1]),
),
];
Some((range_vector_add(screen, screen_offset)?, inactive_candidate))
}
}
pub(in crate::renderer) struct StrokeProofs {
uniform: CameraUniform,
outputs: [Option<(VertexKey, Option<ScreenProof>)>; 8],
output_next: usize,
directions: [Option<(DirectionKey, Option<DirectionProof>)>; 8],
direction_next: usize,
bases: [Option<([u32; 5], Option<Ranges>)>; 8],
base_next: usize,
branches: [Option<((DirectionKey, u32), bool)>; 8],
branch_next: usize,
}
impl StrokeProofs {
pub(in crate::renderer) fn new(uniform: CameraUniform) -> Self {
Self {
uniform,
outputs: [None; 8],
output_next: 0,
directions: [None; 8],
direction_next: 0,
bases: [None; 8],
base_next: 0,
branches: [None; 8],
branch_next: 0,
}
}
pub(in crate::renderer) fn screen(&mut self, vertex: Vertex) -> Option<ScreenProof> {
let key = VertexKey::new(vertex);
if let Some((_, proof)) = self
.outputs
.iter()
.flatten()
.find(|(cached, _)| *cached == key)
{
return *proof;
}
let proof = self.screen_uncached(vertex);
self.outputs[self.output_next] = Some((key, proof));
self.output_next = (self.output_next + 1) % self.outputs.len();
proof
}
fn screen_uncached(&mut self, vertex: Vertex) -> Option<ScreenProof> {
if vertex.stroke_role < 0.0 {
return exact_markers::vertex_screen_ranges(vertex, self.uniform);
}
let base_key = [
vertex.world_position[0],
vertex.world_position[1],
vertex.world_offset[0],
vertex.world_offset[1],
vertex.depth,
]
.map(f32::to_bits);
let base = match self
.bases
.iter()
.flatten()
.find(|(key, _)| *key == base_key)
{
Some((_, proof)) => *proof,
None => {
let proof = tessellated_vertex_base_screen_ranges(vertex, self.uniform);
self.bases[self.base_next] = Some((base_key, proof));
self.base_next = (self.base_next + 1) % self.bases.len();
proof
}
}?;
let key = DirectionKey::new(vertex);
let proof = match self
.directions
.iter()
.flatten()
.find(|(cached, _)| *cached == key)
{
Some((_, proof)) => *proof,
None => {
let proof = DirectionProof::new(vertex, self.uniform);
self.directions[self.direction_next] = Some((key, proof));
self.direction_next = (self.direction_next + 1) % self.directions.len();
proof
}
};
proof?.screen(vertex, base)
}
pub(in crate::renderer) fn branches_are_stable(&mut self, vertex: Vertex) -> bool {
if vertex.normal_distance == 0.0 && vertex.tangent_distance == 0.0 {
return true;
}
let key = (DirectionKey::new(vertex), vertex.miter_limit.to_bits());
if let Some((_, proof)) = self
.branches
.iter()
.flatten()
.find(|(cached, _)| *cached == key)
{
return *proof;
}
let proof = logical_stroke_branches_are_stable(vertex, self.uniform);
self.branches[self.branch_next] = Some((key, proof));
self.branch_next = (self.branch_next + 1) % self.branches.len();
proof
}
}
#[cfg(test)]
mod tests;