skyler
/
Lightningbeam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change vector drawing primitive from shape to doubly-connected edge graph

This commit is contained in:
Skyler Lehmkuhl 2026-02-23 21:29:58 -05:00
parent eab116c930
commit 99f8dcfcf4
31 changed files with 2664 additions and 3774 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lightningbeam-ui/Cargo.lock generated
View File

@ -3444,6 +3444,7 @@ dependencies = [
"kurbo 0.12.0", "kurbo 0.12.0",
"lru", "lru",
"pathdiff", "pathdiff",
"rstar",
"serde", "serde",
"serde_json", "serde_json",
"uuid", "uuid",
@ -5345,6 +5346,17 @@ version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97" checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
[[package]]
name = "rstar"
version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "421400d13ccfd26dfa5858199c30a5d76f9c54e0dba7575273025b43c5175dbb"
dependencies = [
"heapless",
"num-traits",
"smallvec",
]
[[package]] [[package]]
name = "rtrb" name = "rtrb"
version = "0.3.2" version = "0.3.2"

3
lightningbeam-ui/lightningbeam-core/Cargo.toml
View File

@ -41,5 +41,8 @@ pathdiff = "0.2"
flacenc = "0.4" # For FLAC encoding (lossless) flacenc = "0.4" # For FLAC encoding (lossless)
claxon = "0.4" # For FLAC decoding claxon = "0.4" # For FLAC decoding
# Spatial indexing for DCEL vertex snapping
rstar = "0.12"
# System clipboard # System clipboard
arboard = "3" arboard = "3"

161
lightningbeam-ui/lightningbeam-core/src/actions/add_shape.rs
View File

@ -1,111 +1,124 @@
//! Add shape action //! Add shape action — inserts strokes into the DCEL.
//! //!
//! Handles adding a new shape to a vector layer's keyframe. //! Converts a BezPath into cubic segments and inserts them via
//! `Dcel::insert_stroke()`. Undo is handled by snapshotting the DCEL.
use crate::action::Action; use crate::action::Action;
use crate::dcel::{bezpath_to_cubic_segments, Dcel, DEFAULT_SNAP_EPSILON};
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer; use crate::layer::AnyLayer;
use crate::shape::Shape; use crate::shape::{ShapeColor, StrokeStyle};
use kurbo::BezPath;
use uuid::Uuid; use uuid::Uuid;
/// Action that adds a shape to a vector layer's keyframe /// Action that inserts a drawn path into a vector layer's DCEL keyframe.
pub struct AddShapeAction { pub struct AddShapeAction {
/// Layer ID to add the shape to
layer_id: Uuid, layer_id: Uuid,
/// The shape to add (contains geometry, styling, transform, opacity)
shape: Shape,
/// Time of the keyframe to add to
time: f64, time: f64,
path: BezPath,
/// ID of the created shape (set after execution) stroke_style: Option<StrokeStyle>,
created_shape_id: Option<Uuid>, stroke_color: Option<ShapeColor>,
fill_color: Option<ShapeColor>,
is_closed: bool,
description_text: String,
/// Snapshot of the DCEL before insertion (for undo).
dcel_before: Option<Dcel>,
} }
impl AddShapeAction { impl AddShapeAction {
pub fn new(layer_id: Uuid, shape: Shape, time: f64) -> Self { pub fn new(
layer_id: Uuid,
time: f64,
path: BezPath,
stroke_style: Option<StrokeStyle>,
stroke_color: Option<ShapeColor>,
fill_color: Option<ShapeColor>,
is_closed: bool,
) -> Self {
Self { Self {
layer_id, layer_id,
shape,
time, time,
created_shape_id: None, path,
stroke_style,
stroke_color,
fill_color,
is_closed,
description_text: "Add shape".to_string(),
dcel_before: None,
} }
} }
pub fn with_description(mut self, desc: impl Into<String>) -> Self {
self.description_text = desc.into();
self
}
} }
impl Action for AddShapeAction { impl Action for AddShapeAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, document: &mut Document) -> Result<(), String> {
let layer = match document.get_layer_mut(&self.layer_id) { let layer = document
Some(l) => l, .get_layer_mut(&self.layer_id)
None => return Ok(()), .ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vl = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Not a vector layer".to_string()),
}; };
if let AnyLayer::Vector(vector_layer) = layer { let keyframe = vl.ensure_keyframe_at(self.time);
let shape_id = self.shape.id; let dcel = &mut keyframe.dcel;
vector_layer.add_shape_to_keyframe(self.shape.clone(), self.time);
self.created_shape_id = Some(shape_id); // Snapshot for undo
self.dcel_before = Some(dcel.clone());
let subpaths = bezpath_to_cubic_segments(&self.path);
for segments in &subpaths {
if segments.is_empty() {
continue;
}
let result = dcel.insert_stroke(
segments,
self.stroke_style.clone(),
self.stroke_color.clone(),
DEFAULT_SNAP_EPSILON,
);
// Apply fill to new faces if this is a closed shape with fill
if self.is_closed {
if let Some(ref fill) = self.fill_color {
for face_id in &result.new_faces {
dcel.face_mut(*face_id).fill_color = Some(fill.clone());
}
}
}
} }
dcel.rebuild_spatial_index();
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, document: &mut Document) -> Result<(), String> {
if let Some(shape_id) = self.created_shape_id { let layer = document
let layer = match document.get_layer_mut(&self.layer_id) { .get_layer_mut(&self.layer_id)
Some(l) => l, .ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
None => return Ok(()),
};
if let AnyLayer::Vector(vector_layer) = layer { let vl = match layer {
vector_layer.remove_shape_from_keyframe(&shape_id, self.time); AnyLayer::Vector(vl) => vl,
} _ => return Err("Not a vector layer".to_string()),
};
let keyframe = vl.ensure_keyframe_at(self.time);
keyframe.dcel = self
.dcel_before
.take()
.ok_or_else(|| "No DCEL snapshot for undo".to_string())?;
self.created_shape_id = None;
}
Ok(()) Ok(())
} }
fn description(&self) -> String { fn description(&self) -> String {
"Add shape".to_string() self.description_text.clone()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::ShapeColor;
use vello::kurbo::{Rect, Shape as KurboShape};
#[test]
fn test_add_shape_action_rectangle() {
let mut document = Document::new("Test");
let vector_layer = VectorLayer::new("Layer 1");
let layer_id = document.root.add_child(AnyLayer::Vector(vector_layer));
let rect = Rect::new(0.0, 0.0, 100.0, 50.0);
let path = rect.to_path(0.1);
let shape = Shape::new(path)
.with_fill(ShapeColor::rgb(255, 0, 0))
.with_position(50.0, 50.0);
let mut action = AddShapeAction::new(layer_id, shape, 0.0);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(layer)) = document.get_layer(&layer_id) {
let shapes = layer.shapes_at_time(0.0);
assert_eq!(shapes.len(), 1);
assert_eq!(shapes[0].transform.x, 50.0);
assert_eq!(shapes[0].transform.y, 50.0);
} else {
panic!("Layer not found or not a vector layer");
}
// Rollback
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(layer)) = document.get_layer(&layer_id) {
assert_eq!(layer.shapes_at_time(0.0).len(), 0);
}
} }
} }

205
lightningbeam-ui/lightningbeam-core/src/actions/convert_to_movie_clip.rs
View File

@ -1,18 +1,13 @@
//! Convert to Movie Clip action //! Convert to Movie Clip action — STUB: needs DCEL rewrite
//!
//! Wraps selected shapes and/or clip instances into a new VectorClip
//! with is_group = false, giving it a real internal timeline.
//! Works with 1+ selected items (unlike Group which requires 2+).
use crate::action::Action; use crate::action::Action;
use crate::animation::{AnimationCurve, AnimationTarget, Keyframe, TransformProperty}; use crate::clip::ClipInstance;
use crate::clip::{ClipInstance, VectorClip};
use crate::document::Document; use crate::document::Document;
use crate::layer::{AnyLayer, VectorLayer};
use crate::shape::Shape;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::{Rect, Shape as KurboShape};
/// Action that converts selected items to a Movie Clip
/// TODO: Rewrite for DCEL
#[allow(dead_code)]
pub struct ConvertToMovieClipAction { pub struct ConvertToMovieClipAction {
layer_id: Uuid, layer_id: Uuid,
time: f64, time: f64,
@ -20,7 +15,6 @@ pub struct ConvertToMovieClipAction {
clip_instance_ids: Vec<Uuid>, clip_instance_ids: Vec<Uuid>,
instance_id: Uuid, instance_id: Uuid,
created_clip_id: Option<Uuid>, created_clip_id: Option<Uuid>,
removed_shapes: Vec<Shape>,
removed_clip_instances: Vec<ClipInstance>, removed_clip_instances: Vec<ClipInstance>,
} }
@ -39,201 +33,18 @@ impl ConvertToMovieClipAction {
clip_instance_ids, clip_instance_ids,
instance_id, instance_id,
created_clip_id: None, created_clip_id: None,
removed_shapes: Vec::new(),
removed_clip_instances: Vec::new(), removed_clip_instances: Vec::new(),
} }
} }
} }
impl Action for ConvertToMovieClipAction { impl Action for ConvertToMovieClipAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = document let _ = (&self.layer_id, self.time, &self.shape_ids, &self.clip_instance_ids, self.instance_id);
.get_layer(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vl = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Convert to Movie Clip is only supported on vector layers".to_string()),
};
// Collect shapes
let shapes_at_time = vl.shapes_at_time(self.time);
let mut collected_shapes: Vec<Shape> = Vec::new();
for id in &self.shape_ids {
if let Some(shape) = shapes_at_time.iter().find(|s| &s.id == id) {
collected_shapes.push(shape.clone());
}
}
// Collect clip instances
let mut collected_clip_instances: Vec<ClipInstance> = Vec::new();
for id in &self.clip_instance_ids {
if let Some(ci) = vl.clip_instances.iter().find(|ci| &ci.id == id) {
collected_clip_instances.push(ci.clone());
}
}
let total_items = collected_shapes.len() + collected_clip_instances.len();
if total_items < 1 {
return Err("Need at least 1 item to convert to movie clip".to_string());
}
// Compute combined bounding box
let mut combined_bbox: Option<Rect> = None;
for shape in &collected_shapes {
let local_bbox = shape.path().bounding_box();
let transform = shape.transform.to_affine();
let transformed_bbox = transform.transform_rect_bbox(local_bbox);
combined_bbox = Some(match combined_bbox {
Some(existing) => existing.union(transformed_bbox),
None => transformed_bbox,
});
}
for ci in &collected_clip_instances {
let content_bounds = if let Some(vector_clip) = document.get_vector_clip(&ci.clip_id) {
let clip_time = ((self.time - ci.timeline_start) * ci.playback_speed) + ci.trim_start;
vector_clip.calculate_content_bounds(document, clip_time)
} else if let Some(video_clip) = document.get_video_clip(&ci.clip_id) {
Rect::new(0.0, 0.0, video_clip.width, video_clip.height)
} else {
continue;
};
let ci_transform = ci.transform.to_affine();
let transformed_bbox = ci_transform.transform_rect_bbox(content_bounds);
combined_bbox = Some(match combined_bbox {
Some(existing) => existing.union(transformed_bbox),
None => transformed_bbox,
});
}
let bbox = combined_bbox.ok_or("Could not compute bounding box")?;
let center_x = (bbox.x0 + bbox.x1) / 2.0;
let center_y = (bbox.y0 + bbox.y1) / 2.0;
// Offset shapes relative to center
let mut clip_shapes: Vec<Shape> = collected_shapes.clone();
for shape in &mut clip_shapes {
shape.transform.x -= center_x;
shape.transform.y -= center_y;
}
let mut clip_instances_inside: Vec<ClipInstance> = collected_clip_instances.clone();
for ci in &mut clip_instances_inside {
ci.transform.x -= center_x;
ci.transform.y -= center_y;
}
// Create VectorClip with real timeline duration
let mut clip = VectorClip::new("Movie Clip", bbox.width(), bbox.height(), document.duration);
// is_group defaults to false — movie clips have real timelines
let clip_id = clip.id;
let mut inner_layer = VectorLayer::new("Layer 1");
for shape in clip_shapes {
inner_layer.add_shape_to_keyframe(shape, 0.0);
}
for ci in clip_instances_inside {
inner_layer.clip_instances.push(ci);
}
clip.layers.add_root(AnyLayer::Vector(inner_layer));
document.add_vector_clip(clip);
self.created_clip_id = Some(clip_id);
// Remove originals from the layer
let layer = document.get_layer_mut(&self.layer_id).unwrap();
let vl = match layer {
AnyLayer::Vector(vl) => vl,
_ => unreachable!(),
};
self.removed_shapes.clear();
for id in &self.shape_ids {
if let Some(shape) = vl.remove_shape_from_keyframe(id, self.time) {
self.removed_shapes.push(shape);
}
}
self.removed_clip_instances.clear();
for id in &self.clip_instance_ids {
if let Some(pos) = vl.clip_instances.iter().position(|ci| &ci.id == id) {
self.removed_clip_instances.push(vl.clip_instances.remove(pos));
}
}
// Place the new ClipInstance
let instance = ClipInstance::with_id(self.instance_id, clip_id)
.with_position(center_x, center_y)
.with_name("Movie Clip");
vl.clip_instances.push(instance);
// Create default animation curves
let props_and_values = [
(TransformProperty::X, center_x),
(TransformProperty::Y, center_y),
(TransformProperty::Rotation, 0.0),
(TransformProperty::ScaleX, 1.0),
(TransformProperty::ScaleY, 1.0),
(TransformProperty::SkewX, 0.0),
(TransformProperty::SkewY, 0.0),
(TransformProperty::Opacity, 1.0),
];
for (prop, value) in props_and_values {
let target = AnimationTarget::Object {
id: self.instance_id,
property: prop,
};
let mut curve = AnimationCurve::new(target.clone(), value);
curve.set_keyframe(Keyframe::linear(0.0, value));
vl.layer.animation_data.set_curve(curve);
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = document
.get_layer_mut(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
if let AnyLayer::Vector(vl) = layer {
// Remove animation curves
for prop in &[
TransformProperty::X, TransformProperty::Y,
TransformProperty::Rotation,
TransformProperty::ScaleX, TransformProperty::ScaleY,
TransformProperty::SkewX, TransformProperty::SkewY,
TransformProperty::Opacity,
] {
let target = AnimationTarget::Object {
id: self.instance_id,
property: *prop,
};
vl.layer.animation_data.remove_curve(&target);
}
// Remove the clip instance
vl.clip_instances.retain(|ci| ci.id != self.instance_id);
// Re-insert removed shapes
for shape in self.removed_shapes.drain(..) {
vl.add_shape_to_keyframe(shape, self.time);
}
// Re-insert removed clip instances
for ci in self.removed_clip_instances.drain(..) {
vl.clip_instances.push(ci);
}
}
// Remove the VectorClip from the document
if let Some(clip_id) = self.created_clip_id.take() {
document.remove_vector_clip(&clip_id);
}
Ok(()) Ok(())
} }

372
lightningbeam-ui/lightningbeam-core/src/actions/group_shapes.rs
View File

@ -1,42 +1,20 @@
//! Group action //! Group action — STUB: needs DCEL rewrite
//!
//! Groups selected shapes and/or clip instances into a new VectorClip
//! with a ClipInstance placed on the layer. Supports grouping shapes,
//! existing clip instances (groups), or a mix of both.
use crate::action::Action; use crate::action::Action;
use crate::animation::{AnimationCurve, AnimationTarget, Keyframe, TransformProperty}; use crate::clip::ClipInstance;
use crate::clip::{ClipInstance, VectorClip};
use crate::document::Document; use crate::document::Document;
use crate::layer::{AnyLayer, VectorLayer};
use crate::shape::Shape;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::{Rect, Shape as KurboShape};
/// Action that groups selected shapes and/or clip instances into a VectorClip /// Action that groups selected shapes and/or clip instances into a VectorClip
/// TODO: Rewrite for DCEL (group DCEL faces/edges into a sub-clip)
#[allow(dead_code)]
pub struct GroupAction { pub struct GroupAction {
/// Layer containing the items to group
layer_id: Uuid, layer_id: Uuid,
/// Time of the keyframe to operate on (for shape lookup)
time: f64, time: f64,
/// Shape IDs to include in the group
shape_ids: Vec<Uuid>, shape_ids: Vec<Uuid>,
/// Clip instance IDs to include in the group
clip_instance_ids: Vec<Uuid>, clip_instance_ids: Vec<Uuid>,
/// Pre-generated clip instance ID for the new group (so caller can update selection)
instance_id: Uuid, instance_id: Uuid,
/// Created clip ID (for rollback)
created_clip_id: Option<Uuid>, created_clip_id: Option<Uuid>,
/// Shapes removed from the keyframe (for rollback)
removed_shapes: Vec<Shape>,
/// Clip instances removed from the layer (for rollback, preserving original order)
removed_clip_instances: Vec<ClipInstance>, removed_clip_instances: Vec<ClipInstance>,
} }
@ -55,227 +33,19 @@ impl GroupAction {
clip_instance_ids, clip_instance_ids,
instance_id, instance_id,
created_clip_id: None, created_clip_id: None,
removed_shapes: Vec::new(),
removed_clip_instances: Vec::new(), removed_clip_instances: Vec::new(),
} }
} }
} }
impl Action for GroupAction { impl Action for GroupAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
// --- Phase 1: Collect items and compute bounding box --- let _ = (&self.layer_id, self.time, &self.shape_ids, &self.clip_instance_ids, self.instance_id);
// TODO: Implement DCEL-aware grouping
let layer = document
.get_layer(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vl = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Group is only supported on vector layers".to_string()),
};
// Collect shapes
let shapes_at_time = vl.shapes_at_time(self.time);
let mut group_shapes: Vec<Shape> = Vec::new();
for id in &self.shape_ids {
if let Some(shape) = shapes_at_time.iter().find(|s| &s.id == id) {
group_shapes.push(shape.clone());
}
}
// Collect clip instances
let mut group_clip_instances: Vec<ClipInstance> = Vec::new();
for id in &self.clip_instance_ids {
if let Some(ci) = vl.clip_instances.iter().find(|ci| &ci.id == id) {
group_clip_instances.push(ci.clone());
}
}
let total_items = group_shapes.len() + group_clip_instances.len();
if total_items < 2 {
return Err("Need at least 2 items to group".to_string());
}
// Compute combined bounding box in parent (layer) space
let mut combined_bbox: Option<Rect> = None;
// Shape bounding boxes
for shape in &group_shapes {
let local_bbox = shape.path().bounding_box();
let transform = shape.transform.to_affine();
let transformed_bbox = transform.transform_rect_bbox(local_bbox);
combined_bbox = Some(match combined_bbox {
Some(existing) => existing.union(transformed_bbox),
None => transformed_bbox,
});
}
// Clip instance bounding boxes
for ci in &group_clip_instances {
let content_bounds = if let Some(vector_clip) = document.get_vector_clip(&ci.clip_id) {
let clip_time = ((self.time - ci.timeline_start) * ci.playback_speed) + ci.trim_start;
vector_clip.calculate_content_bounds(document, clip_time)
} else if let Some(video_clip) = document.get_video_clip(&ci.clip_id) {
Rect::new(0.0, 0.0, video_clip.width, video_clip.height)
} else {
continue;
};
let ci_transform = ci.transform.to_affine();
let transformed_bbox = ci_transform.transform_rect_bbox(content_bounds);
combined_bbox = Some(match combined_bbox {
Some(existing) => existing.union(transformed_bbox),
None => transformed_bbox,
});
}
let bbox = combined_bbox.ok_or("Could not compute bounding box")?;
let center_x = (bbox.x0 + bbox.x1) / 2.0;
let center_y = (bbox.y0 + bbox.y1) / 2.0;
// --- Phase 2: Build the VectorClip ---
// Offset shapes so positions are relative to the group center
let mut clip_shapes: Vec<Shape> = group_shapes.clone();
for shape in &mut clip_shapes {
shape.transform.x -= center_x;
shape.transform.y -= center_y;
}
// Offset clip instances similarly
let mut clip_instances_inside: Vec<ClipInstance> = group_clip_instances.clone();
for ci in &mut clip_instances_inside {
ci.transform.x -= center_x;
ci.transform.y -= center_y;
}
// Create VectorClip — groups are static (one frame), not time-based clips
let frame_duration = 1.0 / document.framerate;
let mut clip = VectorClip::new("Group", bbox.width(), bbox.height(), frame_duration);
clip.is_group = true;
let clip_id = clip.id;
let mut inner_layer = VectorLayer::new("Layer 1");
for shape in clip_shapes {
inner_layer.add_shape_to_keyframe(shape, 0.0);
}
for ci in clip_instances_inside {
inner_layer.clip_instances.push(ci);
}
clip.layers.add_root(AnyLayer::Vector(inner_layer));
// Add clip to document library
document.add_vector_clip(clip);
self.created_clip_id = Some(clip_id);
// --- Phase 3: Remove originals from the layer ---
let layer = document.get_layer_mut(&self.layer_id).unwrap();
let vl = match layer {
AnyLayer::Vector(vl) => vl,
_ => unreachable!(),
};
// Remove shapes
self.removed_shapes.clear();
for id in &self.shape_ids {
if let Some(shape) = vl.remove_shape_from_keyframe(id, self.time) {
self.removed_shapes.push(shape);
}
}
// Remove clip instances (preserve order for rollback)
self.removed_clip_instances.clear();
for id in &self.clip_instance_ids {
if let Some(pos) = vl.clip_instances.iter().position(|ci| &ci.id == id) {
self.removed_clip_instances.push(vl.clip_instances.remove(pos));
}
}
// --- Phase 4: Place the new group ClipInstance ---
let instance = ClipInstance::with_id(self.instance_id, clip_id)
.with_position(center_x, center_y)
.with_name("Group");
vl.clip_instances.push(instance);
// Register the group in the current keyframe's clip_instance_ids
if let Some(kf) = vl.keyframe_at_mut(self.time) {
if !kf.clip_instance_ids.contains(&self.instance_id) {
kf.clip_instance_ids.push(self.instance_id);
}
}
// --- Phase 5: Create default animation curves with initial keyframe ---
let props_and_values = [
(TransformProperty::X, center_x),
(TransformProperty::Y, center_y),
(TransformProperty::Rotation, 0.0),
(TransformProperty::ScaleX, 1.0),
(TransformProperty::ScaleY, 1.0),
(TransformProperty::SkewX, 0.0),
(TransformProperty::SkewY, 0.0),
(TransformProperty::Opacity, 1.0),
];
for (prop, value) in props_and_values {
let target = AnimationTarget::Object {
id: self.instance_id,
property: prop,
};
let mut curve = AnimationCurve::new(target.clone(), value);
curve.set_keyframe(Keyframe::linear(0.0, value));
vl.layer.animation_data.set_curve(curve);
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = document
.get_layer_mut(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
if let AnyLayer::Vector(vl) = layer {
// Remove animation curves for the group's clip instance
for prop in &[
TransformProperty::X, TransformProperty::Y,
TransformProperty::Rotation,
TransformProperty::ScaleX, TransformProperty::ScaleY,
TransformProperty::SkewX, TransformProperty::SkewY,
TransformProperty::Opacity,
] {
let target = AnimationTarget::Object {
id: self.instance_id,
property: *prop,
};
vl.layer.animation_data.remove_curve(&target);
}
// Remove the group's clip instance
vl.clip_instances.retain(|ci| ci.id != self.instance_id);
// Remove the group ID from the keyframe
if let Some(kf) = vl.keyframe_at_mut(self.time) {
kf.clip_instance_ids.retain(|id| id != &self.instance_id);
}
// Re-insert removed shapes
for shape in self.removed_shapes.drain(..) {
vl.add_shape_to_keyframe(shape, self.time);
}
// Re-insert removed clip instances
for ci in self.removed_clip_instances.drain(..) {
vl.clip_instances.push(ci);
}
}
// Remove the VectorClip from the document
if let Some(clip_id) = self.created_clip_id.take() {
document.remove_vector_clip(&clip_id);
}
Ok(()) Ok(())
} }
@ -284,129 +54,3 @@ impl Action for GroupAction {
format!("Group {} objects", count) format!("Group {} objects", count)
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::shape::ShapeColor;
use vello::kurbo::{Circle, Shape as KurboShape};
#[test]
fn test_group_shapes() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let circle1 = Circle::new((0.0, 0.0), 20.0);
let shape1 = Shape::new(circle1.to_path(0.1))
.with_fill(ShapeColor::rgb(255, 0, 0))
.with_position(50.0, 50.0);
let shape1_id = shape1.id;
let circle2 = Circle::new((0.0, 0.0), 20.0);
let shape2 = Shape::new(circle2.to_path(0.1))
.with_fill(ShapeColor::rgb(0, 255, 0))
.with_position(150.0, 50.0);
let shape2_id = shape2.id;
layer.add_shape_to_keyframe(shape1, 0.0);
layer.add_shape_to_keyframe(shape2, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let instance_id = Uuid::new_v4();
let mut action = GroupAction::new(
layer_id, 0.0,
vec![shape1_id, shape2_id],
vec![],
instance_id,
);
action.execute(&mut document).unwrap();
// Shapes removed, clip instance added
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.shapes_at_time(0.0).len(), 0);
assert_eq!(vl.clip_instances.len(), 1);
assert_eq!(vl.clip_instances[0].id, instance_id);
}
assert_eq!(document.vector_clips.len(), 1);
// Rollback
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.shapes_at_time(0.0).len(), 2);
assert_eq!(vl.clip_instances.len(), 0);
}
assert!(document.vector_clips.is_empty());
}
#[test]
fn test_group_mixed_shapes_and_clips() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
// Add a shape
let circle = Circle::new((0.0, 0.0), 20.0);
let shape = Shape::new(circle.to_path(0.1))
.with_fill(ShapeColor::rgb(255, 0, 0))
.with_position(50.0, 50.0);
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
// Add a clip instance (create a clip for it first)
let mut inner_clip = VectorClip::new("Inner", 40.0, 40.0, 1.0);
let inner_clip_id = inner_clip.id;
let mut inner_layer = VectorLayer::new("Inner Layer");
let inner_shape = Shape::new(Circle::new((20.0, 20.0), 15.0).to_path(0.1))
.with_fill(ShapeColor::rgb(0, 0, 255));
inner_layer.add_shape_to_keyframe(inner_shape, 0.0);
inner_clip.layers.add_root(AnyLayer::Vector(inner_layer));
document.add_vector_clip(inner_clip);
let ci = ClipInstance::new(inner_clip_id).with_position(150.0, 50.0);
let ci_id = ci.id;
layer.clip_instances.push(ci);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let instance_id = Uuid::new_v4();
let mut action = GroupAction::new(
layer_id, 0.0,
vec![shape_id],
vec![ci_id],
instance_id,
);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.shapes_at_time(0.0).len(), 0);
// Only the new group instance remains (the inner clip instance was grouped)
assert_eq!(vl.clip_instances.len(), 1);
assert_eq!(vl.clip_instances[0].id, instance_id);
}
// Two vector clips: the inner one + the new group
assert_eq!(document.vector_clips.len(), 2);
// Rollback
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.shapes_at_time(0.0).len(), 1);
assert_eq!(vl.clip_instances.len(), 1);
assert_eq!(vl.clip_instances[0].id, ci_id);
}
// Only the inner clip remains
assert_eq!(document.vector_clips.len(), 1);
}
#[test]
fn test_group_description() {
let action = GroupAction::new(
Uuid::new_v4(), 0.0,
vec![Uuid::new_v4(), Uuid::new_v4()],
vec![Uuid::new_v4()],
Uuid::new_v4(),
);
assert_eq!(action.description(), "Group 3 objects");
}
}

2
lightningbeam-ui/lightningbeam-core/src/actions/mod.rs
View File

@ -37,7 +37,7 @@ pub use add_clip_instance::AddClipInstanceAction;
pub use add_effect::AddEffectAction; pub use add_effect::AddEffectAction;
pub use add_layer::AddLayerAction; pub use add_layer::AddLayerAction;
pub use add_shape::AddShapeAction; pub use add_shape::AddShapeAction;
pub use modify_shape_path::ModifyShapePathAction; pub use modify_shape_path::ModifyDcelAction;
pub use move_clip_instances::MoveClipInstancesAction; pub use move_clip_instances::MoveClipInstancesAction;
pub use move_objects::MoveShapeInstancesAction; pub use move_objects::MoveShapeInstancesAction;
pub use paint_bucket::PaintBucketAction; pub use paint_bucket::PaintBucketAction;

236
lightningbeam-ui/lightningbeam-core/src/actions/modify_shape_path.rs
View File

@ -1,223 +1,83 @@
//! Modify shape path action //! Modify DCEL action — snapshot-based undo for DCEL editing
//!
//! Handles modifying a shape's bezier path (for vector editing operations)
//! with undo/redo support.
use crate::action::Action; use crate::action::Action;
use crate::dcel::Dcel;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer; use crate::layer::AnyLayer;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::BezPath;
/// Action that modifies a shape's path /// Action that captures a before/after DCEL snapshot for undo/redo.
/// ///
/// This action is used for vector editing operations like dragging vertices, /// Used by vertex editing, curve editing, and control point editing.
/// reshaping curves, or manipulating control points. /// The caller provides both snapshots (taken before and after the edit).
pub struct ModifyShapePathAction { pub struct ModifyDcelAction {
/// Layer containing the shape
layer_id: Uuid, layer_id: Uuid,
/// Shape to modify
shape_id: Uuid,
/// Time of the keyframe containing the shape
time: f64, time: f64,
dcel_before: Option<Dcel>,
/// The version index being modified (for shapes with multiple versions) dcel_after: Option<Dcel>,
version_index: usize, description_text: String,
/// New path
new_path: BezPath,
/// Old path (stored after first execution for undo)
old_path: Option<BezPath>,
} }
impl ModifyShapePathAction { impl ModifyDcelAction {
/// Create a new action to modify a shape's path pub fn new(
pub fn new(layer_id: Uuid, shape_id: Uuid, time: f64, version_index: usize, new_path: BezPath) -> Self {
Self {
layer_id,
shape_id,
time,
version_index,
new_path,
old_path: None,
}
}
/// Create action with old path already known (for optimization)
pub fn with_old_path(
layer_id: Uuid, layer_id: Uuid,
shape_id: Uuid,
time: f64, time: f64,
version_index: usize, dcel_before: Dcel,
old_path: BezPath, dcel_after: Dcel,
new_path: BezPath, description: impl Into<String>,
) -> Self { ) -> Self {
Self { Self {
layer_id, layer_id,
shape_id,
time, time,
version_index, dcel_before: Some(dcel_before),
new_path, dcel_after: Some(dcel_after),
old_path: Some(old_path), description_text: description.into(),
} }
} }
} }
impl Action for ModifyShapePathAction { impl Action for ModifyDcelAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, document: &mut Document) -> Result<(), String> {
if let Some(layer) = document.get_layer_mut(&self.layer_id) { let dcel_after = self.dcel_after.as_ref()
if let AnyLayer::Vector(vector_layer) = layer { .ok_or("ModifyDcelAction: no dcel_after snapshot")?
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(&self.shape_id, self.time) { .clone();
if self.version_index >= shape.versions.len() {
return Err(format!(
"Version index {} out of bounds (shape has {} versions)",
self.version_index,
shape.versions.len()
));
}
// Store old path if not already stored let layer = document.get_layer_mut(&self.layer_id)
if self.old_path.is_none() { .ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
self.old_path = Some(shape.versions[self.version_index].path.clone());
}
// Apply new path if let AnyLayer::Vector(vl) = layer {
shape.versions[self.version_index].path = self.new_path.clone(); if let Some(kf) = vl.keyframe_at_mut(self.time) {
kf.dcel = dcel_after;
return Ok(()); Ok(())
} } else {
Err(format!("No keyframe at time {}", self.time))
} }
} else {
Err("Not a vector layer".to_string())
} }
Err(format!(
"Could not find shape {} in layer {}",
self.shape_id, self.layer_id
))
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, document: &mut Document) -> Result<(), String> {
if let Some(old_path) = &self.old_path { let dcel_before = self.dcel_before.as_ref()
if let Some(layer) = document.get_layer_mut(&self.layer_id) { .ok_or("ModifyDcelAction: no dcel_before snapshot")?
if let AnyLayer::Vector(vector_layer) = layer { .clone();
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(&self.shape_id, self.time) {
if self.version_index < shape.versions.len() {
shape.versions[self.version_index].path = old_path.clone();
return Ok(());
}
}
}
}
}
Err(format!( let layer = document.get_layer_mut(&self.layer_id)
"Could not rollback shape path modification for shape {} in layer {}", .ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
self.shape_id, self.layer_id
)) if let AnyLayer::Vector(vl) = layer {
if let Some(kf) = vl.keyframe_at_mut(self.time) {
kf.dcel = dcel_before;
Ok(())
} else {
Err(format!("No keyframe at time {}", self.time))
}
} else {
Err("Not a vector layer".to_string())
}
} }
fn description(&self) -> String { fn description(&self) -> String {
"Modify shape path".to_string() self.description_text.clone()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::Shape;
use vello::kurbo::Shape as KurboShape;
fn create_test_path() -> BezPath {
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((100.0, 0.0));
path.line_to((100.0, 100.0));
path.line_to((0.0, 100.0));
path.close_path();
path
}
fn create_modified_path() -> BezPath {
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((150.0, 0.0));
path.line_to((150.0, 150.0));
path.line_to((0.0, 150.0));
path.close_path();
path
}
#[test]
fn test_modify_shape_path() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape = Shape::new(create_test_path());
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
// Verify initial path
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
let bbox = shape.versions[0].path.bounding_box();
assert_eq!(bbox.width(), 100.0);
assert_eq!(bbox.height(), 100.0);
}
// Create and execute action
let new_path = create_modified_path();
let mut action = ModifyShapePathAction::new(layer_id, shape_id, 0.0, 0, new_path);
action.execute(&mut document).unwrap();
// Verify path changed
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
let bbox = shape.versions[0].path.bounding_box();
assert_eq!(bbox.width(), 150.0);
assert_eq!(bbox.height(), 150.0);
}
// Rollback
action.rollback(&mut document).unwrap();
// Verify restored
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
let bbox = shape.versions[0].path.bounding_box();
assert_eq!(bbox.width(), 100.0);
assert_eq!(bbox.height(), 100.0);
}
}
#[test]
fn test_invalid_version_index() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape = Shape::new(create_test_path());
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let new_path = create_modified_path();
let mut action = ModifyShapePathAction::new(layer_id, shape_id, 0.0, 5, new_path);
let result = action.execute(&mut document);
assert!(result.is_err());
assert!(result.unwrap_err().contains("out of bounds"));
}
#[test]
fn test_description() {
let layer_id = Uuid::new_v4();
let shape_id = Uuid::new_v4();
let action = ModifyShapePathAction::new(layer_id, shape_id, 0.0, 0, create_test_path());
assert_eq!(action.description(), "Modify shape path");
} }
} }

2
lightningbeam-ui/lightningbeam-core/src/actions/move_asset_to_folder.rs
View File

@ -247,7 +247,7 @@ mod tests {
let folder2_id = folder2_action.created_folder_id().unwrap(); let folder2_id = folder2_action.created_folder_id().unwrap();
// Create a clip in folder 1 // Create a clip in folder 1
let mut clip = crate::clip::AudioClip::new_sampled("Test Audio", 5.0, 0); let mut clip = crate::clip::AudioClip::new_sampled("Test Audio", 0, 5.0);
clip.folder_id = Some(folder1_id); clip.folder_id = Some(folder1_id);
let clip_id = clip.id; let clip_id = clip.id;
document.audio_clips.insert(clip_id, clip); document.audio_clips.insert(clip_id, clip);

38
lightningbeam-ui/lightningbeam-core/src/actions/move_objects.rs
View File

@ -1,19 +1,16 @@
//! Move shapes action //! Move shapes action — STUB: needs DCEL rewrite
//!
//! Handles moving one or more shapes to new positions within a keyframe.
use crate::action::Action; use crate::action::Action;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer;
use std::collections::HashMap; use std::collections::HashMap;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::Point; use vello::kurbo::Point;
/// Action that moves shapes to new positions within a keyframe /// Action that moves shapes to new positions within a keyframe
/// TODO: Replace with DCEL vertex translation
pub struct MoveShapeInstancesAction { pub struct MoveShapeInstancesAction {
layer_id: Uuid, layer_id: Uuid,
time: f64, time: f64,
/// Map of shape IDs to their old and new positions
shape_positions: HashMap<Uuid, (Point, Point)>, shape_positions: HashMap<Uuid, (Point, Point)>,
} }
@ -28,37 +25,12 @@ impl MoveShapeInstancesAction {
} }
impl Action for MoveShapeInstancesAction { impl Action for MoveShapeInstancesAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = match document.get_layer_mut(&self.layer_id) { let _ = (&self.layer_id, self.time, &self.shape_positions);
Some(l) => l,
None => return Ok(()),
};
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, (_old, new)) in &self.shape_positions {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(shape_id, self.time) {
shape.transform.x = new.x;
shape.transform.y = new.y;
}
}
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = match document.get_layer_mut(&self.layer_id) {
Some(l) => l,
None => return Ok(()),
};
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, (old, _new)) in &self.shape_positions {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(shape_id, self.time) {
shape.transform.x = old.x;
shape.transform.y = old.y;
}
}
}
Ok(()) Ok(())
} }

248
lightningbeam-ui/lightningbeam-core/src/actions/paint_bucket.rs
View File

@ -1,44 +1,27 @@
//! Paint bucket fill action //! Paint bucket fill action — STUB: needs DCEL rewrite
//! //!
//! This action performs a paint bucket fill operation starting from a click point, //! With DCEL, paint bucket simply hit-tests faces and sets fill_color.
//! using planar graph face detection to identify the region to fill.
use crate::action::Action; use crate::action::Action;
use crate::curve_segment::CurveSegment;
use crate::document::Document; use crate::document::Document;
use crate::gap_handling::GapHandlingMode; use crate::gap_handling::GapHandlingMode;
use crate::layer::AnyLayer;
use crate::planar_graph::PlanarGraph;
use crate::shape::ShapeColor; use crate::shape::ShapeColor;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::Point; use vello::kurbo::Point;
/// Action that performs a paint bucket fill operation /// Action that performs a paint bucket fill operation
/// TODO: Rewrite to use DCEL face hit-testing
pub struct PaintBucketAction { pub struct PaintBucketAction {
/// Layer ID to add the filled shape to
layer_id: Uuid, layer_id: Uuid,
/// Time of the keyframe to operate on
time: f64, time: f64,
/// Click point where fill was initiated
click_point: Point, click_point: Point,
/// Fill color for the shape
fill_color: ShapeColor, fill_color: ShapeColor,
/// Tolerance for gap bridging (in pixels)
_tolerance: f64, _tolerance: f64,
/// Gap handling mode
_gap_mode: GapHandlingMode, _gap_mode: GapHandlingMode,
/// ID of the created shape (set after execution)
created_shape_id: Option<Uuid>, created_shape_id: Option<Uuid>,
} }
impl PaintBucketAction { impl PaintBucketAction {
/// Create a new paint bucket action
pub fn new( pub fn new(
layer_id: Uuid, layer_id: Uuid,
time: f64, time: f64,
@ -60,93 +43,14 @@ impl PaintBucketAction {
} }
impl Action for PaintBucketAction { impl Action for PaintBucketAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
println!("=== PaintBucketAction::execute ==="); let _ = (&self.layer_id, self.time, self.click_point, self.fill_color);
// TODO: Hit-test DCEL faces, set face.fill_color
// Optimization: Check if we're clicking on an existing shape first
if let Some(AnyLayer::Vector(vector_layer)) = document.get_layer_mut(&self.layer_id) {
// Iterate through shapes in the keyframe in reverse order (topmost first)
let shapes = vector_layer.shapes_at_time(self.time);
for shape in shapes.iter().rev() {
// Skip shapes without fill color
if shape.fill_color.is_none() {
continue;
}
use vello::kurbo::PathEl;
let is_closed = shape.path().elements().iter().any(|el| matches!(el, PathEl::ClosePath));
if !is_closed {
continue;
}
// Apply the shape's transform
let transform_affine = shape.transform.to_affine();
let inverse_transform = transform_affine.inverse();
let local_point = inverse_transform * self.click_point;
use vello::kurbo::Shape as KurboShape;
let winding = shape.path().winding(local_point);
if winding != 0 {
println!("Clicked on existing shape, changing fill color");
let shape_id = shape.id;
// Now get mutable access to change the fill
if let Some(shape_mut) = vector_layer.get_shape_in_keyframe_mut(&shape_id, self.time) {
shape_mut.fill_color = Some(self.fill_color);
}
return Ok(());
}
}
println!("No existing shape at click point, creating new fill region");
}
// Step 1: Extract curves from all shapes in the keyframe
let all_curves = extract_curves_from_keyframe(document, &self.layer_id, self.time);
println!("Extracted {} curves from all shapes", all_curves.len());
if all_curves.is_empty() {
println!("No curves found, returning");
return Ok(());
}
// Step 2: Build planar graph
println!("Building planar graph...");
let graph = PlanarGraph::build(&all_curves);
// Step 3: Trace the face containing the click point
println!("Tracing face from click point {:?}...", self.click_point);
if let Some(face) = graph.trace_face_from_point(self.click_point) {
println!("Successfully traced face containing click point!");
let face_path = graph.build_face_path(&face);
let face_shape = crate::shape::Shape::new(face_path)
.with_fill(self.fill_color);
self.created_shape_id = Some(face_shape.id);
if let Some(AnyLayer::Vector(vector_layer)) = document.get_layer_mut(&self.layer_id) {
vector_layer.add_shape_to_keyframe(face_shape, self.time);
println!("DEBUG: Added filled shape to keyframe");
}
} else {
println!("Click point is not inside any face!");
}
println!("=== Paint Bucket Complete ===");
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
if let Some(shape_id) = self.created_shape_id { self.created_shape_id = None;
if let Some(AnyLayer::Vector(vector_layer)) = document.get_layer_mut(&self.layer_id) {
vector_layer.remove_shape_from_keyframe(&shape_id, self.time);
}
self.created_shape_id = None;
}
Ok(()) Ok(())
} }
@ -154,139 +58,3 @@ impl Action for PaintBucketAction {
"Paint bucket fill".to_string() "Paint bucket fill".to_string()
} }
} }
/// Extract curves from all shapes in the keyframe at the given time
fn extract_curves_from_keyframe(
document: &Document,
layer_id: &Uuid,
time: f64,
) -> Vec<CurveSegment> {
let mut all_curves = Vec::new();
let layer = match document.get_layer(layer_id) {
Some(l) => l,
None => return all_curves,
};
if let AnyLayer::Vector(vector_layer) = layer {
let shapes = vector_layer.shapes_at_time(time);
println!("Extracting curves from {} shapes in keyframe", shapes.len());
for (shape_idx, shape) in shapes.iter().enumerate() {
let transform_affine = shape.transform.to_affine();
let path = shape.path();
let mut current_point = Point::ZERO;
let mut subpath_start = Point::ZERO;
let mut segment_index = 0;
let mut curves_in_shape = 0;
for element in path.elements() {
if let Some(mut segment) = CurveSegment::from_path_element(
shape.id.as_u128() as usize,
segment_index,
element,
current_point,
) {
for control_point in &mut segment.control_points {
*control_point = transform_affine * (*control_point);
}
all_curves.push(segment);
segment_index += 1;
curves_in_shape += 1;
}
match element {
vello::kurbo::PathEl::MoveTo(p) => {
current_point = *p;
subpath_start = *p;
}
vello::kurbo::PathEl::LineTo(p) => current_point = *p,
vello::kurbo::PathEl::QuadTo(_, p) => current_point = *p,
vello::kurbo::PathEl::CurveTo(_, _, p) => current_point = *p,
vello::kurbo::PathEl::ClosePath => {
if let Some(mut segment) = CurveSegment::from_path_element(
shape.id.as_u128() as usize,
segment_index,
&vello::kurbo::PathEl::LineTo(subpath_start),
current_point,
) {
for control_point in &mut segment.control_points {
*control_point = transform_affine * (*control_point);
}
all_curves.push(segment);
segment_index += 1;
curves_in_shape += 1;
}
current_point = subpath_start;
}
}
}
println!(" Shape {}: Extracted {} curves", shape_idx, curves_in_shape);
}
}
all_curves
}
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::Shape;
use vello::kurbo::{Rect, Shape as KurboShape};
#[test]
fn test_paint_bucket_action_basic() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Layer 1");
// Create a simple rectangle shape (boundary for fill)
let rect = Rect::new(0.0, 0.0, 100.0, 100.0);
let path = rect.to_path(0.1);
let shape = Shape::new(path);
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
// Create and execute paint bucket action
let mut action = PaintBucketAction::new(
layer_id,
0.0,
Point::new(50.0, 50.0),
ShapeColor::rgb(255, 0, 0),
2.0,
GapHandlingMode::BridgeSegment,
);
action.execute(&mut document).unwrap();
// Verify a filled shape was created (or existing shape was recolored)
if let Some(AnyLayer::Vector(layer)) = document.get_layer(&layer_id) {
assert!(layer.shapes_at_time(0.0).len() >= 1);
} else {
panic!("Layer not found or not a vector layer");
}
// Test rollback
action.rollback(&mut document).unwrap();
}
#[test]
fn test_paint_bucket_action_description() {
let action = PaintBucketAction::new(
Uuid::new_v4(),
0.0,
Point::ZERO,
ShapeColor::rgb(0, 0, 255),
2.0,
GapHandlingMode::BridgeSegment,
);
assert_eq!(action.description(), "Paint bucket fill");
}
}

93
lightningbeam-ui/lightningbeam-core/src/actions/region_split.rs
View File

@ -1,119 +1,42 @@
//! Region split action //! Region split action — STUB: needs DCEL rewrite
//!
//! Commits a temporary region-based shape split permanently.
//! Replaces original shapes with their inside and outside portions.
use crate::action::Action; use crate::action::Action;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer;
use crate::shape::Shape; use crate::shape::Shape;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::BezPath; use vello::kurbo::BezPath;
/// One shape split entry for the action /// Action that commits a region split
#[derive(Clone, Debug)] /// TODO: Rewrite for DCEL edge splitting
struct SplitEntry {
/// The original shape (for rollback)
original_shape: Shape,
/// The inside portion shape
inside_shape: Shape,
/// The outside portion shape
outside_shape: Shape,
}
/// Action that commits a region split — replacing original shapes with
/// their inside and outside portions.
pub struct RegionSplitAction { pub struct RegionSplitAction {
layer_id: Uuid, layer_id: Uuid,
time: f64, time: f64,
splits: Vec<SplitEntry>,
} }
impl RegionSplitAction { impl RegionSplitAction {
/// Create a new region split action.
///
/// Each tuple is (original_shape, inside_path, inside_id, outside_path, outside_id).
pub fn new( pub fn new(
layer_id: Uuid, layer_id: Uuid,
time: f64, time: f64,
split_data: Vec<(Shape, BezPath, Uuid, BezPath, Uuid)>, _split_data: Vec<(Shape, BezPath, Uuid, BezPath, Uuid)>,
) -> Self { ) -> Self {
let splits = split_data
.into_iter()
.map(|(original, inside_path, inside_id, outside_path, outside_id)| {
let mut inside_shape = original.clone();
inside_shape.id = inside_id;
inside_shape.versions[0].path = inside_path;
let mut outside_shape = original.clone();
outside_shape.id = outside_id;
outside_shape.versions[0].path = outside_path;
SplitEntry {
original_shape: original,
inside_shape,
outside_shape,
}
})
.collect();
Self { Self {
layer_id, layer_id,
time, time,
splits,
} }
} }
} }
impl Action for RegionSplitAction { impl Action for RegionSplitAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = document let _ = (&self.layer_id, self.time);
.get_layer_mut(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vector_layer = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Not a vector layer".to_string()),
};
for split in &self.splits {
// Remove original
vector_layer.remove_shape_from_keyframe(&split.original_shape.id, self.time);
// Add inside and outside portions
vector_layer.add_shape_to_keyframe(split.inside_shape.clone(), self.time);
vector_layer.add_shape_to_keyframe(split.outside_shape.clone(), self.time);
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = document
.get_layer_mut(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vector_layer = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Not a vector layer".to_string()),
};
for split in &self.splits {
// Remove inside and outside portions
vector_layer.remove_shape_from_keyframe(&split.inside_shape.id, self.time);
vector_layer.remove_shape_from_keyframe(&split.outside_shape.id, self.time);
// Restore original
vector_layer.add_shape_to_keyframe(split.original_shape.clone(), self.time);
}
Ok(()) Ok(())
} }
fn description(&self) -> String { fn description(&self) -> String {
let count = self.splits.len(); "Region split".to_string()
if count == 1 {
"Region split shape".to_string()
} else {
format!("Region split {} shapes", count)
}
} }
} }

85
lightningbeam-ui/lightningbeam-core/src/actions/remove_shapes.rs
View File

@ -1,23 +1,15 @@
//! Remove shapes action //! Remove shapes action — STUB: needs DCEL rewrite
//!
//! Handles removing shapes from a vector layer's keyframe (for cut/delete).
use crate::action::Action; use crate::action::Action;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer;
use crate::shape::Shape;
use uuid::Uuid; use uuid::Uuid;
/// Action that removes shapes from a vector layer's keyframe /// Action that removes shapes from a vector layer's keyframe
/// TODO: Replace with DCEL edge/face removal actions
pub struct RemoveShapesAction { pub struct RemoveShapesAction {
/// Layer ID containing the shapes
layer_id: Uuid, layer_id: Uuid,
/// Shape IDs to remove
shape_ids: Vec<Uuid>, shape_ids: Vec<Uuid>,
/// Time of the keyframe
time: f64, time: f64,
/// Saved shapes for rollback
saved_shapes: Vec<Shape>,
} }
impl RemoveShapesAction { impl RemoveShapesAction {
@ -26,47 +18,17 @@ impl RemoveShapesAction {
layer_id, layer_id,
shape_ids, shape_ids,
time, time,
saved_shapes: Vec::new(),
} }
} }
} }
impl Action for RemoveShapesAction { impl Action for RemoveShapesAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
self.saved_shapes.clear(); let _ = (&self.layer_id, &self.shape_ids, self.time);
let layer = document
.get_layer_mut(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vector_layer = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Not a vector layer".to_string()),
};
for shape_id in &self.shape_ids {
if let Some(shape) = vector_layer.remove_shape_from_keyframe(shape_id, self.time) {
self.saved_shapes.push(shape);
}
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
let layer = document
.get_layer_mut(&self.layer_id)
.ok_or_else(|| format!("Layer {} not found", self.layer_id))?;
let vector_layer = match layer {
AnyLayer::Vector(vl) => vl,
_ => return Err("Not a vector layer".to_string()),
};
for shape in self.saved_shapes.drain(..) {
vector_layer.add_shape_to_keyframe(shape, self.time);
}
Ok(()) Ok(())
} }
@ -79,40 +41,3 @@ impl Action for RemoveShapesAction {
} }
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::Shape;
use vello::kurbo::BezPath;
#[test]
fn test_remove_shapes() {
let mut document = Document::new("Test");
let mut vector_layer = VectorLayer::new("Layer 1");
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((100.0, 100.0));
let shape = Shape::new(path);
let shape_id = shape.id;
vector_layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(vector_layer));
let mut action = RemoveShapesAction::new(layer_id, vec![shape_id], 0.0);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert!(vl.shapes_at_time(0.0).is_empty());
}
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.shapes_at_time(0.0).len(), 1);
}
}
}

228
lightningbeam-ui/lightningbeam-core/src/actions/set_instance_properties.rs
View File

@ -1,12 +1,7 @@
//! Set shape instance properties action //! Set shape instance properties action — STUB: needs DCEL rewrite
//!
//! Handles changing individual properties on shapes (position, rotation, scale, etc.)
//! with undo/redo support. In the keyframe model, these operate on Shape's transform
//! and opacity fields within the active keyframe.
use crate::action::Action; use crate::action::Action;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer;
use uuid::Uuid; use uuid::Uuid;
/// Individual property change for a shape instance /// Individual property change for a shape instance
@ -23,8 +18,7 @@ pub enum InstancePropertyChange {
} }
impl InstancePropertyChange { impl InstancePropertyChange {
/// Extract the f64 value from any variant pub fn value(&self) -> f64 {
fn value(&self) -> f64 {
match self { match self {
InstancePropertyChange::X(v) => *v, InstancePropertyChange::X(v) => *v,
InstancePropertyChange::Y(v) => *v, InstancePropertyChange::Y(v) => *v,
@ -39,22 +33,15 @@ impl InstancePropertyChange {
} }
/// Action that sets a property on one or more shapes in a keyframe /// Action that sets a property on one or more shapes in a keyframe
/// TODO: Replace with DCEL-based property changes
pub struct SetInstancePropertiesAction { pub struct SetInstancePropertiesAction {
/// Layer containing the shapes
layer_id: Uuid, layer_id: Uuid,
/// Time of the keyframe
time: f64, time: f64,
/// Shape IDs to modify and their old values
shape_changes: Vec<(Uuid, Option<f64>)>, shape_changes: Vec<(Uuid, Option<f64>)>,
/// Property to change
property: InstancePropertyChange, property: InstancePropertyChange,
} }
impl SetInstancePropertiesAction { impl SetInstancePropertiesAction {
/// Create a new action to set a property on a single shape
pub fn new(layer_id: Uuid, time: f64, shape_id: Uuid, property: InstancePropertyChange) -> Self { pub fn new(layer_id: Uuid, time: f64, shape_id: Uuid, property: InstancePropertyChange) -> Self {
Self { Self {
layer_id, layer_id,
@ -64,7 +51,6 @@ impl SetInstancePropertiesAction {
} }
} }
/// Create a new action to set a property on multiple shapes
pub fn new_batch(layer_id: Uuid, time: f64, shape_ids: Vec<Uuid>, property: InstancePropertyChange) -> Self { pub fn new_batch(layer_id: Uuid, time: f64, shape_ids: Vec<Uuid>, property: InstancePropertyChange) -> Self {
Self { Self {
layer_id, layer_id,
@ -73,76 +59,15 @@ impl SetInstancePropertiesAction {
property, property,
} }
} }
fn get_value_from_shape(shape: &crate::shape::Shape, property: &InstancePropertyChange) -> f64 {
match property {
InstancePropertyChange::X(_) => shape.transform.x,
InstancePropertyChange::Y(_) => shape.transform.y,
InstancePropertyChange::Rotation(_) => shape.transform.rotation,
InstancePropertyChange::ScaleX(_) => shape.transform.scale_x,
InstancePropertyChange::ScaleY(_) => shape.transform.scale_y,
InstancePropertyChange::SkewX(_) => shape.transform.skew_x,
InstancePropertyChange::SkewY(_) => shape.transform.skew_y,
InstancePropertyChange::Opacity(_) => shape.opacity,
}
}
fn set_value_on_shape(shape: &mut crate::shape::Shape, property: &InstancePropertyChange, value: f64) {
match property {
InstancePropertyChange::X(_) => shape.transform.x = value,
InstancePropertyChange::Y(_) => shape.transform.y = value,
InstancePropertyChange::Rotation(_) => shape.transform.rotation = value,
InstancePropertyChange::ScaleX(_) => shape.transform.scale_x = value,
InstancePropertyChange::ScaleY(_) => shape.transform.scale_y = value,
InstancePropertyChange::SkewX(_) => shape.transform.skew_x = value,
InstancePropertyChange::SkewY(_) => shape.transform.skew_y = value,
InstancePropertyChange::Opacity(_) => shape.opacity = value,
}
}
} }
impl Action for SetInstancePropertiesAction { impl Action for SetInstancePropertiesAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
let new_value = self.property.value(); let _ = (&self.layer_id, self.time, &self.shape_changes, &self.property);
// First pass: collect old values
if let Some(layer) = document.get_layer(&self.layer_id) {
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, old_value) in &mut self.shape_changes {
if old_value.is_none() {
if let Some(shape) = vector_layer.get_shape_in_keyframe(shape_id, self.time) {
*old_value = Some(Self::get_value_from_shape(shape, &self.property));
}
}
}
}
}
// Second pass: apply new values
if let Some(layer) = document.get_layer_mut(&self.layer_id) {
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, _) in &self.shape_changes {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(shape_id, self.time) {
Self::set_value_on_shape(shape, &self.property, new_value);
}
}
}
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
if let Some(layer) = document.get_layer_mut(&self.layer_id) {
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, old_value) in &self.shape_changes {
if let Some(value) = old_value {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(shape_id, self.time) {
Self::set_value_on_shape(shape, &self.property, *value);
}
}
}
}
}
Ok(()) Ok(())
} }
@ -165,144 +90,3 @@ impl Action for SetInstancePropertiesAction {
} }
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::Shape;
use vello::kurbo::BezPath;
fn make_shape_at(x: f64, y: f64) -> Shape {
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((10.0, 10.0));
Shape::new(path).with_position(x, y)
}
#[test]
fn test_set_x_position() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape = make_shape_at(10.0, 20.0);
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let mut action = SetInstancePropertiesAction::new(
layer_id,
0.0,
shape_id,
InstancePropertyChange::X(50.0),
);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let s = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(s.transform.x, 50.0);
assert_eq!(s.transform.y, 20.0);
}
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let s = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(s.transform.x, 10.0);
}
}
#[test]
fn test_set_opacity() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape = make_shape_at(0.0, 0.0);
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let mut action = SetInstancePropertiesAction::new(
layer_id,
0.0,
shape_id,
InstancePropertyChange::Opacity(0.5),
);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let s = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(s.opacity, 0.5);
}
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let s = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(s.opacity, 1.0);
}
}
#[test]
fn test_batch_set_scale() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape1 = make_shape_at(0.0, 0.0);
let shape1_id = shape1.id;
let shape2 = make_shape_at(10.0, 10.0);
let shape2_id = shape2.id;
layer.add_shape_to_keyframe(shape1, 0.0);
layer.add_shape_to_keyframe(shape2, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let mut action = SetInstancePropertiesAction::new_batch(
layer_id,
0.0,
vec![shape1_id, shape2_id],
InstancePropertyChange::ScaleX(2.0),
);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.get_shape_in_keyframe(&shape1_id, 0.0).unwrap().transform.scale_x, 2.0);
assert_eq!(vl.get_shape_in_keyframe(&shape2_id, 0.0).unwrap().transform.scale_x, 2.0);
}
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
assert_eq!(vl.get_shape_in_keyframe(&shape1_id, 0.0).unwrap().transform.scale_x, 1.0);
assert_eq!(vl.get_shape_in_keyframe(&shape2_id, 0.0).unwrap().transform.scale_x, 1.0);
}
}
#[test]
fn test_description() {
let layer_id = Uuid::new_v4();
let shape_id = Uuid::new_v4();
let action1 = SetInstancePropertiesAction::new(
layer_id, 0.0, shape_id,
InstancePropertyChange::X(0.0),
);
assert_eq!(action1.description(), "Set X position");
let action2 = SetInstancePropertiesAction::new(
layer_id, 0.0, shape_id,
InstancePropertyChange::Rotation(0.0),
);
assert_eq!(action2.description(), "Set rotation");
let action3 = SetInstancePropertiesAction::new_batch(
layer_id, 0.0,
vec![Uuid::new_v4(), Uuid::new_v4()],
InstancePropertyChange::Opacity(1.0),
);
assert_eq!(action3.description(), "Set opacity on 2 shapes");
}
}

197
lightningbeam-ui/lightningbeam-core/src/actions/set_shape_properties.rs
View File

@ -1,12 +1,8 @@
//! Set shape properties action //! Set shape properties action — STUB: needs DCEL rewrite
//!
//! Handles changing shape properties (fill color, stroke color, stroke width)
//! with undo/redo support.
use crate::action::Action; use crate::action::Action;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer; use crate::shape::ShapeColor;
use crate::shape::{ShapeColor, StrokeStyle};
use uuid::Uuid; use uuid::Uuid;
/// Property change for a shape /// Property change for a shape
@ -18,25 +14,16 @@ pub enum ShapePropertyChange {
} }
/// Action that sets properties on a shape /// Action that sets properties on a shape
/// TODO: Replace with DCEL face/edge property changes
pub struct SetShapePropertiesAction { pub struct SetShapePropertiesAction {
/// Layer containing the shape
layer_id: Uuid, layer_id: Uuid,
/// Shape to modify
shape_id: Uuid, shape_id: Uuid,
/// Time of the keyframe containing the shape
time: f64, time: f64,
/// New property value
new_value: ShapePropertyChange, new_value: ShapePropertyChange,
/// Old property value (stored after first execution)
old_value: Option<ShapePropertyChange>, old_value: Option<ShapePropertyChange>,
} }
impl SetShapePropertiesAction { impl SetShapePropertiesAction {
/// Create a new action to set a property on a shape
pub fn new(layer_id: Uuid, shape_id: Uuid, time: f64, new_value: ShapePropertyChange) -> Self { pub fn new(layer_id: Uuid, shape_id: Uuid, time: f64, new_value: ShapePropertyChange) -> Self {
Self { Self {
layer_id, layer_id,
@ -47,85 +34,27 @@ impl SetShapePropertiesAction {
} }
} }
/// Create action to set fill color
pub fn set_fill_color(layer_id: Uuid, shape_id: Uuid, time: f64, color: Option<ShapeColor>) -> Self { pub fn set_fill_color(layer_id: Uuid, shape_id: Uuid, time: f64, color: Option<ShapeColor>) -> Self {
Self::new(layer_id, shape_id, time, ShapePropertyChange::FillColor(color)) Self::new(layer_id, shape_id, time, ShapePropertyChange::FillColor(color))
} }
/// Create action to set stroke color
pub fn set_stroke_color(layer_id: Uuid, shape_id: Uuid, time: f64, color: Option<ShapeColor>) -> Self { pub fn set_stroke_color(layer_id: Uuid, shape_id: Uuid, time: f64, color: Option<ShapeColor>) -> Self {
Self::new(layer_id, shape_id, time, ShapePropertyChange::StrokeColor(color)) Self::new(layer_id, shape_id, time, ShapePropertyChange::StrokeColor(color))
} }
/// Create action to set stroke width
pub fn set_stroke_width(layer_id: Uuid, shape_id: Uuid, time: f64, width: f64) -> Self { pub fn set_stroke_width(layer_id: Uuid, shape_id: Uuid, time: f64, width: f64) -> Self {
Self::new(layer_id, shape_id, time, ShapePropertyChange::StrokeWidth(width)) Self::new(layer_id, shape_id, time, ShapePropertyChange::StrokeWidth(width))
} }
} }
fn apply_property(shape: &mut crate::shape::Shape, change: &ShapePropertyChange) {
match change {
ShapePropertyChange::FillColor(color) => {
shape.fill_color = *color;
}
ShapePropertyChange::StrokeColor(color) => {
shape.stroke_color = *color;
}
ShapePropertyChange::StrokeWidth(width) => {
if let Some(ref mut style) = shape.stroke_style {
style.width = *width;
} else {
shape.stroke_style = Some(StrokeStyle {
width: *width,
..Default::default()
});
}
}
}
}
impl Action for SetShapePropertiesAction { impl Action for SetShapePropertiesAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
if let Some(layer) = document.get_layer_mut(&self.layer_id) { let _ = (&self.layer_id, &self.shape_id, self.time, &self.new_value);
if let AnyLayer::Vector(vector_layer) = layer {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(&self.shape_id, self.time) {
// Store old value if not already stored
if self.old_value.is_none() {
self.old_value = Some(match &self.new_value {
ShapePropertyChange::FillColor(_) => {
ShapePropertyChange::FillColor(shape.fill_color)
}
ShapePropertyChange::StrokeColor(_) => {
ShapePropertyChange::StrokeColor(shape.stroke_color)
}
ShapePropertyChange::StrokeWidth(_) => {
let width = shape
.stroke_style
.as_ref()
.map(|s| s.width)
.unwrap_or(1.0);
ShapePropertyChange::StrokeWidth(width)
}
});
}
apply_property(shape, &self.new_value);
}
}
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
if let Some(old_value) = &self.old_value.clone() { let _ = &self.old_value;
if let Some(layer) = document.get_layer_mut(&self.layer_id) {
if let AnyLayer::Vector(vector_layer) = layer {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(&self.shape_id, self.time) {
apply_property(shape, old_value);
}
}
}
}
Ok(()) Ok(())
} }
@ -137,115 +66,3 @@ impl Action for SetShapePropertiesAction {
} }
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::Shape;
use vello::kurbo::BezPath;
fn create_test_shape() -> Shape {
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((100.0, 0.0));
path.line_to((100.0, 100.0));
path.line_to((0.0, 100.0));
path.close_path();
let mut shape = Shape::new(path);
shape.fill_color = Some(ShapeColor::rgb(255, 0, 0));
shape.stroke_color = Some(ShapeColor::rgb(0, 0, 0));
shape.stroke_style = Some(StrokeStyle {
width: 2.0,
..Default::default()
});
shape
}
#[test]
fn test_set_fill_color() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape = create_test_shape();
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
// Verify initial color
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(shape.fill_color.unwrap().r, 255);
}
// Create and execute action
let new_color = Some(ShapeColor::rgb(0, 255, 0));
let mut action = SetShapePropertiesAction::set_fill_color(layer_id, shape_id, 0.0, new_color);
action.execute(&mut document).unwrap();
// Verify color changed
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(shape.fill_color.unwrap().g, 255);
}
// Rollback
action.rollback(&mut document).unwrap();
// Verify restored
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(shape.fill_color.unwrap().r, 255);
}
}
#[test]
fn test_set_stroke_width() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let shape = create_test_shape();
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
// Create and execute action
let mut action = SetShapePropertiesAction::set_stroke_width(layer_id, shape_id, 0.0, 5.0);
action.execute(&mut document).unwrap();
// Verify width changed
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(shape.stroke_style.as_ref().unwrap().width, 5.0);
}
// Rollback
action.rollback(&mut document).unwrap();
// Verify restored
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let shape = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(shape.stroke_style.as_ref().unwrap().width, 2.0);
}
}
#[test]
fn test_description() {
let layer_id = Uuid::new_v4();
let shape_id = Uuid::new_v4();
let action1 =
SetShapePropertiesAction::set_fill_color(layer_id, shape_id, 0.0, Some(ShapeColor::rgb(0, 0, 0)));
assert_eq!(action1.description(), "Set fill color");
let action2 =
SetShapePropertiesAction::set_stroke_color(layer_id, shape_id, 0.0, Some(ShapeColor::rgb(0, 0, 0)));
assert_eq!(action2.description(), "Set stroke color");
let action3 = SetShapePropertiesAction::set_stroke_width(layer_id, shape_id, 0.0, 3.0);
assert_eq!(action3.description(), "Set stroke width");
}
}

75
lightningbeam-ui/lightningbeam-core/src/actions/transform_objects.rs
View File

@ -1,19 +1,16 @@
//! Transform shapes action //! Transform shapes action — STUB: needs DCEL rewrite
//!
//! Applies scale, rotation, and other transformations to shapes in a keyframe.
use crate::action::Action; use crate::action::Action;
use crate::document::Document; use crate::document::Document;
use crate::layer::AnyLayer;
use crate::object::Transform; use crate::object::Transform;
use std::collections::HashMap; use std::collections::HashMap;
use uuid::Uuid; use uuid::Uuid;
/// Action to transform multiple shapes in a keyframe /// Action to transform multiple shapes in a keyframe
/// TODO: Replace with DCEL-based transforms (affine on vertices/edges)
pub struct TransformShapeInstancesAction { pub struct TransformShapeInstancesAction {
layer_id: Uuid, layer_id: Uuid,
time: f64, time: f64,
/// Map of shape ID to (old transform, new transform)
shape_transforms: HashMap<Uuid, (Transform, Transform)>, shape_transforms: HashMap<Uuid, (Transform, Transform)>,
} }
@ -32,29 +29,12 @@ impl TransformShapeInstancesAction {
} }
impl Action for TransformShapeInstancesAction { impl Action for TransformShapeInstancesAction {
fn execute(&mut self, document: &mut Document) -> Result<(), String> { fn execute(&mut self, _document: &mut Document) -> Result<(), String> {
if let Some(layer) = document.get_layer_mut(&self.layer_id) { let _ = (&self.layer_id, self.time, &self.shape_transforms);
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, (_old, new)) in &self.shape_transforms {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(shape_id, self.time) {
shape.transform = new.clone();
}
}
}
}
Ok(()) Ok(())
} }
fn rollback(&mut self, document: &mut Document) -> Result<(), String> { fn rollback(&mut self, _document: &mut Document) -> Result<(), String> {
if let Some(layer) = document.get_layer_mut(&self.layer_id) {
if let AnyLayer::Vector(vector_layer) = layer {
for (shape_id, (old, _new)) in &self.shape_transforms {
if let Some(shape) = vector_layer.get_shape_in_keyframe_mut(shape_id, self.time) {
shape.transform = old.clone();
}
}
}
}
Ok(()) Ok(())
} }
@ -62,48 +42,3 @@ impl Action for TransformShapeInstancesAction {
format!("Transform {} shape(s)", self.shape_transforms.len()) format!("Transform {} shape(s)", self.shape_transforms.len())
} }
} }
#[cfg(test)]
mod tests {
use super::*;
use crate::layer::VectorLayer;
use crate::shape::Shape;
use vello::kurbo::BezPath;
#[test]
fn test_transform_shape() {
let mut document = Document::new("Test");
let mut layer = VectorLayer::new("Test Layer");
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((100.0, 100.0));
let shape = Shape::new(path).with_position(10.0, 20.0);
let shape_id = shape.id;
layer.add_shape_to_keyframe(shape, 0.0);
let layer_id = document.root_mut().add_child(AnyLayer::Vector(layer));
let old_transform = Transform::with_position(10.0, 20.0);
let new_transform = Transform::with_position(100.0, 200.0);
let mut transforms = HashMap::new();
transforms.insert(shape_id, (old_transform, new_transform));
let mut action = TransformShapeInstancesAction::new(layer_id, 0.0, transforms);
action.execute(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let s = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(s.transform.x, 100.0);
assert_eq!(s.transform.y, 200.0);
}
action.rollback(&mut document).unwrap();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
let s = vl.get_shape_in_keyframe(&shape_id, 0.0).unwrap();
assert_eq!(s.transform.x, 10.0);
assert_eq!(s.transform.y, 20.0);
}
}
}

37
lightningbeam-ui/lightningbeam-core/src/clip.rs
View File

@ -17,7 +17,7 @@ use crate::object::Transform;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::path::PathBuf; use std::path::PathBuf;
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::{Rect, Shape as KurboShape}; use vello::kurbo::Rect;
/// Vector clip containing nested layers /// Vector clip containing nested layers
/// ///
@ -167,20 +167,19 @@ impl VectorClip {
for layer_node in self.layers.iter() { for layer_node in self.layers.iter() {
// Only process vector layers (skip other layer types) // Only process vector layers (skip other layer types)
if let AnyLayer::Vector(vector_layer) = &layer_node.data { if let AnyLayer::Vector(vector_layer) = &layer_node.data {
// Calculate bounds for all shapes in the active keyframe // Calculate bounds from DCEL edges
for shape in vector_layer.shapes_at_time(clip_time) { if let Some(dcel) = vector_layer.dcel_at_time(clip_time) {
// Get the local bounding box of the shape's path use kurbo::Shape as KurboShape;
let local_bbox = shape.path().bounding_box(); for edge in &dcel.edges {
if edge.deleted {
// Apply the shape's transform continue;
let shape_transform = shape.transform.to_affine(); }
let transformed_bbox = shape_transform.transform_rect_bbox(local_bbox); let edge_bbox = edge.curve.bounding_box();
combined_bounds = Some(match combined_bounds {
// Union with combined bounds None => edge_bbox,
combined_bounds = Some(match combined_bounds { Some(existing) => existing.union(edge_bbox),
None => transformed_bbox, });
Some(existing) => existing.union(transformed_bbox), }
});
} }
// Handle nested clip instances recursively // Handle nested clip instances recursively
@ -847,11 +846,13 @@ mod tests {
#[test] #[test]
fn test_audio_clip_midi() { fn test_audio_clip_midi() {
let events = vec![MidiEvent::note_on(0.0, 0, 60, 100)]; let clip = AudioClip::new_midi("Piano Melody", 1, 60.0);
let clip = AudioClip::new_midi("Piano Melody", 60.0, events.clone(), false);
assert_eq!(clip.name, "Piano Melody"); assert_eq!(clip.name, "Piano Melody");
assert_eq!(clip.duration, 60.0); assert_eq!(clip.duration, 60.0);
assert_eq!(clip.midi_events().map(|e| e.len()), Some(1)); match &clip.clip_type {
AudioClipType::Midi { midi_clip_id } => assert_eq!(*midi_clip_id, 1),
_ => panic!("Expected Midi clip type"),
}
} }
#[test] #[test]

1740
lightningbeam-ui/lightningbeam-core/src/dcel.rs Normal file
View File

File diff suppressed because it is too large Load Diff

281
lightningbeam-ui/lightningbeam-core/src/hit_test.rs
View File

@ -4,9 +4,9 @@
//! shapes and objects, taking into account transform hierarchies. //! shapes and objects, taking into account transform hierarchies.
use crate::clip::ClipInstance; use crate::clip::ClipInstance;
use crate::dcel::{VertexId, EdgeId, FaceId};
use crate::layer::VectorLayer; use crate::layer::VectorLayer;
use crate::region_select; use crate::shape::Shape; // TODO: remove after DCEL migration complete
use crate::shape::Shape;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use uuid::Uuid; use uuid::Uuid;
use vello::kurbo::{Affine, BezPath, Point, Rect, Shape as KurboShape}; use vello::kurbo::{Affine, BezPath, Point, Rect, Shape as KurboShape};
@ -36,21 +36,13 @@ pub enum HitResult {
/// ///
/// The UUID of the first shape hit, or None if no hit /// The UUID of the first shape hit, or None if no hit
pub fn hit_test_layer( pub fn hit_test_layer(
layer: &VectorLayer, _layer: &VectorLayer,
time: f64, _time: f64,
point: Point, _point: Point,
tolerance: f64, _tolerance: f64,
parent_transform: Affine, _parent_transform: Affine,
) -> Option<Uuid> { ) -> Option<Uuid> {
// Test shapes in reverse order (front to back for hit testing) // TODO: Implement DCEL-based hit testing (faces, edges, vertices)
for shape in layer.shapes_at_time(time).iter().rev() {
let combined_transform = parent_transform * shape.transform.to_affine();
if hit_test_shape(shape, point, tolerance, combined_transform) {
return Some(shape.id);
}
}
None None
} }
@ -95,29 +87,13 @@ pub fn hit_test_shape(
/// ///
/// Returns all shapes in the active keyframe whose bounding boxes intersect with the given rectangle. /// Returns all shapes in the active keyframe whose bounding boxes intersect with the given rectangle.
pub fn hit_test_objects_in_rect( pub fn hit_test_objects_in_rect(
layer: &VectorLayer, _layer: &VectorLayer,
time: f64, _time: f64,
rect: Rect, _rect: Rect,
parent_transform: Affine, _parent_transform: Affine,
) -> Vec<Uuid> { ) -> Vec<Uuid> {
let mut hits = Vec::new(); // TODO: Implement DCEL-based marquee selection
Vec::new()
for shape in layer.shapes_at_time(time) {
let combined_transform = parent_transform * shape.transform.to_affine();
// Get shape bounding box in local space
let bbox = shape.path().bounding_box();
// Transform bounding box to screen space
let transformed_bbox = combined_transform.transform_rect_bbox(bbox);
// Check if rectangles intersect
if rect.intersect(transformed_bbox).area() > 0.0 {
hits.push(shape.id);
}
}
hits
} }
/// Classification of shapes relative to a clipping region /// Classification of shapes relative to a clipping region
@ -141,7 +117,7 @@ pub fn classify_shapes_by_region(
region: &BezPath, region: &BezPath,
parent_transform: Affine, parent_transform: Affine,
) -> ShapeRegionClassification { ) -> ShapeRegionClassification {
let mut result = ShapeRegionClassification { let result = ShapeRegionClassification {
fully_inside: Vec::new(), fully_inside: Vec::new(),
intersecting: Vec::new(), intersecting: Vec::new(),
fully_outside: Vec::new(), fully_outside: Vec::new(),
@ -149,33 +125,8 @@ pub fn classify_shapes_by_region(
let region_bbox = region.bounding_box(); let region_bbox = region.bounding_box();
for shape in layer.shapes_at_time(time) { // TODO: Implement DCEL-based region classification
let combined_transform = parent_transform * shape.transform.to_affine(); let _ = (layer, time, parent_transform, region_bbox);
let bbox = shape.path().bounding_box();
let transformed_bbox = combined_transform.transform_rect_bbox(bbox);
// Fast rejection: if bounding boxes don't overlap, fully outside
if region_bbox.intersect(transformed_bbox).area() <= 0.0 {
result.fully_outside.push(shape.id);
continue;
}
// Transform the shape path to world space for accurate testing
let world_path = {
let mut p = shape.path().clone();
p.apply_affine(combined_transform);
p
};
// Check if the path crosses the region boundary
if region_select::path_intersects_region(&world_path, region) {
result.intersecting.push(shape.id);
} else if region_select::path_fully_inside_region(&world_path, region) {
result.fully_inside.push(shape.id);
} else {
result.fully_outside.push(shape.id);
}
}
result result
} }
@ -300,23 +251,22 @@ pub fn hit_test_clip_instances_in_rect(
pub enum VectorEditHit { pub enum VectorEditHit {
/// Hit a control point (BezierEdit tool only) /// Hit a control point (BezierEdit tool only)
ControlPoint { ControlPoint {
shape_instance_id: Uuid, edge_id: EdgeId,
curve_index: usize, point_index: u8, // 1 = p1, 2 = p2
point_index: u8,
}, },
/// Hit a vertex (anchor point) /// Hit a vertex (anchor point)
Vertex { Vertex {
shape_instance_id: Uuid, vertex_id: VertexId,
vertex_index: usize,
}, },
/// Hit a curve segment /// Hit a curve segment
Curve { Curve {
shape_instance_id: Uuid, edge_id: EdgeId,
curve_index: usize,
parameter_t: f64, parameter_t: f64,
}, },
/// Hit shape fill /// Hit shape fill
Fill { shape_instance_id: Uuid }, Fill {
face_id: FaceId,
},
} }
/// Tolerances for vector editing hit testing (in screen pixels) /// Tolerances for vector editing hit testing (in screen pixels)
@ -359,83 +309,79 @@ pub fn hit_test_vector_editing(
parent_transform: Affine, parent_transform: Affine,
show_control_points: bool, show_control_points: bool,
) -> Option<VectorEditHit> { ) -> Option<VectorEditHit> {
use crate::bezpath_editing::extract_editable_curves; use kurbo::ParamCurveNearest;
use vello::kurbo::{ParamCurve, ParamCurveNearest};
// Test shapes in reverse order (front to back for hit testing) let dcel = layer.dcel_at_time(time)?;
for shape in layer.shapes_at_time(time).iter().rev() {
let combined_transform = parent_transform * shape.transform.to_affine();
let inverse_transform = combined_transform.inverse();
let local_point = inverse_transform * point;
// Calculate the scale factor to transform screen-space tolerances to local space // Transform point into layer-local space
let coeffs = combined_transform.as_coeffs(); let local_point = parent_transform.inverse() * point;
let scale_x = (coeffs[0].powi(2) + coeffs[1].powi(2)).sqrt();
let scale_y = (coeffs[2].powi(2) + coeffs[3].powi(2)).sqrt();
let avg_scale = (scale_x + scale_y) / 2.0;
let local_tolerance_factor = 1.0 / avg_scale.max(0.001);
let editable = extract_editable_curves(shape.path()); // Priority: ControlPoint > Vertex > Curve
// Priority 1: Control points (only in BezierEdit mode) // 1. Control points (only when show_control_points is true, e.g. BezierEdit tool)
if show_control_points { if show_control_points {
let local_cp_tolerance = tolerance.control_point * local_tolerance_factor; let mut best_cp: Option<(EdgeId, u8, f64)> = None;
for (i, curve) in editable.curves.iter().enumerate() { for (i, edge) in dcel.edges.iter().enumerate() {
let dist_p1 = (curve.p1 - local_point).hypot(); if edge.deleted {
if dist_p1 < local_cp_tolerance { continue;
return Some(VectorEditHit::ControlPoint { }
shape_instance_id: shape.id, let edge_id = EdgeId(i as u32);
curve_index: i, // Check p1
point_index: 1, let d1 = local_point.distance(edge.curve.p1);
}); if d1 < tolerance.control_point {
if best_cp.is_none() || d1 < best_cp.unwrap().2 {
best_cp = Some((edge_id, 1, d1));
} }
}
let dist_p2 = (curve.p2 - local_point).hypot(); // Check p2
if dist_p2 < local_cp_tolerance { let d2 = local_point.distance(edge.curve.p2);
return Some(VectorEditHit::ControlPoint { if d2 < tolerance.control_point {
shape_instance_id: shape.id, if best_cp.is_none() || d2 < best_cp.unwrap().2 {
curve_index: i, best_cp = Some((edge_id, 2, d2));
point_index: 2,
});
} }
} }
} }
if let Some((edge_id, point_index, _)) = best_cp {
// Priority 2: Vertices (anchor points) return Some(VectorEditHit::ControlPoint { edge_id, point_index });
let local_vertex_tolerance = tolerance.vertex * local_tolerance_factor;
for (i, vertex) in editable.vertices.iter().enumerate() {
let dist = (vertex.point - local_point).hypot();
if dist < local_vertex_tolerance {
return Some(VectorEditHit::Vertex {
shape_instance_id: shape.id,
vertex_index: i,
});
}
}
// Priority 3: Curves
let local_curve_tolerance = tolerance.curve * local_tolerance_factor;
for (i, curve) in editable.curves.iter().enumerate() {
let nearest = curve.nearest(local_point, 1e-6);
let nearest_point = curve.eval(nearest.t);
let dist = (nearest_point - local_point).hypot();
if dist < local_curve_tolerance {
return Some(VectorEditHit::Curve {
shape_instance_id: shape.id,
curve_index: i,
parameter_t: nearest.t,
});
}
}
// Priority 4: Fill
if shape.fill_color.is_some() && shape.path().contains(local_point) {
return Some(VectorEditHit::Fill {
shape_instance_id: shape.id,
});
} }
} }
// 2. Vertices
let mut best_vertex: Option<(VertexId, f64)> = None;
for (i, vertex) in dcel.vertices.iter().enumerate() {
if vertex.deleted {
continue;
}
let dist = local_point.distance(vertex.position);
if dist < tolerance.vertex {
if best_vertex.is_none() || dist < best_vertex.unwrap().1 {
best_vertex = Some((VertexId(i as u32), dist));
}
}
}
if let Some((vertex_id, _)) = best_vertex {
return Some(VectorEditHit::Vertex { vertex_id });
}
// 3. Curves (edges)
let mut best_curve: Option<(EdgeId, f64, f64)> = None; // (edge_id, t, dist)
for (i, edge) in dcel.edges.iter().enumerate() {
if edge.deleted {
continue;
}
let nearest = edge.curve.nearest(local_point, 0.5);
let dist = nearest.distance_sq.sqrt();
if dist < tolerance.curve {
if best_curve.is_none() || dist < best_curve.unwrap().2 {
best_curve = Some((EdgeId(i as u32), nearest.t, dist));
}
}
}
if let Some((edge_id, parameter_t, _)) = best_curve {
return Some(VectorEditHit::Curve { edge_id, parameter_t });
}
// 4. Face hit testing skipped for now
None None
} }
@ -447,65 +393,16 @@ mod tests {
#[test] #[test]
fn test_hit_test_simple_circle() { fn test_hit_test_simple_circle() {
let mut layer = VectorLayer::new("Test Layer"); // TODO: DCEL - rewrite test
let circle = Circle::new((100.0, 100.0), 50.0);
let path = circle.to_path(0.1);
let shape = Shape::new(path).with_fill(ShapeColor::rgb(255, 0, 0));
layer.add_shape_to_keyframe(shape, 0.0);
// Test hit inside circle
let hit = hit_test_layer(&layer, 0.0, Point::new(100.0, 100.0), 0.0, Affine::IDENTITY);
assert!(hit.is_some());
// Test miss outside circle
let miss = hit_test_layer(&layer, 0.0, Point::new(200.0, 200.0), 0.0, Affine::IDENTITY);
assert!(miss.is_none());
} }
#[test] #[test]
fn test_hit_test_with_transform() { fn test_hit_test_with_transform() {
let mut layer = VectorLayer::new("Test Layer"); // TODO: DCEL - rewrite test
let circle = Circle::new((0.0, 0.0), 50.0);
let path = circle.to_path(0.1);
let shape = Shape::new(path)
.with_fill(ShapeColor::rgb(255, 0, 0))
.with_position(100.0, 100.0);
layer.add_shape_to_keyframe(shape, 0.0);
// Test hit at translated position
let hit = hit_test_layer(&layer, 0.0, Point::new(100.0, 100.0), 0.0, Affine::IDENTITY);
assert!(hit.is_some());
// Test miss at origin (where shape is defined, but transform moves it)
let miss = hit_test_layer(&layer, 0.0, Point::new(0.0, 0.0), 0.0, Affine::IDENTITY);
assert!(miss.is_none());
} }
#[test] #[test]
fn test_marquee_selection() { fn test_marquee_selection() {
let mut layer = VectorLayer::new("Test Layer"); // TODO: DCEL - rewrite test
let circle1 = Circle::new((50.0, 50.0), 20.0);
let shape1 = Shape::new(circle1.to_path(0.1)).with_fill(ShapeColor::rgb(255, 0, 0));
let circle2 = Circle::new((150.0, 150.0), 20.0);
let shape2 = Shape::new(circle2.to_path(0.1)).with_fill(ShapeColor::rgb(0, 255, 0));
layer.add_shape_to_keyframe(shape1, 0.0);
layer.add_shape_to_keyframe(shape2, 0.0);
// Marquee that contains both circles
let rect = Rect::new(0.0, 0.0, 200.0, 200.0);
let hits = hit_test_objects_in_rect(&layer, 0.0, rect, Affine::IDENTITY);
assert_eq!(hits.len(), 2);
// Marquee that contains only first circle
let rect = Rect::new(0.0, 0.0, 100.0, 100.0);
let hits = hit_test_objects_in_rect(&layer, 0.0, rect, Affine::IDENTITY);
assert_eq!(hits.len(), 1);
} }
} }

91
lightningbeam-ui/lightningbeam-core/src/layer.rs
View File

@ -4,6 +4,7 @@
use crate::animation::AnimationData; use crate::animation::AnimationData;
use crate::clip::ClipInstance; use crate::clip::ClipInstance;
use crate::dcel::Dcel;
use crate::effect_layer::EffectLayer; use crate::effect_layer::EffectLayer;
use crate::object::ShapeInstance; use crate::object::ShapeInstance;
use crate::shape::Shape; use crate::shape::Shape;
@ -151,13 +152,13 @@ impl Default for TweenType {
} }
} }
/// A keyframe containing all shapes at a point in time /// A keyframe containing vector artwork as a DCEL planar subdivision.
#[derive(Clone, Debug, Serialize, Deserialize)] #[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ShapeKeyframe { pub struct ShapeKeyframe {
/// Time in seconds /// Time in seconds
pub time: f64, pub time: f64,
/// All shapes at this keyframe /// DCEL planar subdivision containing all vector artwork
pub shapes: Vec<Shape>, pub dcel: Dcel,
/// What happens between this keyframe and the next /// What happens between this keyframe and the next
#[serde(default)] #[serde(default)]
pub tween_after: TweenType, pub tween_after: TweenType,
@ -172,17 +173,7 @@ impl ShapeKeyframe {
pub fn new(time: f64) -> Self { pub fn new(time: f64) -> Self {
Self { Self {
time, time,
shapes: Vec::new(), dcel: Dcel::new(),
tween_after: TweenType::None,
clip_instance_ids: Vec::new(),
}
}
/// Create a keyframe with shapes
pub fn with_shapes(time: f64, shapes: Vec<Shape>) -> Self {
Self {
time,
shapes,
tween_after: TweenType::None, tween_after: TweenType::None,
clip_instance_ids: Vec::new(), clip_instance_ids: Vec::new(),
} }
@ -370,12 +361,14 @@ impl VectorLayer {
self.keyframes.iter().position(|kf| (kf.time - time).abs() < tolerance) self.keyframes.iter().position(|kf| (kf.time - time).abs() < tolerance)
} }
/// Get shapes visible at a given time (from the keyframe at-or-before time) /// Get the DCEL at a given time (from the keyframe at-or-before time)
pub fn shapes_at_time(&self, time: f64) -> &[Shape] { pub fn dcel_at_time(&self, time: f64) -> Option<&Dcel> {
match self.keyframe_at(time) { self.keyframe_at(time).map(|kf| &kf.dcel)
Some(kf) => &kf.shapes, }
None => &[],
} /// Get a mutable DCEL at a given time
pub fn dcel_at_time_mut(&mut self, time: f64) -> Option<&mut Dcel> {
self.keyframe_at_mut(time).map(|kf| &mut kf.dcel)
} }
/// Get the duration of the keyframe span starting at-or-before `time`. /// Get the duration of the keyframe span starting at-or-before `time`.
@ -424,22 +417,10 @@ impl VectorLayer {
time + frame_duration time + frame_duration
} }
/// Get mutable shapes at a given time // Shape-based methods removed — use DCEL methods instead.
pub fn shapes_at_time_mut(&mut self, time: f64) -> Option<&mut Vec<Shape>> { // - shapes_at_time_mut → dcel_at_time_mut
self.keyframe_at_mut(time).map(|kf| &mut kf.shapes) // - get_shape_in_keyframe → use DCEL vertex/edge/face accessors
} // - get_shape_in_keyframe_mut → use DCEL vertex/edge/face accessors
/// Find a shape by ID within the keyframe active at the given time
pub fn get_shape_in_keyframe(&self, shape_id: &Uuid, time: f64) -> Option<&Shape> {
self.keyframe_at(time)
.and_then(|kf| kf.shapes.iter().find(|s| &s.id == shape_id))
}
/// Find a mutable shape by ID within the keyframe active at the given time
pub fn get_shape_in_keyframe_mut(&mut self, shape_id: &Uuid, time: f64) -> Option<&mut Shape> {
self.keyframe_at_mut(time)
.and_then(|kf| kf.shapes.iter_mut().find(|s| &s.id == shape_id))
}
/// Ensure a keyframe exists at the exact time, creating an empty one if needed. /// Ensure a keyframe exists at the exact time, creating an empty one if needed.
/// Returns a mutable reference to the keyframe. /// Returns a mutable reference to the keyframe.
@ -454,8 +435,7 @@ impl VectorLayer {
&mut self.keyframes[insert_idx] &mut self.keyframes[insert_idx]
} }
/// Insert a new keyframe at time by copying shapes from the active keyframe. /// Insert a new keyframe at time by cloning the DCEL from the active keyframe.
/// Shape UUIDs are regenerated (no cross-keyframe identity).
/// If a keyframe already exists at the exact time, does nothing and returns it. /// If a keyframe already exists at the exact time, does nothing and returns it.
pub fn insert_keyframe_from_current(&mut self, time: f64) -> &mut ShapeKeyframe { pub fn insert_keyframe_from_current(&mut self, time: f64) -> &mut ShapeKeyframe {
let tolerance = 0.001; let tolerance = 0.001;
@ -463,45 +443,22 @@ impl VectorLayer {
return &mut self.keyframes[idx]; return &mut self.keyframes[idx];
} }
// Clone shapes and clip instance IDs from the active keyframe // Clone DCEL and clip instance IDs from the active keyframe
let (cloned_shapes, cloned_clip_ids) = self let (cloned_dcel, cloned_clip_ids) = self
.keyframe_at(time) .keyframe_at(time)
.map(|kf| { .map(|kf| {
let shapes: Vec<Shape> = kf.shapes (kf.dcel.clone(), kf.clip_instance_ids.clone())
.iter()
.map(|s| {
let mut new_shape = s.clone();
new_shape.id = Uuid::new_v4();
new_shape
})
.collect();
let clip_ids = kf.clip_instance_ids.clone();
(shapes, clip_ids)
}) })
.unwrap_or_default(); .unwrap_or_else(|| (Dcel::new(), Vec::new()));
let insert_idx = self.keyframes.partition_point(|kf| kf.time < time); let insert_idx = self.keyframes.partition_point(|kf| kf.time < time);
let mut kf = ShapeKeyframe::with_shapes(time, cloned_shapes); let mut kf = ShapeKeyframe::new(time);
kf.dcel = cloned_dcel;
kf.clip_instance_ids = cloned_clip_ids; kf.clip_instance_ids = cloned_clip_ids;
self.keyframes.insert(insert_idx, kf); self.keyframes.insert(insert_idx, kf);
&mut self.keyframes[insert_idx] &mut self.keyframes[insert_idx]
} }
/// Add a shape to the keyframe at the given time.
/// Creates a keyframe if none exists at that time.
pub fn add_shape_to_keyframe(&mut self, shape: Shape, time: f64) {
let kf = self.ensure_keyframe_at(time);
kf.shapes.push(shape);
}
/// Remove a shape from the keyframe at the given time.
/// Returns the removed shape if found.
pub fn remove_shape_from_keyframe(&mut self, shape_id: &Uuid, time: f64) -> Option<Shape> {
let kf = self.keyframe_at_mut(time)?;
let idx = kf.shapes.iter().position(|s| &s.id == shape_id)?;
Some(kf.shapes.remove(idx))
}
/// Remove a keyframe at the exact time (within tolerance). /// Remove a keyframe at the exact time (within tolerance).
/// Returns the removed keyframe if found. /// Returns the removed keyframe if found.
pub(crate) fn remove_keyframe_at(&mut self, time: f64, tolerance: f64) -> Option<ShapeKeyframe> { pub(crate) fn remove_keyframe_at(&mut self, time: f64, tolerance: f64) -> Option<ShapeKeyframe> {

1
lightningbeam-ui/lightningbeam-core/src/lib.rs
View File

@ -44,3 +44,4 @@ pub mod file_io;
pub mod export; pub mod export;
pub mod clipboard; pub mod clipboard;
pub mod region_select; pub mod region_select;
pub mod dcel;

229
lightningbeam-ui/lightningbeam-core/src/renderer.rs
View File

@ -13,7 +13,7 @@ use crate::clip::{ClipInstance, ImageAsset};
use crate::document::Document; use crate::document::Document;
use crate::gpu::BlendMode; use crate::gpu::BlendMode;
use crate::layer::{AnyLayer, LayerTrait, VectorLayer}; use crate::layer::{AnyLayer, LayerTrait, VectorLayer};
use kurbo::{Affine, Shape}; use kurbo::Affine;
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Arc; use std::sync::Arc;
use uuid::Uuid; use uuid::Uuid;
@ -178,7 +178,6 @@ pub fn render_document_for_compositing(
base_transform: Affine, base_transform: Affine,
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
skip_instance_id: Option<uuid::Uuid>,
) -> CompositeRenderResult { ) -> CompositeRenderResult {
let time = document.current_time; let time = document.current_time;
@ -212,7 +211,6 @@ pub fn render_document_for_compositing(
base_transform, base_transform,
image_cache, image_cache,
video_manager, video_manager,
skip_instance_id,
); );
rendered_layers.push(rendered); rendered_layers.push(rendered);
} }
@ -237,7 +235,6 @@ pub fn render_layer_isolated(
base_transform: Affine, base_transform: Affine,
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
skip_instance_id: Option<uuid::Uuid>,
) -> RenderedLayer { ) -> RenderedLayer {
let layer_id = layer.id(); let layer_id = layer.id();
let opacity = layer.opacity() as f32; let opacity = layer.opacity() as f32;
@ -259,9 +256,9 @@ pub fn render_layer_isolated(
1.0, // Full opacity - layer opacity handled in compositing 1.0, // Full opacity - layer opacity handled in compositing
image_cache, image_cache,
video_manager, video_manager,
skip_instance_id,
); );
rendered.has_content = !vector_layer.shapes_at_time(time).is_empty() rendered.has_content = vector_layer.dcel_at_time(time)
.map_or(false, |dcel| !dcel.edges.iter().all(|e| e.deleted) || !dcel.faces.iter().skip(1).all(|f| f.deleted))
|| !vector_layer.clip_instances.is_empty(); || !vector_layer.clip_instances.is_empty();
} }
AnyLayer::Audio(_) => { AnyLayer::Audio(_) => {
@ -306,9 +303,7 @@ fn render_vector_layer_to_scene(
parent_opacity: f64, parent_opacity: f64,
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
skip_instance_id: Option<uuid::Uuid>,
) { ) {
// Render using the existing function but to this isolated scene
render_vector_layer( render_vector_layer(
document, document,
time, time,
@ -318,7 +313,6 @@ fn render_vector_layer_to_scene(
parent_opacity, parent_opacity,
image_cache, image_cache,
video_manager, video_manager,
skip_instance_id,
); );
} }
@ -355,7 +349,7 @@ pub fn render_document(
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
) { ) {
render_document_with_transform(document, scene, Affine::IDENTITY, image_cache, video_manager, None); render_document_with_transform(document, scene, Affine::IDENTITY, image_cache, video_manager);
} }
/// Render a document to a Vello scene with a base transform /// Render a document to a Vello scene with a base transform
@ -366,7 +360,6 @@ pub fn render_document_with_transform(
base_transform: Affine, base_transform: Affine,
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
skip_instance_id: Option<uuid::Uuid>,
) { ) {
// 1. Draw background // 1. Draw background
render_background(document, scene, base_transform); render_background(document, scene, base_transform);
@ -380,10 +373,10 @@ pub fn render_document_with_transform(
for layer in document.visible_layers() { for layer in document.visible_layers() {
if any_soloed { if any_soloed {
if layer.soloed() { if layer.soloed() {
render_layer(document, time, layer, scene, base_transform, 1.0, image_cache, video_manager, skip_instance_id); render_layer(document, time, layer, scene, base_transform, 1.0, image_cache, video_manager);
} }
} else { } else {
render_layer(document, time, layer, scene, base_transform, 1.0, image_cache, video_manager, skip_instance_id); render_layer(document, time, layer, scene, base_transform, 1.0, image_cache, video_manager);
} }
} }
} }
@ -415,11 +408,10 @@ fn render_layer(
parent_opacity: f64, parent_opacity: f64,
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
skip_instance_id: Option<uuid::Uuid>,
) { ) {
match layer { match layer {
AnyLayer::Vector(vector_layer) => { AnyLayer::Vector(vector_layer) => {
render_vector_layer(document, time, vector_layer, scene, base_transform, parent_opacity, image_cache, video_manager, skip_instance_id) render_vector_layer(document, time, vector_layer, scene, base_transform, parent_opacity, image_cache, video_manager)
} }
AnyLayer::Audio(_) => { AnyLayer::Audio(_) => {
// Audio layers don't render visually // Audio layers don't render visually
@ -620,7 +612,7 @@ fn render_clip_instance(
if !layer_node.data.visible() { if !layer_node.data.visible() {
continue; continue;
} }
render_layer(document, clip_time, &layer_node.data, scene, instance_transform, clip_opacity, image_cache, video_manager, None); render_layer(document, clip_time, &layer_node.data, scene, instance_transform, clip_opacity, image_cache, video_manager);
} }
} }
@ -792,6 +784,89 @@ fn render_video_layer(
} }
/// Render a vector layer with all its clip instances and shape instances /// Render a vector layer with all its clip instances and shape instances
/// Render a DCEL to a Vello scene.
///
/// Walks faces for fills and edges for strokes.
pub fn render_dcel(
dcel: &crate::dcel::Dcel,
scene: &mut Scene,
base_transform: Affine,
layer_opacity: f64,
document: &Document,
image_cache: &mut ImageCache,
) {
let opacity_f32 = layer_opacity as f32;
// 1. Render faces (fills)
for (i, face) in dcel.faces.iter().enumerate() {
if face.deleted || i == 0 {
continue; // Skip unbounded face and deleted faces
}
if face.fill_color.is_none() && face.image_fill.is_none() {
continue; // No fill to render
}
let face_id = crate::dcel::FaceId(i as u32);
let path = dcel.face_to_bezpath_with_holes(face_id);
let fill_rule: Fill = face.fill_rule.into();
let mut filled = false;
// Image fill
if let Some(image_asset_id) = face.image_fill {
if let Some(image_asset) = document.get_image_asset(&image_asset_id) {
if let Some(image) = image_cache.get_or_decode(image_asset) {
let image_with_alpha = (*image).clone().with_alpha(opacity_f32);
scene.fill(fill_rule, base_transform, &image_with_alpha, None, &path);
filled = true;
}
}
}
// Color fill
if !filled {
if let Some(fill_color) = &face.fill_color {
let alpha = ((fill_color.a as f32 / 255.0) * opacity_f32 * 255.0) as u8;
let adjusted = crate::shape::ShapeColor::rgba(
fill_color.r,
fill_color.g,
fill_color.b,
alpha,
);
scene.fill(fill_rule, base_transform, adjusted.to_peniko(), None, &path);
}
}
}
// 2. Render edges (strokes)
for edge in &dcel.edges {
if edge.deleted {
continue;
}
if let (Some(stroke_color), Some(stroke_style)) = (&edge.stroke_color, &edge.stroke_style) {
let alpha = ((stroke_color.a as f32 / 255.0) * opacity_f32 * 255.0) as u8;
let adjusted = crate::shape::ShapeColor::rgba(
stroke_color.r,
stroke_color.g,
stroke_color.b,
alpha,
);
let mut path = kurbo::BezPath::new();
path.move_to(edge.curve.p0);
path.curve_to(edge.curve.p1, edge.curve.p2, edge.curve.p3);
scene.stroke(
&stroke_style.to_stroke(),
base_transform,
adjusted.to_peniko(),
None,
&path,
);
}
}
}
fn render_vector_layer( fn render_vector_layer(
document: &Document, document: &Document,
time: f64, time: f64,
@ -801,7 +876,6 @@ fn render_vector_layer(
parent_opacity: f64, parent_opacity: f64,
image_cache: &mut ImageCache, image_cache: &mut ImageCache,
video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>, video_manager: &std::sync::Arc<std::sync::Mutex<crate::video::VideoManager>>,
skip_instance_id: Option<uuid::Uuid>,
) { ) {
// Cascade opacity: parent_opacity × layer.opacity // Cascade opacity: parent_opacity × layer.opacity
let layer_opacity = parent_opacity * layer.layer.opacity; let layer_opacity = parent_opacity * layer.layer.opacity;
@ -818,124 +892,9 @@ fn render_vector_layer(
render_clip_instance(document, time, clip_instance, layer_opacity, scene, base_transform, &layer.layer.animation_data, image_cache, video_manager, group_end_time); render_clip_instance(document, time, clip_instance, layer_opacity, scene, base_transform, &layer.layer.animation_data, image_cache, video_manager, group_end_time);
} }
// Render each shape in the active keyframe // Render DCEL from active keyframe
for shape in layer.shapes_at_time(time) { if let Some(dcel) = layer.dcel_at_time(time) {
// Skip this shape if it's being edited render_dcel(dcel, scene, base_transform, layer_opacity, document, image_cache);
if Some(shape.id) == skip_instance_id {
continue;
}
// Use shape's transform directly (keyframe model — no animation evaluation)
let x = shape.transform.x;
let y = shape.transform.y;
let rotation = shape.transform.rotation;
let scale_x = shape.transform.scale_x;
let scale_y = shape.transform.scale_y;
let skew_x = shape.transform.skew_x;
let skew_y = shape.transform.skew_y;
let opacity = shape.opacity;
// Get the path
let path = shape.path();
// Build transform matrix (compose with base transform for camera)
let shape_bbox = path.bounding_box();
let center_x = (shape_bbox.x0 + shape_bbox.x1) / 2.0;
let center_y = (shape_bbox.y0 + shape_bbox.y1) / 2.0;
// Build skew transforms (applied around shape center)
let skew_transform = if skew_x != 0.0 || skew_y != 0.0 {
let skew_x_affine = if skew_x != 0.0 {
let tan_skew = skew_x.to_radians().tan();
Affine::new([1.0, 0.0, tan_skew, 1.0, 0.0, 0.0])
} else {
Affine::IDENTITY
};
let skew_y_affine = if skew_y != 0.0 {
let tan_skew = skew_y.to_radians().tan();
Affine::new([1.0, tan_skew, 0.0, 1.0, 0.0, 0.0])
} else {
Affine::IDENTITY
};
Affine::translate((center_x, center_y))
* skew_x_affine
* skew_y_affine
* Affine::translate((-center_x, -center_y))
} else {
Affine::IDENTITY
};
let object_transform = Affine::translate((x, y))
* Affine::rotate(rotation.to_radians())
* Affine::scale_non_uniform(scale_x, scale_y)
* skew_transform;
let affine = base_transform * object_transform;
// Calculate final opacity (cascaded from parent → layer → shape)
let final_opacity = (layer_opacity * opacity) as f32;
// Determine fill rule
let fill_rule = match shape.fill_rule {
crate::shape::FillRule::NonZero => Fill::NonZero,
crate::shape::FillRule::EvenOdd => Fill::EvenOdd,
};
// Render fill - prefer image fill over color fill
let mut filled = false;
// Check for image fill first
if let Some(image_asset_id) = shape.image_fill {
if let Some(image_asset) = document.get_image_asset(&image_asset_id) {
if let Some(image) = image_cache.get_or_decode(image_asset) {
let image_with_alpha = (*image).clone().with_alpha(final_opacity);
scene.fill(fill_rule, affine, &image_with_alpha, None, &path);
filled = true;
}
}
}
// Fall back to color fill if no image fill (or image failed to load)
if !filled {
if let Some(fill_color) = &shape.fill_color {
let alpha = ((fill_color.a as f32 / 255.0) * final_opacity * 255.0) as u8;
let adjusted_color = crate::shape::ShapeColor::rgba(
fill_color.r,
fill_color.g,
fill_color.b,
alpha,
);
scene.fill(
fill_rule,
affine,
adjusted_color.to_peniko(),
None,
&path,
);
}
}
// Render stroke if present
if let (Some(stroke_color), Some(stroke_style)) = (&shape.stroke_color, &shape.stroke_style)
{
let alpha = ((stroke_color.a as f32 / 255.0) * final_opacity * 255.0) as u8;
let adjusted_color = crate::shape::ShapeColor::rgba(
stroke_color.r,
stroke_color.g,
stroke_color.b,
alpha,
);
scene.stroke(
&stroke_style.to_stroke(),
affine,
adjusted_color.to_peniko(),
None,
&path,
);
}
} }
} }

4
lightningbeam-ui/lightningbeam-core/src/shape.rs
View File

@ -60,7 +60,7 @@ pub enum Cap {
impl Default for Cap { impl Default for Cap {
fn default() -> Self { fn default() -> Self {
Cap::Butt Cap::Round
} }
} }
@ -122,7 +122,7 @@ impl Default for StrokeStyle {
fn default() -> Self { fn default() -> Self {
Self { Self {
width: 1.0, width: 1.0,
cap: Cap::Butt, cap: Cap::Round,
join: Join::Miter, join: Join::Miter,
miter_limit: 4.0, miter_limit: 4.0,
} }

25
lightningbeam-ui/lightningbeam-core/src/tool.rs
View File

@ -116,22 +116,18 @@ pub enum ToolState {
num_sides: u32, // Number of sides (from properties, default 5) num_sides: u32, // Number of sides (from properties, default 5)
}, },
/// Editing a vertex (dragging it and connected curves) /// Editing a vertex (dragging it and connected edges)
EditingVertex { EditingVertex {
shape_id: Uuid, // Which shape is being edited vertex_id: crate::dcel::VertexId,
vertex_index: usize, // Which vertex in the vertices array connected_edges: Vec<crate::dcel::EdgeId>, // edges to update when vertex moves
start_pos: Point, // Vertex position when drag started
start_mouse: Point, // Mouse position when drag started
affected_curve_indices: Vec<usize>, // Which curves connect to this vertex
}, },
/// Editing a curve (reshaping with moldCurve algorithm) /// Editing a curve (reshaping with moldCurve algorithm)
EditingCurve { EditingCurve {
shape_id: Uuid, // Which shape is being edited edge_id: crate::dcel::EdgeId,
curve_index: usize, // Which curve in the curves array original_curve: vello::kurbo::CubicBez,
original_curve: vello::kurbo::CubicBez, // The curve when drag started start_mouse: Point,
start_mouse: Point, // Mouse position when drag started parameter_t: f64,
parameter_t: f64, // Parameter where the drag started (0.0-1.0)
}, },
/// Drawing a region selection rectangle /// Drawing a region selection rectangle
@ -147,11 +143,10 @@ pub enum ToolState {
/// Editing a control point (BezierEdit tool only) /// Editing a control point (BezierEdit tool only)
EditingControlPoint { EditingControlPoint {
shape_id: Uuid, // Which shape is being edited edge_id: crate::dcel::EdgeId,
curve_index: usize, // Which curve owns this control point
point_index: u8, // 1 or 2 (p1 or p2 of the cubic bezier) point_index: u8, // 1 or 2 (p1 or p2 of the cubic bezier)
original_curve: vello::kurbo::CubicBez, // The curve when drag started original_curve: vello::kurbo::CubicBez,
start_pos: Point, // Control point position when drag started start_pos: Point,
}, },
} }

8
lightningbeam-ui/lightningbeam-core/tests/clip_workflow_test.rs
View File

@ -20,7 +20,7 @@ fn setup_test_document() -> (Document, Uuid, Uuid, Uuid) {
let mut document = Document::new("Test Project"); let mut document = Document::new("Test Project");
// Create a vector clip // Create a vector clip
let vector_clip = VectorClip::new("Test Clip", 10.0, 1920.0, 1080.0); let vector_clip = VectorClip::new("Test Clip", 1920.0, 1080.0, 10.0);
let clip_id = vector_clip.id; let clip_id = vector_clip.id;
document.vector_clips.insert(clip_id, vector_clip); document.vector_clips.insert(clip_id, vector_clip);
@ -126,7 +126,7 @@ fn test_transform_clip_instance_workflow() {
let mut transforms = HashMap::new(); let mut transforms = HashMap::new();
transforms.insert(instance_id, (old_transform, new_transform)); transforms.insert(instance_id, (old_transform, new_transform));
let mut action = TransformClipInstancesAction::new(layer_id, transforms); let mut action = TransformClipInstancesAction::new(layer_id, 0.0, transforms);
// Execute // Execute
action.execute(&mut document); action.execute(&mut document);
@ -214,7 +214,7 @@ fn test_multiple_clip_instances_workflow() {
let mut document = Document::new("Test Project"); let mut document = Document::new("Test Project");
// Create a vector clip // Create a vector clip
let vector_clip = VectorClip::new("Test Clip", 10.0, 1920.0, 1080.0); let vector_clip = VectorClip::new("Test Clip", 1920.0, 1080.0, 10.0);
let clip_id = vector_clip.id; let clip_id = vector_clip.id;
document.vector_clips.insert(clip_id, vector_clip); document.vector_clips.insert(clip_id, vector_clip);
@ -294,7 +294,7 @@ fn test_clip_time_remapping() {
let mut document = Document::new("Test Project"); let mut document = Document::new("Test Project");
// Create a 10 second clip // Create a 10 second clip
let vector_clip = VectorClip::new("Test Clip", 10.0, 1920.0, 1080.0); let vector_clip = VectorClip::new("Test Clip", 1920.0, 1080.0, 10.0);
let clip_id = vector_clip.id; let clip_id = vector_clip.id;
let clip_duration = vector_clip.duration; let clip_duration = vector_clip.duration;
document.vector_clips.insert(clip_id, vector_clip); document.vector_clips.insert(clip_id, vector_clip);

2
lightningbeam-ui/lightningbeam-core/tests/rendering_integration_test.rs
View File

@ -80,7 +80,7 @@ fn test_render_with_transform() {
// Render with zoom and pan // Render with zoom and pan
let transform = Affine::translate((100.0, 50.0)) * Affine::scale(2.0); let transform = Affine::translate((100.0, 50.0)) * Affine::scale(2.0);
render_document_with_transform(&document, &mut scene, transform, &mut image_cache, &video_manager, None); render_document_with_transform(&document, &mut scene, transform, &mut image_cache, &video_manager);
} }
#[test] #[test]

2
lightningbeam-ui/lightningbeam-core/tests/selection_integration_test.rs
View File

@ -189,7 +189,7 @@ fn test_selection_with_transform_action() {
transforms.insert(id, (old_transform.clone(), new_transform.clone())); transforms.insert(id, (old_transform.clone(), new_transform.clone()));
} }
let mut action = TransformClipInstancesAction::new(layer_id, transforms); let mut action = TransformClipInstancesAction::new(layer_id, 0.0, transforms);
action.execute(&mut document); action.execute(&mut document);
// Verify transform applied // Verify transform applied

2
lightningbeam-ui/lightningbeam-editor/src/export/video_exporter.rs
View File

@ -747,7 +747,6 @@ pub fn render_frame_to_rgba_hdr(
base_transform, base_transform,
image_cache, image_cache,
video_manager, video_manager,
None, // No skipping during export
); );
// Buffer specs for layer rendering // Buffer specs for layer rendering
@ -1133,7 +1132,6 @@ pub fn render_frame_to_gpu_rgba(
base_transform, base_transform,
image_cache, image_cache,
video_manager, video_manager,
None, // No skipping during export
); );
// Buffer specs for layer rendering // Buffer specs for layer rendering

65
lightningbeam-ui/lightningbeam-editor/src/main.rs
View File

@ -1887,10 +1887,9 @@ impl EditorApp {
let new_shape_ids: Vec<Uuid> = shapes.iter().map(|s| s.id).collect(); let new_shape_ids: Vec<Uuid> = shapes.iter().map(|s| s.id).collect();
let kf = vector_layer.ensure_keyframe_at(self.playback_time); // TODO: DCEL - paste shapes disabled during migration
for shape in shapes { // (was: push shapes into kf.shapes)
kf.shapes.push(shape); let _ = (vector_layer, shapes);
}
// Select pasted shapes // Select pasted shapes
self.selection.clear_shapes(); self.selection.clear_shapes();
@ -2098,11 +2097,9 @@ impl EditorApp {
_ => return, _ => return,
}; };
for split in &region_sel.splits { // TODO: DCEL - region selection revert disabled during migration
vector_layer.remove_shape_from_keyframe(&split.inside_shape_id, region_sel.time); // (was: remove/add_shape_from/to_keyframe for splits)
vector_layer.remove_shape_from_keyframe(&split.outside_shape_id, region_sel.time); let _ = vector_layer;
vector_layer.add_shape_to_keyframe(split.original_shape.clone(), region_sel.time);
}
selection.clear(); selection.clear();
} }
@ -2626,7 +2623,7 @@ impl EditorApp {
let mut test_clip = VectorClip::new(&clip_name, 400.0, 400.0, 5.0); let mut test_clip = VectorClip::new(&clip_name, 400.0, 400.0, 5.0);
// Create a layer with some shapes // Create a layer with some shapes
let mut layer = VectorLayer::new("Shapes"); let layer = VectorLayer::new("Shapes");
// Create a red circle shape // Create a red circle shape
let circle_path = Circle::new((100.0, 100.0), 50.0).to_path(0.1); let circle_path = Circle::new((100.0, 100.0), 50.0).to_path(0.1);
@ -2638,10 +2635,9 @@ impl EditorApp {
let mut rect_shape = Shape::new(rect_path); let mut rect_shape = Shape::new(rect_path);
rect_shape.fill_color = Some(ShapeColor::rgb(0, 0, 255)); rect_shape.fill_color = Some(ShapeColor::rgb(0, 0, 255));
// Add shapes to keyframe at time 0.0 // TODO: DCEL - test shape creation disabled during migration
let kf = layer.ensure_keyframe_at(0.0); // (was: push shapes into kf.shapes)
kf.shapes.push(circle_shape); let _ = (circle_shape, rect_shape);
kf.shapes.push(rect_shape);
// Add the layer to the clip // Add the layer to the clip
test_clip.layers.add_root(AnyLayer::Vector(layer)); test_clip.layers.add_root(AnyLayer::Vector(layer));
@ -2664,14 +2660,11 @@ impl EditorApp {
if let Some(layer_id) = self.active_layer_id { if let Some(layer_id) = self.active_layer_id {
let document = self.action_executor.document(); let document = self.action_executor.document();
// Determine which selected objects are shape instances vs clip instances // Determine which selected objects are shape instances vs clip instances
let mut shape_ids = Vec::new(); let _shape_ids: Vec<uuid::Uuid> = Vec::new();
let mut clip_ids = Vec::new(); let mut clip_ids = Vec::new();
if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) { if let Some(AnyLayer::Vector(vl)) = document.get_layer(&layer_id) {
for &id in self.selection.shape_instances() { // TODO: DCEL - shape instance lookup disabled during migration
if vl.get_shape_in_keyframe(&id, self.playback_time).is_some() { // (was: get_shape_in_keyframe to check which selected objects are shapes)
shape_ids.push(id);
}
}
for &id in self.selection.clip_instances() { for &id in self.selection.clip_instances() {
if vl.clip_instances.iter().any(|ci| ci.id == id) { if vl.clip_instances.iter().any(|ci| ci.id == id) {
clip_ids.push(id); clip_ids.push(id);
@ -3555,34 +3548,10 @@ impl EditorApp {
// Get image dimensions // Get image dimensions
let (width, height) = asset_info.dimensions.unwrap_or((100.0, 100.0)); let (width, height) = asset_info.dimensions.unwrap_or((100.0, 100.0));
// Get document center position // TODO: Image fills on DCEL faces are a separate feature.
let doc = self.action_executor.document(); // For now, just log a message.
let center_x = doc.width / 2.0; let _ = (layer_id, width, height);
let center_y = doc.height / 2.0; eprintln!("Image drop to canvas not yet supported with DCEL backend");
// Create a rectangle path at the origin (position handled by transform)
use kurbo::BezPath;
let mut path = BezPath::new();
path.move_to((0.0, 0.0));
path.line_to((width, 0.0));
path.line_to((width, height));
path.line_to((0.0, height));
path.close_path();
// Create shape with image fill (references the ImageAsset)
use lightningbeam_core::shape::Shape;
let shape = Shape::new(path).with_image_fill(asset_info.clip_id);
// Set position on shape directly
let shape = shape.with_position(center_x, center_y);
// Create and execute action
let action = lightningbeam_core::actions::AddShapeAction::new(
layer_id,
shape,
self.playback_time,
);
let _ = self.action_executor.execute(Box::new(action));
} else { } else {
// For clips, create a clip instance // For clips, create a clip instance
let mut clip_instance = ClipInstance::new(asset_info.clip_id) let mut clip_instance = ClipInstance::new(asset_info.clip_id)

97
lightningbeam-ui/lightningbeam-editor/src/panes/asset_library.rs
View File

@ -10,7 +10,6 @@ use eframe::egui;
use lightningbeam_core::clip::{AudioClipType, VectorClip}; use lightningbeam_core::clip::{AudioClipType, VectorClip};
use lightningbeam_core::document::Document; use lightningbeam_core::document::Document;
use lightningbeam_core::layer::AnyLayer; use lightningbeam_core::layer::AnyLayer;
use lightningbeam_core::shape::ShapeColor;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use uuid::Uuid; use uuid::Uuid;
@ -413,8 +412,7 @@ fn generate_midi_thumbnail(
/// Generate a 64x64 RGBA thumbnail for a vector clip /// Generate a 64x64 RGBA thumbnail for a vector clip
/// Renders frame 0 of the clip using tiny-skia for software rendering /// Renders frame 0 of the clip using tiny-skia for software rendering
fn generate_vector_thumbnail(clip: &VectorClip, bg_color: egui::Color32) -> Vec<u8> { fn generate_vector_thumbnail(clip: &VectorClip, bg_color: egui::Color32) -> Vec<u8> {
use kurbo::PathEl; use tiny_skia::Pixmap;
use tiny_skia::{Paint, PathBuilder, Pixmap, Transform as TsTransform};
let size = THUMBNAIL_SIZE as usize; let size = THUMBNAIL_SIZE as usize;
let mut pixmap = Pixmap::new(THUMBNAIL_SIZE, THUMBNAIL_SIZE) let mut pixmap = Pixmap::new(THUMBNAIL_SIZE, THUMBNAIL_SIZE)
@ -431,94 +429,14 @@ fn generate_vector_thumbnail(clip: &VectorClip, bg_color: egui::Color32) -> Vec<
// Calculate scale to fit clip dimensions into thumbnail // Calculate scale to fit clip dimensions into thumbnail
let scale_x = THUMBNAIL_SIZE as f64 / clip.width.max(1.0); let scale_x = THUMBNAIL_SIZE as f64 / clip.width.max(1.0);
let scale_y = THUMBNAIL_SIZE as f64 / clip.height.max(1.0); let scale_y = THUMBNAIL_SIZE as f64 / clip.height.max(1.0);
let scale = scale_x.min(scale_y) * 0.9; // 90% to leave a small margin let _scale = scale_x.min(scale_y) * 0.9; // 90% to leave a small margin
// Center offset
let offset_x = (THUMBNAIL_SIZE as f64 - clip.width * scale) / 2.0;
let offset_y = (THUMBNAIL_SIZE as f64 - clip.height * scale) / 2.0;
// Iterate through layers and render shapes // Iterate through layers and render shapes
for layer_node in clip.layers.iter() { for layer_node in clip.layers.iter() {
if let AnyLayer::Vector(vector_layer) = &layer_node.data { if let AnyLayer::Vector(vector_layer) = &layer_node.data {
// Render each shape at time 0.0 (frame 0) // TODO: DCEL - thumbnail shape rendering disabled during migration
for shape in vector_layer.shapes_at_time(0.0) { // (was: shapes_at_time(0.0) to render shape fills/strokes into thumbnail)
// Get the path (frame 0) let _ = vector_layer;
let kurbo_path = shape.path();
// Convert kurbo BezPath to tiny-skia PathBuilder
let mut path_builder = PathBuilder::new();
for el in kurbo_path.iter() {
match el {
PathEl::MoveTo(p) => {
let x = (p.x * scale + offset_x) as f32;
let y = (p.y * scale + offset_y) as f32;
path_builder.move_to(x, y);
}
PathEl::LineTo(p) => {
let x = (p.x * scale + offset_x) as f32;
let y = (p.y * scale + offset_y) as f32;
path_builder.line_to(x, y);
}
PathEl::QuadTo(p1, p2) => {
let x1 = (p1.x * scale + offset_x) as f32;
let y1 = (p1.y * scale + offset_y) as f32;
let x2 = (p2.x * scale + offset_x) as f32;
let y2 = (p2.y * scale + offset_y) as f32;
path_builder.quad_to(x1, y1, x2, y2);
}
PathEl::CurveTo(p1, p2, p3) => {
let x1 = (p1.x * scale + offset_x) as f32;
let y1 = (p1.y * scale + offset_y) as f32;
let x2 = (p2.x * scale + offset_x) as f32;
let y2 = (p2.y * scale + offset_y) as f32;
let x3 = (p3.x * scale + offset_x) as f32;
let y3 = (p3.y * scale + offset_y) as f32;
path_builder.cubic_to(x1, y1, x2, y2, x3, y3);
}
PathEl::ClosePath => {
path_builder.close();
}
}
}
if let Some(ts_path) = path_builder.finish() {
// Draw fill if present
if let Some(fill_color) = &shape.fill_color {
let mut paint = Paint::default();
paint.set_color(shape_color_to_tiny_skia(fill_color));
paint.anti_alias = true;
pixmap.fill_path(
&ts_path,
&paint,
tiny_skia::FillRule::Winding,
TsTransform::identity(),
None,
);
}
// Draw stroke if present
if let Some(stroke_color) = &shape.stroke_color {
if let Some(stroke_style) = &shape.stroke_style {
let mut paint = Paint::default();
paint.set_color(shape_color_to_tiny_skia(stroke_color));
paint.anti_alias = true;
let stroke = tiny_skia::Stroke {
width: (stroke_style.width * scale) as f32,
..Default::default()
};
pixmap.stroke_path(
&ts_path,
&paint,
&stroke,
TsTransform::identity(),
None,
);
}
}
}
}
} }
} }
@ -541,11 +459,6 @@ fn generate_vector_thumbnail(clip: &VectorClip, bg_color: egui::Color32) -> Vec<
rgba rgba
} }
/// Convert ShapeColor to tiny_skia Color
fn shape_color_to_tiny_skia(color: &ShapeColor) -> tiny_skia::Color {
tiny_skia::Color::from_rgba8(color.r, color.g, color.b, color.a)
}
/// Generate a simple effect thumbnail with a pink gradient /// Generate a simple effect thumbnail with a pink gradient
#[allow(dead_code)] #[allow(dead_code)]
fn generate_effect_thumbnail() -> Vec<u8> { fn generate_effect_thumbnail() -> Vec<u8> {

81
lightningbeam-ui/lightningbeam-editor/src/panes/infopanel.rs
View File

@ -114,84 +114,9 @@ impl InfopanelPane {
if let Some(layer) = document.get_layer(&layer_id) { if let Some(layer) = document.get_layer(&layer_id) {
if let AnyLayer::Vector(vector_layer) = layer { if let AnyLayer::Vector(vector_layer) = layer {
// Gather values from all selected instances // Gather values from all selected instances
let mut first = true; // TODO: DCEL - shape property gathering disabled during migration
// (was: get_shape_in_keyframe to gather transform/fill/stroke properties)
for instance_id in &info.instance_ids { let _ = vector_layer;
if let Some(shape) = vector_layer.get_shape_in_keyframe(instance_id, *shared.playback_time) {
info.shape_ids.push(*instance_id);
if first {
// First shape - set initial values
info.x = Some(shape.transform.x);
info.y = Some(shape.transform.y);
info.rotation = Some(shape.transform.rotation);
info.scale_x = Some(shape.transform.scale_x);
info.scale_y = Some(shape.transform.scale_y);
info.skew_x = Some(shape.transform.skew_x);
info.skew_y = Some(shape.transform.skew_y);
info.opacity = Some(shape.opacity);
// Get shape properties
info.fill_color = Some(shape.fill_color);
info.stroke_color = Some(shape.stroke_color);
info.stroke_width = shape
.stroke_style
.as_ref()
.map(|s| Some(s.width))
.unwrap_or(Some(1.0));
first = false;
} else {
// Check if values differ (set to None if mixed)
if info.x != Some(shape.transform.x) {
info.x = None;
}
if info.y != Some(shape.transform.y) {
info.y = None;
}
if info.rotation != Some(shape.transform.rotation) {
info.rotation = None;
}
if info.scale_x != Some(shape.transform.scale_x) {
info.scale_x = None;
}
if info.scale_y != Some(shape.transform.scale_y) {
info.scale_y = None;
}
if info.skew_x != Some(shape.transform.skew_x) {
info.skew_x = None;
}
if info.skew_y != Some(shape.transform.skew_y) {
info.skew_y = None;
}
if info.opacity != Some(shape.opacity) {
info.opacity = None;
}
// Check shape properties
// Compare fill colors - set to None if mixed
if let Some(current_fill) = &info.fill_color {
if *current_fill != shape.fill_color {
info.fill_color = None;
}
}
// Compare stroke colors - set to None if mixed
if let Some(current_stroke) = &info.stroke_color {
if *current_stroke != shape.stroke_color {
info.stroke_color = None;
}
}
let stroke_w = shape
.stroke_style
.as_ref()
.map(|s| s.width)
.unwrap_or(1.0);
if info.stroke_width != Some(stroke_w) {
info.stroke_width = None;
}
}
}
}
} }
} }
} }

1816
lightningbeam-ui/lightningbeam-editor/src/panes/stage.rs
View File

File diff suppressed because it is too large Load Diff