use std::cell::RefCell;
use std::rc::Rc;
use crate::core::{Core, Object, ObjectRef, OnAdded, Property, TryFromU64};
use crate::math::Mat;
use crate::option_cell::OptionCell;
use crate::renderer::{StrokeStyle, Style};
use crate::shapes::paint::shape_paint_mutator::ShapePaintMutator;
use crate::shapes::paint::stroke_effect::{self, StrokeEffect};
use crate::shapes::paint::ShapePaint;
use crate::shapes::path_space::PathSpace;
use crate::shapes::{CommandPath, MetricsPath};
use crate::{RenderPaint, Renderer};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum StrokeCap {
Butt,
Round,
Square,
}
impl Default for StrokeCap {
fn default() -> Self {
Self::Butt
}
}
impl TryFromU64 for StrokeCap {
fn try_from(val: u64) -> Option<Self> {
match val {
0 => Some(Self::Butt),
1 => Some(Self::Round),
2 => Some(Self::Square),
_ => None,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum StrokeJoin {
Miter,
Round,
Bevel,
}
impl Default for StrokeJoin {
fn default() -> Self {
Self::Miter
}
}
impl TryFromU64 for StrokeJoin {
fn try_from(val: u64) -> Option<Self> {
match val {
0 => Some(Self::Miter),
1 => Some(Self::Round),
2 => Some(Self::Bevel),
_ => None,
}
}
}
#[derive(Debug)]
pub struct Stroke {
shape_paint: ShapePaint,
thickness: Property<f32>,
cap: Property<StrokeCap>,
join: Property<StrokeJoin>,
transform_affects_stroke: Property<bool>,
metrics_path: OptionCell<MetricsPath>,
effect: OptionCell<Object>,
pub(crate) outlined_stroke: OptionCell<CommandPath>,
}
impl ObjectRef<'_, Stroke> {
pub fn thickness(&self) -> f32 {
self.thickness.get()
}
pub fn set_thickness(&self, thickness: f32) {
if self.thickness() == thickness {
return;
}
self.thickness.set(thickness);
self.cast::<ShapePaint>().render_paint().borrow_mut().style = self.style();
self.outlined_stroke.set(None);
}
pub fn cap(&self) -> StrokeCap {
self.cap.get()
}
pub fn set_cap(&self, cap: StrokeCap) {
if self.cap() == cap {
return;
}
self.cap.set(cap);
self.cast::<ShapePaint>().render_paint().borrow_mut().style = self.style();
self.outlined_stroke.set(None);
}
pub fn join(&self) -> StrokeJoin {
self.join.get()
}
pub fn set_join(&self, join: StrokeJoin) {
if self.join() == join {
return;
}
self.join.set(join);
self.cast::<ShapePaint>().render_paint().borrow_mut().style = self.style();
self.outlined_stroke.set(None);
}
pub fn transform_affects_stroke(&self) -> bool {
self.transform_affects_stroke.get()
}
pub fn set_transform_affects_stroke(&self, transform_affects_stroke: bool) {
self.transform_affects_stroke.set(transform_affects_stroke);
}
}
impl ObjectRef<'_, Stroke> {
pub fn init_render_paint(
&self,
mutator: Object<ShapePaintMutator>,
) -> Option<Rc<RefCell<RenderPaint>>> {
let render_paint = self.cast::<ShapePaint>().init_render_paint(mutator).unwrap();
render_paint.borrow_mut().style = self.style();
Some(render_paint)
}
pub(crate) fn style(&self) -> Style {
Style::Stroke(StrokeStyle {
thickness: self.thickness(),
cap: self.cap(),
join: self.join(),
})
}
pub fn path_space(&self) -> PathSpace {
if self.transform_affects_stroke() {
PathSpace::LOCAL
} else {
PathSpace::WORLD
}
}
pub fn has_stroke_effect(&self) -> bool {
self.effect.get().is_some()
}
pub(crate) fn set_stroke_effect(&self, effect: Option<Object>) {
self.effect.set(effect);
}
pub fn invalidate_effects(&self) {
if let Some(effect) = self.effect.get() {
stroke_effect::as_ref(effect.as_ref()).invalidate_effect();
}
self.metrics_path.set(None);
self.outlined_stroke.set(None);
}
pub fn draw(&self, renderer: &mut impl Renderer, path: &CommandPath, transform: Mat) {
if !self.cast::<ShapePaint>().is_visible() {
return;
}
let mut new_outline = None;
self.outlined_stroke.with(|outline| {
if let Some(outline) = outline {
renderer.draw(
outline,
transform,
&*self.cast::<ShapePaint>().render_paint().borrow(),
);
} else {
let new_path;
let path = if let Some(effect) = self.effect.get() {
let effect = stroke_effect::as_ref(effect.as_ref());
self.metrics_path.maybe_init(|| MetricsPath::new(path));
new_path = self
.metrics_path
.with_mut(|metrics_path| effect.effect_path(metrics_path.unwrap()));
&new_path
} else {
path
};
let outline = path.outline_strokes(&StrokeStyle {
thickness: self.thickness(),
cap: self.cap(),
join: self.join(),
});
renderer.draw(
&outline,
transform,
&*self.cast::<ShapePaint>().render_paint().borrow(),
);
new_outline = Some(outline);
}
});
if new_outline.is_some() {
self.outlined_stroke.set(new_outline);
}
}
}
impl Core for Stroke {
parent_types![(shape_paint, ShapePaint)];
properties![
(47, thickness, set_thickness),
(48, cap, set_cap),
(49, join, set_join),
(50, transform_affects_stroke, set_transform_affects_stroke),
shape_paint,
];
}
impl OnAdded for ObjectRef<'_, Stroke> {
on_added!(ShapePaint);
}
impl Default for Stroke {
fn default() -> Self {
Self {
shape_paint: ShapePaint::default(),
thickness: Property::new(1.0),
cap: Property::new(StrokeCap::Butt),
join: Property::new(StrokeJoin::Miter),
transform_affects_stroke: Property::new(true),
metrics_path: OptionCell::new(),
effect: OptionCell::new(),
outlined_stroke: OptionCell::new(),
}
}
}