skyler
/
Lightningbeam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Lightningbeam/lightningbeam-ui/lightningbeam-core/src/layer.rs

960 lines
27 KiB
Rust
Raw Blame History

//! Layer system for Lightningbeam
//!
//! Layers organize objects and shapes, and contain animation data.
use crate::animation::AnimationData;
use crate::clip::ClipInstance;
use crate::effect_layer::EffectLayer;
use crate::object::ShapeInstance;
use crate::shape::Shape;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use uuid::Uuid;
/// Layer type
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum LayerType {
/// Vector graphics layer (shapes and objects)
Vector,
/// Audio track
Audio,
/// Video clip
Video,
/// Generic automation layer
Automation,
/// Visual effects layer
Effect,
}
/// Common trait for all layer types
///
/// Provides uniform access to common layer properties across VectorLayer,
/// AudioLayer, VideoLayer, and their wrapper AnyLayer enum.
pub trait LayerTrait {
// Identity
fn id(&self) -> Uuid;
fn name(&self) -> &str;
fn set_name(&mut self, name: String);
fn has_custom_name(&self) -> bool;
fn set_has_custom_name(&mut self, custom: bool);
// Visual properties
fn visible(&self) -> bool;
fn set_visible(&mut self, visible: bool);
fn opacity(&self) -> f64;
fn set_opacity(&mut self, opacity: f64);
// Audio properties (all layers can affect audio through nesting)
fn volume(&self) -> f64;
fn set_volume(&mut self, volume: f64);
fn muted(&self) -> bool;
fn set_muted(&mut self, muted: bool);
// Editor state
fn soloed(&self) -> bool;
fn set_soloed(&mut self, soloed: bool);
fn locked(&self) -> bool;
fn set_locked(&mut self, locked: bool);
}
/// Base layer structure
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Layer {
/// Unique identifier
pub id: Uuid,
/// Layer type
pub layer_type: LayerType,
/// Layer name
pub name: String,
/// Whether the name was set by user (vs auto-generated)
pub has_custom_name: bool,
/// Whether the layer is visible
pub visible: bool,
/// Layer opacity (0.0 to 1.0)
pub opacity: f64,
/// Audio volume (1.0 = 100%, affects nested audio layers/clips)
pub volume: f64,
/// Audio mute state
pub muted: bool,
/// Solo state (for isolating layers)
pub soloed: bool,
/// Lock state (prevents editing)
pub locked: bool,
/// Animation data for this layer
pub animation_data: AnimationData,
}
impl Layer {
/// Create a new layer
pub fn new(layer_type: LayerType, name: impl Into<String>) -> Self {
Self {
id: Uuid::new_v4(),
layer_type,
name: name.into(),
has_custom_name: false, // Auto-generated by default
visible: true,
opacity: 1.0,
volume: 1.0, // 100% volume
muted: false,
soloed: false,
locked: false,
animation_data: AnimationData::new(),
}
}
/// Create with a specific ID
pub fn with_id(id: Uuid, layer_type: LayerType, name: impl Into<String>) -> Self {
Self {
id,
layer_type,
name: name.into(),
has_custom_name: false,
visible: true,
opacity: 1.0,
volume: 1.0,
muted: false,
soloed: false,
locked: false,
animation_data: AnimationData::new(),
}
}
/// Set visibility
pub fn with_visibility(mut self, visible: bool) -> Self {
self.visible = visible;
self
}
}
/// Tween type between keyframes
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum TweenType {
/// Hold shapes until next keyframe (no interpolation)
None,
/// Shape tween — morph geometry between keyframes
Shape,
}
impl Default for TweenType {
fn default() -> Self {
TweenType::None
}
}
/// A keyframe containing all shapes at a point in time
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ShapeKeyframe {
/// Time in seconds
pub time: f64,
/// All shapes at this keyframe
pub shapes: Vec<Shape>,
/// What happens between this keyframe and the next
#[serde(default)]
pub tween_after: TweenType,
/// Clip instance IDs visible in this keyframe region.
/// Groups are only rendered in regions where they appear in the left keyframe.
#[serde(default)]
pub clip_instance_ids: Vec<Uuid>,
}
impl ShapeKeyframe {
/// Create a new empty keyframe at a given time
pub fn new(time: f64) -> Self {
Self {
time,
shapes: Vec::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,
clip_instance_ids: Vec::new(),
}
}
}
/// Vector layer containing shapes and objects
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct VectorLayer {
/// Base layer properties
pub layer: Layer,
/// Shapes defined in this layer (indexed by UUID for O(1) lookup)
pub shapes: HashMap<Uuid, Shape>,
/// Shape instances (references to shapes with transforms)
pub shape_instances: Vec<ShapeInstance>,
/// Shape keyframes (sorted by time) — replaces shapes/shape_instances
#[serde(default)]
pub keyframes: Vec<ShapeKeyframe>,
/// Clip instances (references to vector clips with transforms)
/// VectorLayer can contain instances of VectorClips for nested compositions
pub clip_instances: Vec<ClipInstance>,
}
impl LayerTrait for VectorLayer {
fn id(&self) -> Uuid {
self.layer.id
}
fn name(&self) -> &str {
&self.layer.name
}
fn set_name(&mut self, name: String) {
self.layer.name = name;
}
fn has_custom_name(&self) -> bool {
self.layer.has_custom_name
}
fn set_has_custom_name(&mut self, custom: bool) {
self.layer.has_custom_name = custom;
}
fn visible(&self) -> bool {
self.layer.visible
}
fn set_visible(&mut self, visible: bool) {
self.layer.visible = visible;
}
fn opacity(&self) -> f64 {
self.layer.opacity
}
fn set_opacity(&mut self, opacity: f64) {
self.layer.opacity = opacity;
}
fn volume(&self) -> f64 {
self.layer.volume
}
fn set_volume(&mut self, volume: f64) {
self.layer.volume = volume;
}
fn muted(&self) -> bool {
self.layer.muted
}
fn set_muted(&mut self, muted: bool) {
self.layer.muted = muted;
}
fn soloed(&self) -> bool {
self.layer.soloed
}
fn set_soloed(&mut self, soloed: bool) {
self.layer.soloed = soloed;
}
fn locked(&self) -> bool {
self.layer.locked
}
fn set_locked(&mut self, locked: bool) {
self.layer.locked = locked;
}
}
impl VectorLayer {
/// Create a new vector layer
pub fn new(name: impl Into<String>) -> Self {
Self {
layer: Layer::new(LayerType::Vector, name),
shapes: HashMap::new(),
shape_instances: Vec::new(),
keyframes: Vec::new(),
clip_instances: Vec::new(),
}
}
/// Add a shape to this layer
pub fn add_shape(&mut self, shape: Shape) -> Uuid {
let id = shape.id;
self.shapes.insert(id, shape);
id
}
/// Add an object to this layer
pub fn add_object(&mut self, object: ShapeInstance) -> Uuid {
let id = object.id;
self.shape_instances.push(object);
id
}
/// Find a shape by ID
pub fn get_shape(&self, id: &Uuid) -> Option<&Shape> {
self.shapes.get(id)
}
/// Find a mutable shape by ID
pub fn get_shape_mut(&mut self, id: &Uuid) -> Option<&mut Shape> {
self.shapes.get_mut(id)
}
/// Find an object by ID
pub fn get_object(&self, id: &Uuid) -> Option<&ShapeInstance> {
self.shape_instances.iter().find(|o| &o.id == id)
}
/// Find a mutable object by ID
pub fn get_object_mut(&mut self, id: &Uuid) -> Option<&mut ShapeInstance> {
self.shape_instances.iter_mut().find(|o| &o.id == id)
}
// === MUTATION METHODS (pub(crate) - only accessible to action module) ===
/// Modify an object in place (internal, for actions only)
///
/// Applies the given function to the object if found.
/// This method is intentionally `pub(crate)` to ensure mutations
/// only happen through the action system.
pub fn modify_object_internal<F>(&mut self, id: &Uuid, f: F)
where
F: FnOnce(&mut ShapeInstance),
{
if let Some(object) = self.get_object_mut(id) {
f(object);
}
}
// === KEYFRAME METHODS ===
/// Find the keyframe at-or-before the given time
pub fn keyframe_at(&self, time: f64) -> Option<&ShapeKeyframe> {
// keyframes are sorted by time; find the last one <= time
let idx = self.keyframes.partition_point(|kf| kf.time <= time);
if idx > 0 {
Some(&self.keyframes[idx - 1])
} else {
None
}
}
/// Find the mutable keyframe at-or-before the given time
pub fn keyframe_at_mut(&mut self, time: f64) -> Option<&mut ShapeKeyframe> {
let idx = self.keyframes.partition_point(|kf| kf.time <= time);
if idx > 0 {
Some(&mut self.keyframes[idx - 1])
} else {
None
}
}
/// Find the index of a keyframe at the exact time (within tolerance)
pub fn keyframe_index_at_exact(&self, time: f64, tolerance: f64) -> Option<usize> {
self.keyframes.iter().position(|kf| (kf.time - time).abs() < tolerance)
}
/// Get shapes visible at a given time (from the keyframe at-or-before time)
pub fn shapes_at_time(&self, time: f64) -> &[Shape] {
match self.keyframe_at(time) {
Some(kf) => &kf.shapes,
None => &[],
}
}
/// Get the duration of the keyframe span starting at-or-before `time`.
/// Returns the time from `time` to the next keyframe, or to `fallback_end` if there is no next keyframe.
pub fn keyframe_span_duration(&self, time: f64, fallback_end: f64) -> f64 {
// Find the next keyframe after `time`
let next_idx = self.keyframes.partition_point(|kf| kf.time <= time);
let end = if next_idx < self.keyframes.len() {
self.keyframes[next_idx].time
} else {
fallback_end
};
(end - time).max(0.0)
}
/// Check if a clip instance (group) is visible at the given time.
/// Returns true if the keyframe at-or-before `time` contains `clip_instance_id`.
pub fn is_clip_instance_visible_at(&self, clip_instance_id: &Uuid, time: f64) -> bool {
self.keyframe_at(time)
.map_or(false, |kf| kf.clip_instance_ids.contains(clip_instance_id))
}
/// Get the visibility end time for a group clip instance starting from `time`.
/// A group is visible in regions bounded on the left by a keyframe that contains it
/// and on the right by any keyframe. Walks forward through keyframe regions,
/// extending as long as consecutive left-keyframes contain the clip instance.
/// If the last containing keyframe has no next keyframe (no right border),
/// the region is just one frame long.
pub fn group_visibility_end(&self, clip_instance_id: &Uuid, time: f64, frame_duration: f64) -> f64 {
let start_idx = self.keyframes.partition_point(|kf| kf.time <= time);
// start_idx is the index of the first keyframe AFTER time
// Walk forward: each keyframe that contains the group extends visibility to the NEXT keyframe
for idx in start_idx..self.keyframes.len() {
if !self.keyframes[idx].clip_instance_ids.contains(clip_instance_id) {
// This keyframe doesn't contain the group — it's the right border of the last region
return self.keyframes[idx].time;
}
// This keyframe contains the group — check if there's a next one to form a right border
}
// No more keyframes after the last containing one — last region is one frame
if let Some(last_kf) = self.keyframes.last() {
if last_kf.clip_instance_ids.contains(clip_instance_id) {
return last_kf.time + frame_duration;
}
}
time + frame_duration
}
/// Get mutable shapes at a given time
pub fn shapes_at_time_mut(&mut self, time: f64) -> Option<&mut Vec<Shape>> {
self.keyframe_at_mut(time).map(|kf| &mut kf.shapes)
}
/// 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.
/// Returns a mutable reference to the keyframe.
pub fn ensure_keyframe_at(&mut self, time: f64) -> &mut ShapeKeyframe {
let tolerance = 0.001;
if let Some(idx) = self.keyframe_index_at_exact(time, tolerance) {
return &mut self.keyframes[idx];
}
// Insert in sorted position
let insert_idx = self.keyframes.partition_point(|kf| kf.time < time);
self.keyframes.insert(insert_idx, ShapeKeyframe::new(time));
&mut self.keyframes[insert_idx]
}
/// Insert a new keyframe at time by copying shapes 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.
pub fn insert_keyframe_from_current(&mut self, time: f64) -> &mut ShapeKeyframe {
let tolerance = 0.001;
if let Some(idx) = self.keyframe_index_at_exact(time, tolerance) {
return &mut self.keyframes[idx];
}
// Clone shapes and clip instance IDs from the active keyframe
let (cloned_shapes, cloned_clip_ids) = self
.keyframe_at(time)
.map(|kf| {
let shapes: Vec<Shape> = kf.shapes
.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();
let insert_idx = self.keyframes.partition_point(|kf| kf.time < time);
let mut kf = ShapeKeyframe::with_shapes(time, cloned_shapes);
kf.clip_instance_ids = cloned_clip_ids;
self.keyframes.insert(insert_idx, kf);
&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(crate) 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(crate) 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).
/// Returns the removed keyframe if found.
pub(crate) fn remove_keyframe_at(&mut self, time: f64, tolerance: f64) -> Option<ShapeKeyframe> {
if let Some(idx) = self.keyframe_index_at_exact(time, tolerance) {
Some(self.keyframes.remove(idx))
} else {
None
}
}
}
/// Audio layer subtype - distinguishes sampled audio from MIDI
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum AudioLayerType {
/// Sampled audio (WAV, MP3, etc.)
Sampled,
/// MIDI sequence
Midi,
}
impl Default for AudioLayerType {
fn default() -> Self {
AudioLayerType::Sampled
}
}
/// Audio layer containing audio clips
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AudioLayer {
/// Base layer properties
pub layer: Layer,
/// Clip instances (references to audio clips)
/// AudioLayer can contain instances of AudioClips (sampled or MIDI)
pub clip_instances: Vec<ClipInstance>,
/// Audio layer subtype (sampled vs MIDI)
#[serde(default)]
pub audio_layer_type: AudioLayerType,
}
impl LayerTrait for AudioLayer {
fn id(&self) -> Uuid {
self.layer.id
}
fn name(&self) -> &str {
&self.layer.name
}
fn set_name(&mut self, name: String) {
self.layer.name = name;
}
fn has_custom_name(&self) -> bool {
self.layer.has_custom_name
}
fn set_has_custom_name(&mut self, custom: bool) {
self.layer.has_custom_name = custom;
}
fn visible(&self) -> bool {
self.layer.visible
}
fn set_visible(&mut self, visible: bool) {
self.layer.visible = visible;
}
fn opacity(&self) -> f64 {
self.layer.opacity
}
fn set_opacity(&mut self, opacity: f64) {
self.layer.opacity = opacity;
}
fn volume(&self) -> f64 {
self.layer.volume
}
fn set_volume(&mut self, volume: f64) {
self.layer.volume = volume;
}
fn muted(&self) -> bool {
self.layer.muted
}
fn set_muted(&mut self, muted: bool) {
self.layer.muted = muted;
}
fn soloed(&self) -> bool {
self.layer.soloed
}
fn set_soloed(&mut self, soloed: bool) {
self.layer.soloed = soloed;
}
fn locked(&self) -> bool {
self.layer.locked
}
fn set_locked(&mut self, locked: bool) {
self.layer.locked = locked;
}
}
impl AudioLayer {
/// Create a new sampled audio layer
pub fn new(name: impl Into<String>) -> Self {
Self {
layer: Layer::new(LayerType::Audio, name),
clip_instances: Vec::new(),
audio_layer_type: AudioLayerType::Sampled,
}
}
/// Create a new sampled audio layer (explicit)
pub fn new_sampled(name: impl Into<String>) -> Self {
Self::new(name)
}
/// Create a new MIDI layer
pub fn new_midi(name: impl Into<String>) -> Self {
Self {
layer: Layer::new(LayerType::Audio, name),
clip_instances: Vec::new(),
audio_layer_type: AudioLayerType::Midi,
}
}
}
/// Video layer containing video clips
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct VideoLayer {
/// Base layer properties
pub layer: Layer,
/// Clip instances (references to video clips)
/// VideoLayer can contain instances of VideoClips
pub clip_instances: Vec<ClipInstance>,
}
impl LayerTrait for VideoLayer {
fn id(&self) -> Uuid {
self.layer.id
}
fn name(&self) -> &str {
&self.layer.name
}
fn set_name(&mut self, name: String) {
self.layer.name = name;
}
fn has_custom_name(&self) -> bool {
self.layer.has_custom_name
}
fn set_has_custom_name(&mut self, custom: bool) {
self.layer.has_custom_name = custom;
}
fn visible(&self) -> bool {
self.layer.visible
}
fn set_visible(&mut self, visible: bool) {
self.layer.visible = visible;
}
fn opacity(&self) -> f64 {
self.layer.opacity
}
fn set_opacity(&mut self, opacity: f64) {
self.layer.opacity = opacity;
}
fn volume(&self) -> f64 {
self.layer.volume
}
fn set_volume(&mut self, volume: f64) {
self.layer.volume = volume;
}
fn muted(&self) -> bool {
self.layer.muted
}
fn set_muted(&mut self, muted: bool) {
self.layer.muted = muted;
}
fn soloed(&self) -> bool {
self.layer.soloed
}
fn set_soloed(&mut self, soloed: bool) {
self.layer.soloed = soloed;
}
fn locked(&self) -> bool {
self.layer.locked
}
fn set_locked(&mut self, locked: bool) {
self.layer.locked = locked;
}
}
impl VideoLayer {
/// Create a new video layer
pub fn new(name: impl Into<String>) -> Self {
Self {
layer: Layer::new(LayerType::Video, name),
clip_instances: Vec::new(),
}
}
}
/// Unified layer enum for polymorphic handling
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum AnyLayer {
Vector(VectorLayer),
Audio(AudioLayer),
Video(VideoLayer),
Effect(EffectLayer),
}
impl LayerTrait for AnyLayer {
fn id(&self) -> Uuid {
match self {
AnyLayer::Vector(l) => l.id(),
AnyLayer::Audio(l) => l.id(),
AnyLayer::Video(l) => l.id(),
AnyLayer::Effect(l) => l.id(),
}
}
fn name(&self) -> &str {
match self {
AnyLayer::Vector(l) => l.name(),
AnyLayer::Audio(l) => l.name(),
AnyLayer::Video(l) => l.name(),
AnyLayer::Effect(l) => l.name(),
}
}
fn set_name(&mut self, name: String) {
match self {
AnyLayer::Vector(l) => l.set_name(name),
AnyLayer::Audio(l) => l.set_name(name),
AnyLayer::Video(l) => l.set_name(name),
AnyLayer::Effect(l) => l.set_name(name),
}
}
fn has_custom_name(&self) -> bool {
match self {
AnyLayer::Vector(l) => l.has_custom_name(),
AnyLayer::Audio(l) => l.has_custom_name(),
AnyLayer::Video(l) => l.has_custom_name(),
AnyLayer::Effect(l) => l.has_custom_name(),
}
}
fn set_has_custom_name(&mut self, custom: bool) {
match self {
AnyLayer::Vector(l) => l.set_has_custom_name(custom),
AnyLayer::Audio(l) => l.set_has_custom_name(custom),
AnyLayer::Video(l) => l.set_has_custom_name(custom),
AnyLayer::Effect(l) => l.set_has_custom_name(custom),
}
}
fn visible(&self) -> bool {
match self {
AnyLayer::Vector(l) => l.visible(),
AnyLayer::Audio(l) => l.visible(),
AnyLayer::Video(l) => l.visible(),
AnyLayer::Effect(l) => l.visible(),
}
}
fn set_visible(&mut self, visible: bool) {
match self {
AnyLayer::Vector(l) => l.set_visible(visible),
AnyLayer::Audio(l) => l.set_visible(visible),
AnyLayer::Video(l) => l.set_visible(visible),
AnyLayer::Effect(l) => l.set_visible(visible),
}
}
fn opacity(&self) -> f64 {
match self {
AnyLayer::Vector(l) => l.opacity(),
AnyLayer::Audio(l) => l.opacity(),
AnyLayer::Video(l) => l.opacity(),
AnyLayer::Effect(l) => l.opacity(),
}
}
fn set_opacity(&mut self, opacity: f64) {
match self {
AnyLayer::Vector(l) => l.set_opacity(opacity),
AnyLayer::Audio(l) => l.set_opacity(opacity),
AnyLayer::Video(l) => l.set_opacity(opacity),
AnyLayer::Effect(l) => l.set_opacity(opacity),
}
}
fn volume(&self) -> f64 {
match self {
AnyLayer::Vector(l) => l.volume(),
AnyLayer::Audio(l) => l.volume(),
AnyLayer::Video(l) => l.volume(),
AnyLayer::Effect(l) => l.volume(),
}
}
fn set_volume(&mut self, volume: f64) {
match self {
AnyLayer::Vector(l) => l.set_volume(volume),
AnyLayer::Audio(l) => l.set_volume(volume),
AnyLayer::Video(l) => l.set_volume(volume),
AnyLayer::Effect(l) => l.set_volume(volume),
}
}
fn muted(&self) -> bool {
match self {
AnyLayer::Vector(l) => l.muted(),
AnyLayer::Audio(l) => l.muted(),
AnyLayer::Video(l) => l.muted(),
AnyLayer::Effect(l) => l.muted(),
}
}
fn set_muted(&mut self, muted: bool) {
match self {
AnyLayer::Vector(l) => l.set_muted(muted),
AnyLayer::Audio(l) => l.set_muted(muted),
AnyLayer::Video(l) => l.set_muted(muted),
AnyLayer::Effect(l) => l.set_muted(muted),
}
}
fn soloed(&self) -> bool {
match self {
AnyLayer::Vector(l) => l.soloed(),
AnyLayer::Audio(l) => l.soloed(),
AnyLayer::Video(l) => l.soloed(),
AnyLayer::Effect(l) => l.soloed(),
}
}
fn set_soloed(&mut self, soloed: bool) {
match self {
AnyLayer::Vector(l) => l.set_soloed(soloed),
AnyLayer::Audio(l) => l.set_soloed(soloed),
AnyLayer::Video(l) => l.set_soloed(soloed),
AnyLayer::Effect(l) => l.set_soloed(soloed),
}
}
fn locked(&self) -> bool {
match self {
AnyLayer::Vector(l) => l.locked(),
AnyLayer::Audio(l) => l.locked(),
AnyLayer::Video(l) => l.locked(),
AnyLayer::Effect(l) => l.locked(),
}
}
fn set_locked(&mut self, locked: bool) {
match self {
AnyLayer::Vector(l) => l.set_locked(locked),
AnyLayer::Audio(l) => l.set_locked(locked),
AnyLayer::Video(l) => l.set_locked(locked),
AnyLayer::Effect(l) => l.set_locked(locked),
}
}
}
impl AnyLayer {
/// Get a reference to the base layer
pub fn layer(&self) -> &Layer {
match self {
AnyLayer::Vector(l) => &l.layer,
AnyLayer::Audio(l) => &l.layer,
AnyLayer::Video(l) => &l.layer,
AnyLayer::Effect(l) => &l.layer,
}
}
/// Get a mutable reference to the base layer
pub fn layer_mut(&mut self) -> &mut Layer {
match self {
AnyLayer::Vector(l) => &mut l.layer,
AnyLayer::Audio(l) => &mut l.layer,
AnyLayer::Video(l) => &mut l.layer,
AnyLayer::Effect(l) => &mut l.layer,
}
}
/// Get the layer ID
pub fn id(&self) -> Uuid {
self.layer().id
}
/// Get the layer name
pub fn name(&self) -> &str {
&self.layer().name
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_layer_creation() {
let layer = Layer::new(LayerType::Vector, "Test Layer");
assert_eq!(layer.layer_type, LayerType::Vector);
assert_eq!(layer.name, "Test Layer");
assert_eq!(layer.opacity, 1.0);
}
#[test]
fn test_vector_layer() {
let vector_layer = VectorLayer::new("My Layer");
assert_eq!(vector_layer.shapes.len(), 0);
assert_eq!(vector_layer.shape_instances.len(), 0);
}
#[test]
fn test_layer_basic_properties() {
let layer = Layer::new(LayerType::Vector, "Test");
assert_eq!(layer.name, "Test");
assert_eq!(layer.visible, true);
assert_eq!(layer.opacity, 1.0);
assert_eq!(layer.volume, 1.0);
assert_eq!(layer.muted, false);
assert_eq!(layer.soloed, false);
assert_eq!(layer.locked, false);
}
}
Reference in New Issue View Git Blame Copy Permalink