Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

refactor(project): move settings, comp, layer, footage and item types out of lib.rs

aiongg55ab7b556c7e
diff --git a/crates/project/src/comp.rs b/crates/project/src/comp.rs
new file mode 100644
index 000000000..2ff97cd37
--- /dev/null
+++ b/crates/project/src/comp.rs
@@ -0,0 +1,427 @@
+use super::item::LayerId;
+use super::layer::{Layer, LayerSource};
+use super::settings::{Marker, yes};
+use super::*;
+
+/// 3D renderer of a composition.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Renderer {
+ #[default]
+ Classic3D,
+ Advanced3D,
+}
+
+/// A composition's Resolution (the Composition panel's Resolution/Down Sample Factor popup, View ▸
+/// Resolution): how many of its pixels the viewer renders. Auto follows the magnification.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Resolution {
+ #[default]
+ Auto,
+ Full,
+ Half,
+ Third,
+ Quarter,
+ /// View ▸ Resolution ▸ Custom: render every n-th pixel (2..=40).
+ Custom(u8),
+}
+
+impl Resolution {
+ pub const ALL: [Resolution; 5] = [Resolution::Auto, Resolution::Full, Resolution::Half, Resolution::Third, Resolution::Quarter];
+ pub fn label(self) -> &'static str {
+ match self {
+ Resolution::Auto => "Auto",
+ Resolution::Full => "Full",
+ Resolution::Half => "Half",
+ Resolution::Third => "Third",
+ Resolution::Quarter => "Quarter",
+ Resolution::Custom(_) => "Custom",
+ }
+ }
+ pub fn is_auto(&self) -> bool {
+ *self == Resolution::Auto
+ }
+ /// The down-sample factor (render every n-th pixel); `None` for Auto.
+ pub fn factor(self) -> Option<u8> {
+ match self {
+ Resolution::Auto => None,
+ Resolution::Full => Some(1),
+ Resolution::Half => Some(2),
+ Resolution::Third => Some(3),
+ Resolution::Quarter => Some(4),
+ Resolution::Custom(n) => Some(n),
+ }
+ }
+ /// The resolution that renders every `n`-th pixel (1 = Full … 4 = Quarter; up to 40).
+ pub fn from_factor(n: u64) -> Resolution {
+ match n.clamp(1, 40) {
+ 1 => Resolution::Full,
+ 2 => Resolution::Half,
+ 3 => Resolution::Third,
+ 4 => Resolution::Quarter,
+ n => Resolution::Custom(n as u8),
+ }
+ }
+ /// Render scale for a viewer magnification (and display pixel density).
+ pub fn scale(self, zoom: f32, ppp: f32) -> f64 {
+ match self.factor() {
+ Some(n) => 1.0 / f64::from(n.clamp(1, 40)),
+ // As in After Effects, Auto renders the pixels the magnification needs: the coarsest
+ // whole factor that still gives every screen pixel a rendered one (Full above 50 %,
+ // Half down to 33.3 %, Third down to 25 %, Quarter below), never fewer (#417).
+ None => {
+ let n = (1.0 / (zoom * ppp) as f64 + 1e-3).floor();
+ if n >= 1.0 { 1.0 / n.min(4.0) } else { 1.0 }
+ }
+ }
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Comp {
+ pub width: u32,
+ pub height: u32,
+ pub pixel_aspect: f64,
+ pub frame_rate: FrameRate,
+ pub duration: Tick,
+ /// Start timecode/frame shown for time 0.
+ pub display_start: Tick,
+ pub background: [f32; 3],
+ pub work_area: (Tick, Tick),
+ /// Layer #1 first (top of the stack).
+ pub layers: Vec<Layer>,
+ #[serde(default)]
+ pub markers: Vec<Marker>,
+ pub shutter_angle: f64,
+ pub shutter_phase: f64,
+ /// Samples Per Frame: the minimum motion-blur samples (and the count for 3D layers).
+ pub motion_blur_samples: u32,
+ /// Adaptive Sample Limit (Composition Settings ▸ Advanced): the most samples a 2D layer gets
+ /// when it moves far within the shutter.
+ #[serde(default = "adaptive_limit_default")]
+ pub motion_blur_adaptive_limit: u32,
+ #[serde(default)]
+ pub renderer: Renderer,
+ /// Comp switches (timeline toolbar).
+ #[serde(default)]
+ pub hide_shy: bool,
+ #[serde(default = "yes")]
+ pub enable_motion_blur: bool,
+ #[serde(default = "yes")]
+ pub enable_frame_blending: bool,
+ #[serde(default)]
+ pub draft_3d: bool,
+ /// Composition Settings ▸ Advanced ▸ Preserve frame rate when nested or in render queue:
+ /// nested in another comp, or rendered at another rate, it shows only its own frames.
+ #[serde(default)]
+ pub preserve_frame_rate: bool,
+ /// Composition Settings ▸ Advanced ▸ Preserve resolution when nested: nested in a comp
+ /// previewed at a lower resolution, it still renders at full size.
+ #[serde(default)]
+ pub preserve_resolution: bool,
+ #[serde(default)]
+ pub poster_time: Tick,
+ /// Global Light for layer styles (Layer ▸ Layer Styles ▸ Blending Options).
+ #[serde(default)]
+ pub global_light: styles::GlobalLight,
+ /// Viewer guides (View ▸ Add Guide…), in comp pixels.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub guides: Vec<Guide>,
+ /// Essential Graphics: the controls this comp exposes to instances and templates.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub essential: Option<essential::EssentialGraphics>,
+ /// The Composition panel's Resolution, saved with the project as in After Effects. It changes
+ /// what the viewer renders, not the comp's pixels ([`Comp::same_pixels`]), and stays out of
+ /// the undo history.
+ #[serde(default, skip_serializing_if = "Resolution::is_auto")]
+ pub resolution: Resolution,
+}
+
+/// A viewer guide line: vertical guides sit at an x position, horizontal ones at a y position.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Guide {
+ pub vertical: bool,
+ /// Comp pixels, or percent of the comp's width (vertical) / height (horizontal) when
+ /// [`Guide::percent`] is set.
+ pub position: f64,
+ /// A percentage guide (After Effects 26.5): `position` is a percent of the comp's size, so the
+ /// guide keeps its relative place when the comp is resized. Absent in older projects.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub percent: bool,
+}
+
+impl Guide {
+ /// The comp's extent along this guide's axis, never zero.
+ fn extent(&self, width: u32, height: u32) -> f64 {
+ f64::from(if self.vertical { width } else { height }).max(1.0)
+ }
+
+ /// The guide's position in comp pixels for a comp of this size.
+ pub fn px(&self, width: u32, height: u32) -> f64 {
+ if self.percent { self.position / 100.0 * self.extent(width, height) } else { self.position }
+ }
+
+ /// Place the guide at `px` comp pixels, keeping its unit.
+ pub fn set_px(&mut self, px: f64, width: u32, height: u32) {
+ self.position = if self.percent { px / self.extent(width, height) * 100.0 } else { px };
+ }
+
+ /// Switch between pixels and percent without moving the guide on the comp.
+ pub fn set_percent(&mut self, percent: bool, width: u32, height: u32) {
+ let px = self.px(width, height);
+ self.percent = percent;
+ self.set_px(px, width, height);
+ }
+}
+
+fn adaptive_limit_default() -> u32 {
+ 128
+}
+
+impl Comp {
+ pub fn new(width: u32, height: u32, frame_rate: FrameRate, duration: Tick) -> Comp {
+ Comp {
+ width,
+ height,
+ pixel_aspect: 1.0,
+ frame_rate,
+ duration,
+ display_start: Tick::ZERO,
+ background: [0.0, 0.0, 0.0],
+ work_area: (Tick::ZERO, duration),
+ layers: vec![],
+ markers: vec![],
+ shutter_angle: 180.0,
+ shutter_phase: -90.0,
+ motion_blur_samples: 16,
+ motion_blur_adaptive_limit: 128,
+ renderer: Renderer::Classic3D,
+ hide_shy: false,
+ enable_motion_blur: true,
+ enable_frame_blending: true,
+ draft_3d: false,
+ preserve_frame_rate: false,
+ preserve_resolution: false,
+ poster_time: Tick::ZERO,
+ guides: vec![],
+ global_light: styles::GlobalLight::default(),
+ essential: None,
+ resolution: Resolution::Auto,
+ }
+ }
+
+ /// Whether the composition has a frame at its time `t`: nested, it shows nothing before it
+ /// starts or after it ends (a precomp layer trimmed or remapped past it).
+ pub fn covers(&self, t: Tick) -> bool {
+ t >= Tick::ZERO && t < self.duration
+ }
+
+ /// A new, empty composition with this one's settings (frame rate, pixel aspect, background,
+ /// motion blur, frame blending and the 3D renderer), as Pre-compose makes.
+ pub fn nested_like(&self, width: u32, height: u32, duration: Tick) -> Comp {
+ Comp {
+ pixel_aspect: self.pixel_aspect,
+ background: self.background,
+ shutter_angle: self.shutter_angle,
+ shutter_phase: self.shutter_phase,
+ motion_blur_samples: self.motion_blur_samples,
+ motion_blur_adaptive_limit: self.motion_blur_adaptive_limit,
+ renderer: self.renderer,
+ enable_motion_blur: self.enable_motion_blur,
+ enable_frame_blending: self.enable_frame_blending,
+ preserve_frame_rate: self.preserve_frame_rate,
+ preserve_resolution: self.preserve_resolution,
+ ..Comp::new(width, height, self.frame_rate, duration)
+ }
+ }
+
+ pub fn layer(&self, id: LayerId) -> Option<&Layer> {
+ self.layers.iter().find(|l| l.id == id)
+ }
+
+ pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
+ self.layers.iter_mut().find(|l| l.id == id)
+ }
+
+ /// 1-based layer number (#) of a layer.
+ pub fn index_of(&self, id: LayerId) -> Option<usize> {
+ self.layers.iter().position(|l| l.id == id).map(|i| i + 1)
+ }
+
+ pub fn layer_by_name(&self, name: &str) -> Option<&Layer> {
+ self.layers.iter().find(|l| l.name == name)
+ }
+
+ pub fn frame_duration(&self) -> Tick {
+ self.frame_rate.frame_duration()
+ }
+
+ /// Any 3D layer present (camera/lights or a 3D switch).
+ pub fn has_3d(&self) -> bool {
+ self.layers.iter().any(|l| l.switches.three_d || matches!(l.source, LayerSource::Camera | LayerSource::Light { .. }))
+ }
+
+ /// The active camera at `t`: the topmost enabled camera layer active at that time.
+ pub fn active_camera(&self, t: Tick) -> Option<&Layer> {
+ self.layers.iter().find(|l| matches!(l.source, LayerSource::Camera) && l.switches.video && l.is_active_at(t))
+ }
+
+ /// Unique layer name with a numeric suffix (`Shape Layer 2`).
+ pub fn unique_layer_name(&self, base: &str) -> String {
+ if !self.layers.iter().any(|l| l.name == base) {
+ return base.to_string();
+ }
+ let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
+ (2..).map(|i| format!("{stem} {i}")).find(|n| !self.layers.iter().any(|l| &l.name == n)).unwrap_or_default()
+ }
+}
+
+impl Comp {
+ /// Draws the same pixels as `o`: equal but for its layers' Audio, Lock and Shy switches, Hide
+ /// Shy Layers and the viewer's Resolution.
+ pub fn same_pixels(&self, o: &Comp) -> bool {
+ self.same_settings(o) && self.layers.len() == o.layers.len() && self.layers.iter().zip(&o.layers).all(|(a, b)| a.same_pixels(b))
+ }
+
+ /// [`Self::same_pixels`] but for the layers.
+ fn same_settings(&self, o: &Comp) -> bool {
+ // Every field (no `..`: a new field must be considered here).
+ let Comp {
+ width,
+ height,
+ pixel_aspect,
+ frame_rate,
+ duration,
+ display_start,
+ background,
+ work_area,
+ layers: _,
+ markers,
+ shutter_angle,
+ shutter_phase,
+ motion_blur_samples,
+ motion_blur_adaptive_limit,
+ renderer,
+ hide_shy: _,
+ enable_motion_blur,
+ enable_frame_blending,
+ draft_3d,
+ preserve_frame_rate,
+ preserve_resolution,
+ poster_time,
+ global_light,
+ guides,
+ essential,
+ resolution: _,
+ } = self;
+ *width == o.width
+ && *height == o.height
+ && *pixel_aspect == o.pixel_aspect
+ && *frame_rate == o.frame_rate
+ && *duration == o.duration
+ && *display_start == o.display_start
+ && *background == o.background
+ && *work_area == o.work_area
+ && *markers == o.markers
+ && *shutter_angle == o.shutter_angle
+ && *shutter_phase == o.shutter_phase
+ && *motion_blur_samples == o.motion_blur_samples
+ && *motion_blur_adaptive_limit == o.motion_blur_adaptive_limit
+ && *renderer == o.renderer
+ && *enable_motion_blur == o.enable_motion_blur
+ && *enable_frame_blending == o.enable_frame_blending
+ && *draft_3d == o.draft_3d
+ && *preserve_frame_rate == o.preserve_frame_rate
+ && *preserve_resolution == o.preserve_resolution
+ && *poster_time == o.poster_time
+ && *global_light == o.global_light
+ && *guides == o.guides
+ && *essential == o.essential
+ }
+
+ /// The comp-time span (`in_point..out_point` of every layer changed, added or removed,
+ /// widened by the shutter) outside which `self` draws the same pixels as `o`, so cached
+ /// frames there stay valid (#1641). `None` when the edit can reach any frame: a comp setting,
+ /// a layer reorder, Solo turning on or off, an expression (it reads anything), or a changed
+ /// layer another layer parents to, mattes with or picks in an effect.
+ pub fn changed_span(&self, o: &Comp) -> Option<(Tick, Tick)> {
+ fn reads(g: &PropGroup, changed: &[LayerId]) -> bool {
+ g.children.iter().any(|c| match c {
+ Node::Prop(p) => {
+ p.expr.is_some()
+ || std::iter::once(&p.value)
+ .chain(p.keys.iter().map(|k| &k.value))
+ .any(|v| matches!(v, Value::Layer(Some(id)) if changed.contains(&LayerId(*id))))
+ }
+ Node::Group(g) => reads(g, changed),
+ })
+ }
+ // Solo hides every other layer at every frame.
+ if !self.same_settings(o) || self.any_solo() != o.any_solo() {
+ return None;
+ }
+ let common = |a: &Comp, b: &Comp| a.layers.iter().map(|l| l.id).filter(|id| b.layer(*id).is_some()).collect::<Vec<_>>();
+ if common(self, o) != common(o, self) {
+ return None;
+ }
+ let mut changed = Vec::new();
+ let mut span: Option<(Tick, Tick)> = None;
+ // Each changed layer comes up from both sides: its old and its new span.
+ for (l, other) in self.layers.iter().map(|l| (l, o.layer(l.id))).chain(o.layers.iter().map(|l| (l, self.layer(l.id)))) {
+ if other.is_some_and(|b| l.same_pixels(b)) {
+ continue;
+ }
+ changed.push(l.id);
+ let (s, e) = (l.in_point.min(l.out_point), l.in_point.max(l.out_point));
+ span = Some(span.map_or((s, e), |(a, b)| (a.min(s), b.max(e))));
+ }
+ let reaches = |l: &Layer| {
+ l.parent.is_some_and(|p| changed.contains(&p)) || l.track_matte.as_ref().is_some_and(|m| changed.contains(&m.layer)) || reads(&l.props, &changed)
+ };
+ if self.layers.iter().chain(&o.layers).any(reaches) {
+ return None;
+ }
+ // A frame at `t` samples cameras, lights and transforms over its shutter,
+ // `t + (phase + angle * 0..=1) / 360` frames, and draws the layers active at `t` itself.
+ let (a, p) = (self.shutter_angle / 360.0, self.shutter_phase / 360.0);
+ let fd = self.frame_duration().seconds();
+ let (before, after) = (Tick::from_seconds_f64(p.max(p + a).max(0.0) * fd), Tick::from_seconds_f64(-p.min(p + a).min(0.0) * fd));
+ span.map(|(s, e)| (s - before, e + after))
+ }
+
+ /// Some layer is soloed: only the soloed layers draw.
+ pub fn any_solo(&self) -> bool {
+ self.layers.iter().any(|l| l.switches.solo && l.source.is_av())
+ }
+
+ /// Draws the same pixels as `o` once plain markers are ignored: they change no pixels. Protected
+ /// time markers with a duration set the timing (Responsive Design), so those still count.
+ pub fn same_pixels_ignoring_markers(&self, o: &Comp) -> bool {
+ let protected =
+ |m: &[Marker]| -> Vec<(Tick, Tick)> { m.iter().filter(|m| m.protected && m.duration > Tick::ZERO).map(|m| (m.time, m.duration)).collect() };
+ if protected(&self.markers) != protected(&o.markers) {
+ return false;
+ }
+ let mut c = self.clone();
+ c.markers = o.markers.clone();
+ for (a, b) in c.layers.iter_mut().zip(&o.layers) {
+ a.markers = b.markers.clone();
+ a.markers_locked = b.markers_locked;
+ }
+ c.same_pixels(o)
+ }
+
+ /// The comp with those switches and the Resolution at their defaults (borrowed when they
+ /// already are), for keys that hash the whole comp.
+ pub fn pixel_form(&self) -> std::borrow::Cow<'_, Comp> {
+ if !self.hide_shy && self.resolution.is_auto() && self.layers.iter().all(|l| l.switches == l.switches.pixels()) {
+ return std::borrow::Cow::Borrowed(self);
+ }
+ let mut c = self.clone();
+ c.hide_shy = false;
+ c.resolution = Resolution::Auto;
+ for l in &mut c.layers {
+ l.switches = l.switches.pixels();
+ }
+ std::borrow::Cow::Owned(c)
+ }
+}
diff --git a/crates/project/src/footage.rs b/crates/project/src/footage.rs
new file mode 100644
index 000000000..ff1983d88
--- /dev/null
+++ b/crates/project/src/footage.rs
@@ -0,0 +1,229 @@
+use super::settings::yes;
+use super::*;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum FootageKind {
+ #[default]
+ Video,
+ Still,
+ Sequence,
+ Audio,
+ /// A 3D model (glTF 2.0 / OBJ), placed as a model layer.
+ Model,
+ /// A data file (JSON, CSV, TSV) for data-driven animation: read by expressions through
+ /// `footage(name).sourceData` / `sourceText` / `dataValue`; it has no pixels.
+ Data,
+}
+
+/// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum FieldOrder {
+ /// Progressive frames.
+ #[default]
+ Off,
+ /// Interlaced, upper (odd) field first: each field becomes a frame at twice the rate.
+ UpperFirst,
+ LowerFirst,
+}
+
+impl FieldOrder {
+ pub fn label(self) -> &'static str {
+ match self {
+ FieldOrder::Off => "Off",
+ FieldOrder::UpperFirst => "Upper Field First",
+ FieldOrder::LowerFirst => "Lower Field First",
+ }
+ }
+ pub fn parse(s: &str) -> Option<FieldOrder> {
+ match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
+ "off" | "none" | "progressive" => Some(FieldOrder::Off),
+ "upper" | "upperfirst" | "upperfieldfirst" => Some(FieldOrder::UpperFirst),
+ "lower" | "lowerfirst" | "lowerfieldfirst" => Some(FieldOrder::LowerFirst),
+ _ => None,
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AlphaMode {
+ #[default]
+ Straight,
+ Premultiplied,
+ Ignore,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Footage {
+ pub path: String,
+ pub kind: FootageKind,
+ pub width: u32,
+ pub height: u32,
+ pub pixel_aspect: f64,
+ pub frame_rate: FrameRate,
+ /// Native rate before "Conform to frame rate".
+ #[serde(default)]
+ pub native_rate: Option<FrameRate>,
+ pub duration: Tick,
+ pub has_video: bool,
+ pub has_audio: bool,
+ pub alpha: AlphaMode,
+ #[serde(default)]
+ pub premul_color: [f32; 3],
+ #[serde(default = "one")]
+ pub loop_count: u32,
+ #[serde(default)]
+ pub codec: String,
+ #[serde(default)]
+ pub missing: bool,
+ /// Image sequence files (when kind = Sequence).
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub sequence: Vec<String>,
+ /// Colour profile (from the file's metadata, or Interpret Footage). `None` = sRGB.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub color_profile: Option<ColorSpace>,
+ /// One layer of a layered file (Photoshop) instead of its merged image.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub layer: Option<SourceLayer>,
+ /// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
+ #[serde(default, skip_serializing_if = "is_default")]
+ pub fields: FieldOrder,
+ /// Interpret Footage ▸ Alpha ▸ Invert Alpha.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub invert_alpha: bool,
+ /// Interpret Footage ▸ Color ▸ Interpret As Linear Light: the file's values are linear.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub linear_light: bool,
+ /// Interpret Footage ▸ Color ▸ Preserve RGB: the file's values enter the composition
+ /// unconverted. Float footage (OpenEXR, float TIFF) is not sRGB-encoded on decode, and the
+ /// colour profile, Interpret As Linear Light and the working space don't apply.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub preserve_rgb: bool,
+ /// Data footage ([`FootageKind::Data`]): the file's text (JSON, CSV or TSV), kept in the
+ /// project so expressions read it everywhere (and on the web).
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub data: Option<String>,
+ /// PDF / Illustrator footage: the page shown (0-based; File ▸ Import ▸ Page).
+ #[serde(default, skip_serializing_if = "is_default")]
+ pub page: u32,
+ /// Image sequences imported with Force Alphabetical Order: the files play one after another
+ /// and their numbering doesn't count (otherwise a gap in it shows a placeholder, as in After
+ /// Effects; [`sequence`]).
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub alphabetical: bool,
+ /// Interpret Footage ▸ Start Timecode ▸ Override Start: the frame (at the footage's frame
+ /// rate) its timecode shows at its first frame. `None` = Use Source File Timecode (0: file
+ /// timecode isn't read). It only relabels source time, as in After Effects.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub start_timecode: Option<i64>,
+}
+
+fn is_default<T: Default + PartialEq>(v: &T) -> bool {
+ *v == T::default()
+}
+
+impl Default for Footage {
+ fn default() -> Self {
+ Footage {
+ path: String::new(),
+ kind: FootageKind::Still,
+ width: 0,
+ height: 0,
+ pixel_aspect: 1.0,
+ frame_rate: FrameRate::FPS_30,
+ native_rate: None,
+ duration: Tick::ZERO,
+ has_video: false,
+ has_audio: false,
+ alpha: AlphaMode::Straight,
+ premul_color: [0.0; 3],
+ loop_count: 1,
+ codec: String::new(),
+ missing: false,
+ sequence: vec![],
+ color_profile: None,
+ fields: FieldOrder::Off,
+ invert_alpha: false,
+ linear_light: false,
+ preserve_rgb: false,
+ data: None,
+ layer: None,
+ page: 0,
+ alphabetical: false,
+ start_timecode: None,
+ }
+ }
+}
+
+impl Footage {
+ /// Interpret As Linear Light applies (Preserve RGB passes the file's values through).
+ pub fn linear_light_applies(&self) -> bool {
+ self.linear_light && !self.preserve_rgb
+ }
+
+ /// How long the footage plays: its duration times Interpret Footage ▸ Loop.
+ pub fn looped_duration(&self) -> Tick {
+ Tick(self.duration.0.saturating_mul(self.loop_count.max(1) as i64))
+ }
+
+ /// Source time as the footage's timecode: its frame `frame` from Start Timecode
+ /// (`0:00:41:20`), as the Footage panel shows it.
+ pub fn timecode(&self, frame: i64) -> String {
+ effectcraft_time::format_timecode_ae(frame.saturating_add(self.start_timecode.unwrap_or(0)), self.frame_rate, false)
+ }
+
+ /// The data format of data footage: `json`, `csv` or `tsv` (from the file extension).
+ pub fn data_format(&self) -> Option<&'static str> {
+ if self.kind != FootageKind::Data {
+ return None;
+ }
+ let ext = std::path::Path::new(&self.path).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase();
+ Some(match ext.as_str() {
+ "csv" => "csv",
+ "tsv" | "tab" => "tsv",
+ _ => "json",
+ })
+ }
+}
+
+/// A proxy: a stand-in file used instead of a footage item or composition (File ▸ Set Proxy /
+/// Create Proxy), when its Use Proxy switch is on and the render's Proxy Use allows it.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Proxy {
+ /// The proxy's footage (path, size, rate…; File ▸ Interpret Footage ▸ Proxy edits it).
+ pub footage: Footage,
+ /// Use Proxy (the Project panel's proxy indicator: filled = in use, hollow = set but off).
+ #[serde(default = "yes")]
+ pub enabled: bool,
+}
+
+/// A layer of a layered still (a Photoshop document, or a PDF / Illustrator / EPS file) used as
+/// footage (File ▸ Import ▸ Composition / Composition – Retain Layer Sizes, or Choose Layer).
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SourceLayer {
+ /// Layer record index in the file (bottom of the stack = 0).
+ pub index: u32,
+ pub name: String,
+ /// The footage is the layer's own bounds (Retain Layer Sizes) rather than the document size.
+ #[serde(default)]
+ pub layer_size: bool,
+ /// A Photoshop smart object: the unique id of its embedded file (linked layer data), which
+ /// is the footage instead of the layer's pixels.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub embedded: Option<String>,
+ /// A smart object with a perspective quad or a warp: the footage is its embedded file baked
+ /// as placed (warped and pinned to its corners) over the placed bounds in document space.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub placed: bool,
+}
+
+fn one() -> u32 {
+ 1
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Solid {
+ pub color: [f32; 3],
+ pub width: u32,
+ pub height: u32,
+ pub pixel_aspect: f64,
+}
diff --git a/crates/project/src/item.rs b/crates/project/src/item.rs
new file mode 100644
index 000000000..d9d5184c9
--- /dev/null
+++ b/crates/project/src/item.rs
@@ -0,0 +1,308 @@
+use super::comp::Comp;
+use super::footage::{Footage, FootageKind, Proxy, Solid};
+use super::layer::LayerSource;
+use super::settings::{APP_VERSION, ProjectError, ProjectSettings, SCHEMA_VERSION, SavedView};
+use super::*;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct ItemId(pub u64);
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct LayerId(pub u64);
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+#[allow(clippy::large_enum_variant)]
+pub enum ItemKind {
+ Folder,
+ Comp(Arc<Comp>),
+ Footage(Footage),
+ Solid(Solid),
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Item {
+ pub id: ItemId,
+ pub name: String,
+ pub label: Label,
+ #[serde(default)]
+ pub comment: String,
+ /// Containing folder (None = project root).
+ #[serde(default)]
+ pub parent: Option<ItemId>,
+ pub kind: ItemKind,
+ /// The item's proxy (footage and compositions).
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub proxy: Option<Box<Proxy>>,
+}
+
+impl Item {
+ pub fn type_name(&self) -> &'static str {
+ match &self.kind {
+ ItemKind::Folder => "Folder",
+ ItemKind::Comp(_) => "Composition",
+ ItemKind::Footage(f) => match f.kind {
+ FootageKind::Video => "Video",
+ FootageKind::Still => "Image",
+ FootageKind::Sequence => "Image Sequence",
+ FootageKind::Audio => "Audio",
+ FootageKind::Model => "3D Model",
+ FootageKind::Data => "Data",
+ },
+ ItemKind::Solid(_) => "Solid",
+ }
+ }
+ pub fn as_comp(&self) -> Option<&Comp> {
+ if let ItemKind::Comp(c) = &self.kind { Some(c) } else { None }
+ }
+ pub fn is_folder(&self) -> bool {
+ matches!(self.kind, ItemKind::Folder)
+ }
+ /// (width, height) for visual items.
+ pub fn dimensions(&self) -> Option<(u32, u32)> {
+ match &self.kind {
+ ItemKind::Comp(c) => Some((c.width, c.height)),
+ ItemKind::Footage(f) if f.has_video => Some((f.width, f.height)),
+ ItemKind::Solid(s) => Some((s.width, s.height)),
+ _ => None,
+ }
+ }
+ pub fn duration(&self) -> Option<Tick> {
+ match &self.kind {
+ ItemKind::Comp(c) => Some(c.duration),
+ ItemKind::Footage(f) if f.kind != FootageKind::Still => Some(f.looped_duration()),
+ _ => None,
+ }
+ }
+ pub fn frame_rate(&self) -> Option<FrameRate> {
+ match &self.kind {
+ ItemKind::Comp(c) => Some(c.frame_rate),
+ ItemKind::Footage(f) if f.kind == FootageKind::Video || f.kind == FootageKind::Sequence => Some(f.frame_rate),
+ _ => None,
+ }
+ }
+}
+
+impl Default for Project {
+ fn default() -> Self {
+ Project {
+ schema: SCHEMA_VERSION,
+ settings: ProjectSettings::default(),
+ items: BTreeMap::new(),
+ next_id: 1,
+ render_queue: Vec::new(),
+ render_templates: Default::default(),
+ render_prefs: Default::default(),
+ }
+ }
+}
+
+impl Project {
+ /// Allocate an id (items, layers and property uids share one counter).
+ pub fn alloc(&mut self) -> u64 {
+ let id = self.next_id;
+ self.next_id += 1;
+ id
+ }
+ pub fn item(&self, id: ItemId) -> Option<&Item> {
+ self.items.get(&id)
+ }
+ pub fn item_mut(&mut self, id: ItemId) -> Option<&mut Item> {
+ self.items.get_mut(&id)
+ }
+ pub fn comp(&self, id: ItemId) -> Option<&Comp> {
+ self.items.get(&id)?.as_comp()
+ }
+ /// A shared handle on a comp: a snapshot that costs a reference count, not a deep copy of
+ /// its layers (frontends hold one across a frame instead of cloning the comp).
+ pub fn comp_arc(&self, id: ItemId) -> Option<Arc<Comp>> {
+ match &self.items.get(&id)?.kind {
+ ItemKind::Comp(c) => Some(c.clone()),
+ _ => None,
+ }
+ }
+ /// Mutable comp (copy-on-write).
+ pub fn comp_mut(&mut self, id: ItemId) -> Option<&mut Comp> {
+ match &mut self.items.get_mut(&id)?.kind {
+ ItemKind::Comp(c) => Some(Arc::make_mut(c)),
+ _ => None,
+ }
+ }
+ /// Adds an item; its size, frame rate and the like are brought within [`limits`] first.
+ pub fn add_item(&mut self, name: &str, label: Label, parent: Option<ItemId>, mut kind: ItemKind) -> ItemId {
+ limits::repair_kind(name, &mut kind, &mut vec![]);
+ let id = ItemId(self.alloc());
+ self.items.insert(id, Item { id, name: name.into(), label, comment: String::new(), parent, kind, proxy: None });
+ id
+ }
+ /// Children of a folder (None = root), folders first then by name.
+ pub fn children(&self, folder: Option<ItemId>) -> Vec<&Item> {
+ let mut v: Vec<&Item> = self.items.values().filter(|i| i.parent == folder).collect();
+ v.sort_by(|a, b| b.is_folder().cmp(&a.is_folder()).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())));
+ v
+ }
+ pub fn comps(&self) -> impl Iterator<Item = (&ItemId, &Comp)> {
+ self.items.iter().filter_map(|(id, i)| i.as_comp().map(|c| (id, c)))
+ }
+ pub fn find_by_name(&self, name: &str) -> Option<&Item> {
+ self.items.values().find(|i| i.name == name)
+ }
+ /// A numbered name for a copy of `base` that no project item has (Edit ▸ Duplicate): its
+ /// trailing number is dropped and the lowest free one from 2 is added (`Comp 1` → `Comp 2`,
+ /// `Name` → `Name 2`, then `Name 3`). Items for which `ignore` holds don't count.
+ pub fn numbered_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
+ let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
+ let taken = |n: &str| self.items.values().any(|i| i.name == n && !ignore(i));
+ (2u64..).map(|k| format!("{stem} {k}")).find(|n| !taken(n)).unwrap_or_default()
+ }
+ /// `base` when no project item has that name, else the next free numbered name as
+ /// [`Project::numbered_item_name`] gives it. Items for which `ignore` holds don't count.
+ pub fn unique_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
+ if self.items.values().any(|i| i.name == base && !ignore(i)) { self.numbered_item_name(base, ignore) } else { base.to_string() }
+ }
+ pub fn folder_named(&self, name: &str) -> Option<ItemId> {
+ self.items.values().find(|i| i.is_folder() && i.name == name).map(|i| i.id)
+ }
+ /// Find the comp that contains `layer`.
+ pub fn comp_of_layer(&self, layer: LayerId) -> Option<ItemId> {
+ self.comps().find(|(_, c)| c.layer(layer).is_some()).map(|(id, _)| *id)
+ }
+ /// The compositions whose layers use `item` as their source (footage, solid, 3D model or
+ /// precomp), each with how many of its layers do, ordered by comp name then id. Only direct
+ /// layers count, as in After Effects' Project panel ("used 3 times"): a solid inside a precomp
+ /// is used by the precomp, not by the comps that nest it. The total is the sum of the counts.
+ pub fn item_users(&self, item: ItemId) -> Vec<(ItemId, usize)> {
+ let mut users: Vec<(ItemId, String, usize)> = self
+ .items
+ .iter()
+ .filter_map(|(id, it)| {
+ let comp = it.as_comp()?;
+ let n = comp.layers.iter().filter(|l| l.source.item() == Some(item)).count();
+ (n > 0).then(|| (*id, it.name.to_lowercase(), n))
+ })
+ .collect();
+ users.sort_by(|a, b| a.1.cmp(&b.1).then(a.0.cmp(&b.0)));
+ users.into_iter().map(|(id, _, n)| (id, n)).collect()
+ }
+ /// Whether comp `inner` is (transitively) nested inside comp `outer` (to prevent cycles).
+ pub fn comp_contains(&self, outer: ItemId, inner: ItemId) -> bool {
+ // A walk with a stack and a visited set rather than recursion (#1237): a damaged project
+ // may hold a precomp cycle that doesn't pass `inner` (recursion never ended), a long
+ // chain must not use up the call stack, and comps shared by many paths are visited once
+ // (recursion re-walked them for every path).
+ if outer == inner {
+ return true;
+ }
+ let mut seen = std::collections::HashSet::new();
+ let mut stack = vec![outer];
+ while let Some(id) = stack.pop() {
+ if !seen.insert(id) {
+ continue;
+ }
+ let Some(c) = self.comp(id) else { continue };
+ for l in &c.layers {
+ if let LayerSource::Comp { item } = l.source {
+ if item == inner {
+ return true;
+ }
+ if !seen.contains(&item) {
+ stack.push(item);
+ }
+ }
+ }
+ }
+ false
+ }
+ /// Make sure `next_id` exceeds every id in the project (after loading or merging).
+ pub fn fix_next_id(&mut self) {
+ let mut m = self.next_id;
+ for (id, it) in &self.items {
+ // Saturating: a damaged file's ids must not overflow (the import then refuses it).
+ m = m.max(id.0.saturating_add(1));
+ if let ItemKind::Comp(c) = &it.kind {
+ for l in &c.layers {
+ m = m.max(l.id.0.saturating_add(1)).max(l.props.max_uid().saturating_add(1));
+ }
+ }
+ }
+ self.next_id = m;
+ }
+ /// Whether `other` holds the same content. An allocated id counts (an edit may hand it out
+ /// beyond the project, so it must stay taken). Shared compositions compare by pointer first,
+ /// so after a copy-on-write edit only the comps it touched are compared field by field.
+ pub fn same_content(&self, other: &Project) -> bool {
+ let item_eq = |a: &Item, b: &Item| {
+ let kind = match (&a.kind, &b.kind) {
+ (ItemKind::Comp(x), ItemKind::Comp(y)) => Arc::ptr_eq(x, y) || x == y,
+ (x, y) => x == y,
+ };
+ kind && a.id == b.id && a.name == b.name && a.label == b.label && a.comment == b.comment && a.parent == b.parent && a.proxy == b.proxy
+ };
+ self.schema == other.schema
+ && self.next_id == other.next_id
+ && self.settings == other.settings
+ && self.items.len() == other.items.len()
+ && self.items.iter().zip(&other.items).all(|((ka, a), (kb, b))| ka == kb && item_eq(a, b))
+ && self.render_queue == other.render_queue
+ && self.render_templates == other.render_templates
+ && self.render_prefs == other.render_prefs
+ }
+ /// The project file's text: the project with the version that wrote it (`savedBy`), checked
+ /// to read back, so a save never writes a file that can't be opened. Values JSON can't hold
+ /// (NaN or infinity, written as `null`, and nesting too deep to parse) are refused on every
+ /// save; debug builds also read the text back.
+ pub fn to_file_json(&self) -> Result<String, ProjectError> {
+ self.to_file_json_with_view(&SavedView::default())
+ }
+ /// [`Project::to_file_json`] that also records the open compositions ([`SavedView`]).
+ pub fn to_file_json_with_view(&self, view: &SavedView) -> Result<String, ProjectError> {
+ if self.schema > SCHEMA_VERSION {
+ return Err(ProjectError::Invalid(format!(
+ "the project can't be saved: it holds a value a project file can't store (project schema {} is newer than this version supports ({SCHEMA_VERSION}))",
+ self.schema
+ )));
+ }
+ #[derive(Serialize)]
+ struct File<'a> {
+ #[serde(rename = "savedBy")]
+ saved_by: &'a str,
+ #[serde(flatten)]
+ view: &'a SavedView,
+ #[serde(flatten)]
+ project: &'a Project,
+ }
+ let file = File { saved_by: APP_VERSION, view, project: self };
+ file_check::check(&file)
+ .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
+ let text = serde_json::to_string_pretty(&file).map_err(|e| ProjectError::Invalid(format!("the project can't be saved: {e}")))?;
+ #[cfg(debug_assertions)]
+ Project::from_json(&text)
+ .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
+ Ok(text)
+ }
+ pub fn to_json(&self) -> String {
+ serde_json::to_string_pretty(self).unwrap_or_default()
+ }
+ /// [`Project::to_json`] without indentation: smaller and faster (auto-saves).
+ pub fn to_json_compact(&self) -> String {
+ serde_json::to_string(self).unwrap_or_default()
+ }
+ pub fn from_json(s: &str) -> Result<Project, ProjectError> {
+ Project::from_json_repaired(s).map(|(p, _)| p)
+ }
+ /// [`Project::from_json`], also returning one line per value that was out of [`limits`] and
+ /// was corrected (a composition of a billion pixels, a zero frame rate…), so a corrupt or
+ /// hostile file still opens, within bounds, and the user can be told what changed.
+ pub fn from_json_repaired(s: &str) -> Result<(Project, Vec<String>), ProjectError> {
+ let mut p: Project = serde_json::from_str(s).map_err(|e| ProjectError::Invalid(e.to_string()))?;
+ if p.schema > SCHEMA_VERSION {
+ return Err(ProjectError::Invalid(format!("project schema {} is newer than this version supports ({SCHEMA_VERSION})", p.schema)));
+ }
+ p.fix_next_id();
+ let mut notes = vec![];
+ for item in p.items.values_mut() {
+ limits::repair_item(item, &mut notes);
+ }
+ Ok((p, notes))
+ }
+}
diff --git a/crates/project/src/layer.rs b/crates/project/src/layer.rs
new file mode 100644
index 000000000..b7286a6d5
--- /dev/null
+++ b/crates/project/src/layer.rs
@@ -0,0 +1,370 @@
+use super::item::{ItemId, LayerId};
+use super::settings::Marker;
+use super::*;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum LightKind {
+ Parallel,
+ Spot,
+ #[default]
+ Point,
+ Ambient,
+ Environment,
+}
+
+impl LightKind {
+ pub const ALL: [LightKind; 5] = [LightKind::Parallel, LightKind::Spot, LightKind::Point, LightKind::Ambient, LightKind::Environment];
+ pub fn label(self) -> &'static str {
+ match self {
+ LightKind::Parallel => "Parallel",
+ LightKind::Spot => "Spot",
+ LightKind::Point => "Point",
+ LightKind::Ambient => "Ambient",
+ LightKind::Environment => "Environment",
+ }
+ }
+}
+
+/// A parametric 3D primitive (Layer ▸ New ▸ Cube/Sphere/Plane/Torus/Cone/Cylinder).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum PrimitiveKind {
+ #[default]
+ Cube,
+ Sphere,
+ Plane,
+ Torus,
+ Cone,
+ Cylinder,
+}
+
+impl PrimitiveKind {
+ pub const ALL: [PrimitiveKind; 6] =
+ [PrimitiveKind::Cube, PrimitiveKind::Sphere, PrimitiveKind::Plane, PrimitiveKind::Torus, PrimitiveKind::Cone, PrimitiveKind::Cylinder];
+ pub fn label(self) -> &'static str {
+ match self {
+ PrimitiveKind::Cube => "Cube",
+ PrimitiveKind::Sphere => "Sphere",
+ PrimitiveKind::Plane => "Plane",
+ PrimitiveKind::Torus => "Torus",
+ PrimitiveKind::Cone => "Cone",
+ PrimitiveKind::Cylinder => "Cylinder",
+ }
+ }
+ pub fn parse(s: &str) -> Option<PrimitiveKind> {
+ PrimitiveKind::ALL.into_iter().find(|k| k.label().eq_ignore_ascii_case(s.trim()))
+ }
+}
+
+/// What a layer shows.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum LayerSource {
+ /// Footage item (video, still, sequence, audio).
+ Footage {
+ item: ItemId,
+ },
+ /// Nested composition (precomp).
+ Comp {
+ item: ItemId,
+ },
+ /// Solid item (solids also back adjustment layers).
+ Solid {
+ item: ItemId,
+ },
+ Text,
+ Shape,
+ Null,
+ Camera,
+ Light {
+ kind: LightKind,
+ },
+ /// An imported 3D model (a footage item of kind [`FootageKind::Model`]; Advanced 3D).
+ Model {
+ item: ItemId,
+ },
+ /// A parametric 3D primitive (Advanced 3D).
+ Primitive {
+ kind: PrimitiveKind,
+ },
+}
+
+impl LayerSource {
+ pub fn item(&self) -> Option<ItemId> {
+ match self {
+ LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Solid { item } | LayerSource::Model { item } => Some(*item),
+ _ => None,
+ }
+ }
+ pub fn type_name(&self) -> &'static str {
+ match self {
+ LayerSource::Footage { .. } => "Footage",
+ LayerSource::Comp { .. } => "Composition",
+ LayerSource::Solid { .. } => "Solid",
+ LayerSource::Text => "Text",
+ LayerSource::Shape => "Shape",
+ LayerSource::Null => "Null",
+ LayerSource::Camera => "Camera",
+ LayerSource::Light { .. } => "Light",
+ LayerSource::Model { .. } => "3D Model",
+ LayerSource::Primitive { .. } => "3D Primitive",
+ }
+ }
+ /// Layers with pixels (cameras, lights and nulls have none).
+ pub fn is_av(&self) -> bool {
+ !matches!(self, LayerSource::Camera | LayerSource::Light { .. } | LayerSource::Null)
+ }
+ /// A 3D model or primitive layer (meshes; drawn by the Advanced 3D renderer).
+ pub fn is_model(&self) -> bool {
+ matches!(self, LayerSource::Model { .. } | LayerSource::Primitive { .. })
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Quality {
+ #[default]
+ Best,
+ Draft,
+ Wireframe,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Sampling {
+ #[default]
+ Bilinear,
+ Bicubic,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum FrameBlend {
+ #[default]
+ Off,
+ FrameMix,
+ PixelMotion,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Switches {
+ pub video: bool,
+ pub audio: bool,
+ pub solo: bool,
+ pub locked: bool,
+ pub shy: bool,
+ /// Collapse transformations (precomps) / continuously rasterize (vector layers).
+ pub collapse: bool,
+ pub quality: Quality,
+ pub sampling: Sampling,
+ pub effects: bool,
+ pub frame_blend: FrameBlend,
+ pub motion_blur: bool,
+ pub adjustment: bool,
+ pub three_d: bool,
+ pub guide: bool,
+}
+
+impl Default for Switches {
+ fn default() -> Self {
+ Switches {
+ video: true,
+ audio: true,
+ solo: false,
+ locked: false,
+ shy: false,
+ collapse: false,
+ quality: Quality::Best,
+ sampling: Sampling::Bilinear,
+ effects: true,
+ frame_blend: FrameBlend::Off,
+ motion_blur: false,
+ adjustment: false,
+ three_d: false,
+ guide: false,
+ }
+ }
+}
+
+// What a frame's pixels depend on. Caches key on it: the Audio, Lock and Shy switches and Hide
+// Shy Layers don't change pixels, so toggling them keeps cached frames (#103).
+
+impl Switches {
+ /// These switches with Audio, Lock and Shy at their defaults.
+ pub fn pixels(&self) -> Switches {
+ Switches { audio: true, locked: false, shy: false, ..self.clone() }
+ }
+}
+
+impl Layer {
+ /// Draws the same pixels as `o`: equal but for the Audio, Lock and Shy switches.
+ pub fn same_pixels(&self, o: &Layer) -> bool {
+ // Every field (no `..`: a new field must be considered here); the property tree last.
+ let Layer {
+ id,
+ name,
+ source,
+ label,
+ comment,
+ start_time,
+ in_point,
+ out_point,
+ stretch,
+ switches,
+ blend_mode,
+ preserve_transparency,
+ track_matte,
+ parent,
+ markers,
+ markers_locked,
+ auto_orient,
+ environment,
+ environment_background,
+ props,
+ } = self;
+ *id == o.id
+ && *name == o.name
+ && *source == o.source
+ && *label == o.label
+ && *comment == o.comment
+ && *start_time == o.start_time
+ && *in_point == o.in_point
+ && *out_point == o.out_point
+ && *stretch == o.stretch
+ && switches.pixels() == o.switches.pixels()
+ && *blend_mode == o.blend_mode
+ && *preserve_transparency == o.preserve_transparency
+ && *track_matte == o.track_matte
+ && *parent == o.parent
+ && *markers == o.markers
+ && *markers_locked == o.markers_locked
+ && *auto_orient == o.auto_orient
+ && *environment == o.environment
+ && *environment_background == o.environment_background
+ && *props == o.props
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum MatteKind {
+ #[default]
+ Alpha,
+ AlphaInverted,
+ Luma,
+ LumaInverted,
+}
+
+impl MatteKind {
+ pub const ALL: [MatteKind; 4] = [MatteKind::Alpha, MatteKind::AlphaInverted, MatteKind::Luma, MatteKind::LumaInverted];
+ pub fn label(self) -> &'static str {
+ match self {
+ MatteKind::Alpha => "Alpha Matte",
+ MatteKind::AlphaInverted => "Alpha Inverted Matte",
+ MatteKind::Luma => "Luma Matte",
+ MatteKind::LumaInverted => "Luma Inverted Matte",
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct TrackMatte {
+ pub layer: LayerId,
+ pub kind: MatteKind,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AutoOrient {
+ #[default]
+ Off,
+ AlongPath,
+ TowardsCamera,
+ TowardsPointOfInterest,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Layer {
+ pub id: LayerId,
+ pub name: String,
+ pub source: LayerSource,
+ pub label: Label,
+ #[serde(default)]
+ pub comment: String,
+ /// Comp time where the layer's time 0 sits.
+ pub start_time: Tick,
+ /// Visible span in comp time.
+ pub in_point: Tick,
+ pub out_point: Tick,
+ /// Time stretch in percent (100 = normal, negative = reversed).
+ pub stretch: f64,
+ pub switches: Switches,
+ pub blend_mode: BlendMode,
+ #[serde(default)]
+ pub preserve_transparency: bool,
+ #[serde(default)]
+ pub track_matte: Option<TrackMatte>,
+ #[serde(default)]
+ pub parent: Option<LayerId>,
+ #[serde(default)]
+ pub markers: Vec<Marker>,
+ /// Layer ▸ Markers ▸ Lock Markers.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub markers_locked: bool,
+ #[serde(default)]
+ pub auto_orient: AutoOrient,
+ /// Layer ▸ Environment Layer: the layer is the environment (image-based light and
+ /// reflections) of Advanced 3D comps instead of being drawn.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub environment: bool,
+ /// Layer ▸ Light ▸ Create Environment Light Background Layer: the layer's (equirectangular)
+ /// image is drawn as the 3D scene's backdrop, seen through the camera, instead of as a card.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub environment_background: bool,
+ /// The property tree (Masks, Effects, Transform, Text, Contents, Camera/Light options…).
+ pub props: PropGroup,
+}
+
+impl Layer {
+ pub fn is_active_at(&self, t: Tick) -> bool {
+ t >= self.in_point && t < self.out_point
+ }
+
+ /// Layer time for a comp time (stretch-aware).
+ pub fn layer_time(&self, comp_t: Tick) -> Tick {
+ let d = comp_t - self.start_time;
+ if (self.stretch - 100.0).abs() < 1e-9 { d } else { Tick((d.0 as f64 * 100.0 / self.stretch) as i64) }
+ }
+
+ /// Comp time for a layer time.
+ pub fn comp_time(&self, layer_t: Tick) -> Tick {
+ if (self.stretch - 100.0).abs() < 1e-9 { self.start_time + layer_t } else { self.start_time + Tick((layer_t.0 as f64 * self.stretch / 100.0) as i64) }
+ }
+
+ pub fn transform(&self) -> Option<&PropGroup> {
+ self.props.sub("transform")
+ }
+
+ pub fn transform_mut(&mut self) -> Option<&mut PropGroup> {
+ self.props.sub_mut("transform")
+ }
+
+ pub fn effects(&self) -> Option<&PropGroup> {
+ self.props.sub("effects")
+ }
+
+ pub fn masks(&self) -> Option<&PropGroup> {
+ self.props.sub("masks")
+ }
+
+ pub fn is_camera(&self) -> bool {
+ matches!(self.source, LayerSource::Camera)
+ }
+
+ pub fn is_light(&self) -> bool {
+ matches!(self.source, LayerSource::Light { .. })
+ }
+
+ /// The layer participates in 3D (3D switch, or cameras/lights which are always 3D).
+ pub fn is_3d(&self) -> bool {
+ self.switches.three_d || self.is_camera() || self.is_light()
+ }
+
+ pub fn has_video(&self) -> bool {
+ self.source.is_av() && self.switches.video
+ }
+}
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 822fc7f75..8e1409c37 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -29,1393 +29,20 @@ use serde::{Deserialize, Serialize};
pub use effectcraft_keyframe as keyframe;
pub use effectcraft_keyframe::{Keyframe, Value};
-/// The project file schema. 2: effects on layers without a source rectangle (shape, text)
-/// measure positions from the top-left of their comp-sized bounds (effect space), not from
-/// the layer's origin; projects from schema 1 are converted when opened (#227).
-pub const SCHEMA_VERSION: u32 = 2;
-
-/// The first schema in which effect positions are in effect space (see [`SCHEMA_VERSION`]).
-pub const SCHEMA_EFFECT_SPACE: u32 = 2;
-
-/// The EffectCraft version, written into project files as `savedBy`.
-pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
-
-/// The EffectCraft version that wrote a project file (its `savedBy`), when it says.
-pub fn saved_by(text: &str) -> Option<String> {
- #[derive(Deserialize)]
- struct Meta {
- #[serde(rename = "savedBy", default)]
- saved_by: Option<String>,
- }
- serde_json::from_str::<Meta>(text).ok()?.saved_by
-}
-
-/// The compositions that were open when a project file was saved and their current times
-/// (`activeComp`, `openComps` and `compTimes` next to `savedBy`), so it reopens where it was left
-/// (#748, #1714). Editor state rather than project
-/// content: opening a comp doesn't make the project unsaved, and it isn't part of
-/// [`Project`]. Older files have none; older versions ignore it.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SavedView {
- /// The comp shown in the viewer and the Timeline.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub active_comp: Option<ItemId>,
- /// The open comps (Timeline tabs), in tab order.
- #[serde(skip_serializing_if = "Vec::is_empty")]
- pub open_comps: Vec<ItemId>,
- /// Each comp's current time, so a project reopens on the frame it was saved at rather than
- /// at 0, where its layers may not have started yet (#1714).
- #[serde(skip_serializing_if = "BTreeMap::is_empty")]
- pub comp_times: BTreeMap<ItemId, Tick>,
-}
-
-/// The view a project file was saved with ([`SavedView`]); empty for older files. Values that
-/// aren't ids are ignored (whether an id still names a comp is up to the caller).
-pub fn saved_view(text: &str) -> SavedView {
- #[derive(Deserialize)]
- struct Meta {
- #[serde(rename = "activeComp", default)]
- active_comp: Option<serde_json::Value>,
- #[serde(rename = "openComps", default)]
- open_comps: Option<serde_json::Value>,
- #[serde(rename = "compTimes", default)]
- comp_times: Option<serde_json::Value>,
- }
- let Ok(m) = serde_json::from_str::<Meta>(text) else { return SavedView::default() };
- SavedView {
- active_comp: m.active_comp.as_ref().and_then(serde_json::Value::as_u64).map(ItemId),
- open_comps: m
- .open_comps
- .as_ref()
- .and_then(serde_json::Value::as_array)
- .map_or_else(Vec::new, |a| a.iter().filter_map(serde_json::Value::as_u64).map(ItemId).collect()),
- comp_times: m
- .comp_times
- .as_ref()
- .and_then(serde_json::Value::as_object)
- .map_or_else(BTreeMap::new, |o| o.iter().filter_map(|(k, v)| Some((ItemId(k.parse().ok()?), Tick(v.as_i64()?)))).collect()),
- }
-}
-
-/// Whether version `a` (`major.minor.patch`, pre-release suffixes ignored) is newer than `b`.
-pub fn is_newer_version(a: &str, b: &str) -> bool {
- let parts = |v: &str| -> [u64; 3] {
- let mut n = v.split(['-', '+']).next().unwrap_or("").split('.').map(|x| x.parse().unwrap_or(0));
- [n.next().unwrap_or(0), n.next().unwrap_or(0), n.next().unwrap_or(0)]
- };
- parts(a) > parts(b)
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct ItemId(pub u64);
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct LayerId(pub u64);
-
-#[derive(Debug, thiserror::Error)]
-pub enum ProjectError {
- #[error("no item {0:?}")]
- NoItem(ItemId),
- #[error("item {0:?} is not a composition")]
- NotComp(ItemId),
- #[error("no layer {0:?}")]
- NoLayer(LayerId),
- #[error("no property `{0}`")]
- NoProperty(String),
- #[error("{0}")]
- Invalid(String),
-}
-
-/// Project bit depth.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum BitDepth {
- #[default]
- Bpc8,
- Bpc16,
- Bpc32,
-}
-
-impl BitDepth {
- pub fn label(self) -> &'static str {
- match self {
- BitDepth::Bpc8 => "8 bpc",
- BitDepth::Bpc16 => "16 bpc",
- BitDepth::Bpc32 => "32 bpc",
- }
- }
- pub fn next(self) -> BitDepth {
- match self {
- BitDepth::Bpc8 => BitDepth::Bpc16,
- BitDepth::Bpc16 => BitDepth::Bpc32,
- BitDepth::Bpc32 => BitDepth::Bpc8,
- }
- }
- pub fn is_float(self) -> bool {
- self == BitDepth::Bpc32
- }
- /// Quantisation levels per channel of the integer depths (8 bpc: 255; 16 bpc: 32768, After
- /// Effects' "15 + 1" bit range), `None` for 32 bpc float.
- pub fn levels(self) -> Option<f32> {
- match self {
- BitDepth::Bpc8 => Some(255.0),
- BitDepth::Bpc16 => Some(32768.0),
- BitDepth::Bpc32 => None,
- }
- }
- pub fn bits(self) -> u32 {
- match self {
- BitDepth::Bpc8 => 8,
- BitDepth::Bpc16 => 16,
- BitDepth::Bpc32 => 32,
- }
- }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum TimeDisplayStyle {
- #[default]
- Timecode,
- Frames,
- /// Feet + Frames, 35 mm film (16 frames per foot).
- Feet35,
- /// Feet + Frames, 16 mm film (40 frames per foot).
- Feet16,
-}
-
-impl TimeDisplayStyle {
- /// Frames per foot of the Feet + Frames styles.
- pub fn frames_per_foot(self) -> Option<i64> {
- match self {
- TimeDisplayStyle::Feet35 => Some(16),
- TimeDisplayStyle::Feet16 => Some(40),
- _ => None,
- }
- }
- pub fn id(self) -> &'static str {
- match self {
- TimeDisplayStyle::Timecode => "timecode",
- TimeDisplayStyle::Frames => "frames",
- TimeDisplayStyle::Feet35 => "feet35",
- TimeDisplayStyle::Feet16 => "feet16",
- }
- }
- pub fn parse(s: &str) -> Option<TimeDisplayStyle> {
- let k: String = s.chars().filter(char::is_ascii_alphanumeric).collect::<String>().to_ascii_lowercase();
- match k.as_str() {
- "timecode" => Some(TimeDisplayStyle::Timecode),
- "frames" => Some(TimeDisplayStyle::Frames),
- "feet35" | "feetframes" | "feetandframes" | "feet35mm" | "35mm" | "feetframes35mm" => Some(TimeDisplayStyle::Feet35),
- "feet16" | "feet16mm" | "16mm" | "feetframes16mm" => Some(TimeDisplayStyle::Feet16),
- _ => None,
- }
- }
-}
-
-/// Project Settings ▸ Color ▸ Color Engine.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum ColorEngine {
- /// Built-in colour management (ICC-style working spaces).
- #[default]
- Adobe,
- /// OCIO managed, with the built-in configuration (ACES working spaces).
- Ocio,
-}
-
-/// Project Settings ▸ Color ▸ HDR: how over-range (HDR) values reach a standard-dynamic-range
-/// display or output.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum HdrMode {
- /// Values above 1.0 clip.
- #[default]
- Clip,
- /// Highlights above 80% are companded (an exponential knee) into the remaining range.
- Compand,
- /// Extended Reinhard tone mapping of luminance (white at 4.0).
- ToneMap,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct ProjectSettings {
- pub bit_depth: BitDepth,
- /// Linearize Working Space: the working space uses linear light (1.0 gamma) for everything
- /// (sources, effects, blending). Needs a working space.
- pub linearize: bool,
- /// Working Space (colour management). `None` = no colour management.
- #[serde(default)]
- pub working_space: Option<ColorSpace>,
- /// Blend Colors Using 1.0 Gamma: layers blend in linear light (sources and effects stay in
- /// the working space's encoding).
- #[serde(default)]
- pub blend_linear: bool,
- pub time_display: TimeDisplayStyle,
- /// Frame numbering starts at 0 (or 1).
- pub frame_start: i64,
- pub audio_sample_rate: u32,
- /// Video Rendering and Effects ▸ Use: Mercury GPU Acceleration (`true`, the default; used
- /// when a GPU adapter exists) or Mercury Software Only (`false`, the CPU compositor).
- #[serde(default = "yes")]
- pub gpu_acceleration: bool,
- /// The project's comment (Metadata panel).
- #[serde(default, skip_serializing_if = "String::is_empty")]
- pub comment: String,
- /// Color Engine (Adobe-style built-in or OCIO with ACES working spaces).
- #[serde(default)]
- pub color_engine: ColorEngine,
- /// HDR handling for standard-dynamic-range output (display and renders).
- #[serde(default)]
- pub hdr: HdrMode,
- /// The space the top-level comp is output in (renders and the viewer's source). `None` =
- /// sRGB; Rec. 2100 PQ / HLG give HDR output.
- #[serde(default)]
- pub output_space: Option<ColorSpace>,
- /// Working Gamma, 2.2 or 2.4 (`app.project.workingGamma`): with no working space, the curve
- /// Interpret As Linear Light footage is encoded with and Blend Colors Using 1.0 Gamma
- /// linearizes with: the sRGB curve at 2.2, a pure 2.4 power curve at 2.4. Ignored with a
- /// working space (as in After Effects).
- #[serde(default = "gamma_22")]
- pub working_gamma: f64,
-}
-
-fn gamma_22() -> f64 {
- 2.2
-}
-
-impl ProjectSettings {
- /// Working Gamma is 2.4 (anything else reads as 2.2).
- pub fn working_gamma_24(&self) -> bool {
- (self.working_gamma - 2.4).abs() < 0.05
- }
-}
-
-impl Default for ProjectSettings {
- fn default() -> Self {
- ProjectSettings {
- bit_depth: BitDepth::Bpc8,
- linearize: false,
- working_space: None,
- blend_linear: false,
- time_display: TimeDisplayStyle::Timecode,
- frame_start: 0,
- audio_sample_rate: 48_000,
- gpu_acceleration: true,
- comment: String::new(),
- color_engine: ColorEngine::Adobe,
- hdr: HdrMode::Clip,
- output_space: None,
- working_gamma: 2.2,
- }
- }
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct Marker {
- pub time: Tick,
- #[serde(default)]
- pub duration: Tick,
- #[serde(default)]
- pub comment: String,
- #[serde(default)]
- pub label: Label,
- #[serde(default)]
- pub chapter: String,
- #[serde(default)]
- pub url: String,
- #[serde(default)]
- pub protected: bool,
- /// Web link frame target (`_blank`, a frame name…).
- #[serde(default, skip_serializing_if = "String::is_empty")]
- pub frame_target: String,
- /// Flash/video cue point (Event or Navigation) with name and parameters.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub cue_point: Option<CuePoint>,
-}
-
-/// A marker's cue point (Composition/Layer Marker dialog ▸ Cue Point).
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct CuePoint {
- pub name: String,
- /// Navigation (true) or Event cue point.
- #[serde(default)]
- pub navigation: bool,
- /// (name, value) parameter pairs.
- #[serde(default)]
- pub params: Vec<(String, String)>,
-}
-
-/// 3D renderer of a composition.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Renderer {
- #[default]
- Classic3D,
- Advanced3D,
-}
-
-/// A composition's Resolution (the Composition panel's Resolution/Down Sample Factor popup, View ▸
-/// Resolution): how many of its pixels the viewer renders. Auto follows the magnification.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Resolution {
- #[default]
- Auto,
- Full,
- Half,
- Third,
- Quarter,
- /// View ▸ Resolution ▸ Custom: render every n-th pixel (2..=40).
- Custom(u8),
-}
-
-impl Resolution {
- pub const ALL: [Resolution; 5] = [Resolution::Auto, Resolution::Full, Resolution::Half, Resolution::Third, Resolution::Quarter];
- pub fn label(self) -> &'static str {
- match self {
- Resolution::Auto => "Auto",
- Resolution::Full => "Full",
- Resolution::Half => "Half",
- Resolution::Third => "Third",
- Resolution::Quarter => "Quarter",
- Resolution::Custom(_) => "Custom",
- }
- }
- pub fn is_auto(&self) -> bool {
- *self == Resolution::Auto
- }
- /// The down-sample factor (render every n-th pixel); `None` for Auto.
- pub fn factor(self) -> Option<u8> {
- match self {
- Resolution::Auto => None,
- Resolution::Full => Some(1),
- Resolution::Half => Some(2),
- Resolution::Third => Some(3),
- Resolution::Quarter => Some(4),
- Resolution::Custom(n) => Some(n),
- }
- }
- /// The resolution that renders every `n`-th pixel (1 = Full … 4 = Quarter; up to 40).
- pub fn from_factor(n: u64) -> Resolution {
- match n.clamp(1, 40) {
- 1 => Resolution::Full,
- 2 => Resolution::Half,
- 3 => Resolution::Third,
- 4 => Resolution::Quarter,
- n => Resolution::Custom(n as u8),
- }
- }
- /// Render scale for a viewer magnification (and display pixel density).
- pub fn scale(self, zoom: f32, ppp: f32) -> f64 {
- match self.factor() {
- Some(n) => 1.0 / f64::from(n.clamp(1, 40)),
- // As in After Effects, Auto renders the pixels the magnification needs: the coarsest
- // whole factor that still gives every screen pixel a rendered one (Full above 50 %,
- // Half down to 33.3 %, Third down to 25 %, Quarter below), never fewer (#417).
- None => {
- let n = (1.0 / (zoom * ppp) as f64 + 1e-3).floor();
- if n >= 1.0 { 1.0 / n.min(4.0) } else { 1.0 }
- }
- }
- }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Comp {
- pub width: u32,
- pub height: u32,
- pub pixel_aspect: f64,
- pub frame_rate: FrameRate,
- pub duration: Tick,
- /// Start timecode/frame shown for time 0.
- pub display_start: Tick,
- pub background: [f32; 3],
- pub work_area: (Tick, Tick),
- /// Layer #1 first (top of the stack).
- pub layers: Vec<Layer>,
- #[serde(default)]
- pub markers: Vec<Marker>,
- pub shutter_angle: f64,
- pub shutter_phase: f64,
- /// Samples Per Frame: the minimum motion-blur samples (and the count for 3D layers).
- pub motion_blur_samples: u32,
- /// Adaptive Sample Limit (Composition Settings ▸ Advanced): the most samples a 2D layer gets
- /// when it moves far within the shutter.
- #[serde(default = "adaptive_limit_default")]
- pub motion_blur_adaptive_limit: u32,
- #[serde(default)]
- pub renderer: Renderer,
- /// Comp switches (timeline toolbar).
- #[serde(default)]
- pub hide_shy: bool,
- #[serde(default = "yes")]
- pub enable_motion_blur: bool,
- #[serde(default = "yes")]
- pub enable_frame_blending: bool,
- #[serde(default)]
- pub draft_3d: bool,
- /// Composition Settings ▸ Advanced ▸ Preserve frame rate when nested or in render queue:
- /// nested in another comp, or rendered at another rate, it shows only its own frames.
- #[serde(default)]
- pub preserve_frame_rate: bool,
- /// Composition Settings ▸ Advanced ▸ Preserve resolution when nested: nested in a comp
- /// previewed at a lower resolution, it still renders at full size.
- #[serde(default)]
- pub preserve_resolution: bool,
- #[serde(default)]
- pub poster_time: Tick,
- /// Global Light for layer styles (Layer ▸ Layer Styles ▸ Blending Options).
- #[serde(default)]
- pub global_light: styles::GlobalLight,
- /// Viewer guides (View ▸ Add Guide…), in comp pixels.
- #[serde(default, skip_serializing_if = "Vec::is_empty")]
- pub guides: Vec<Guide>,
- /// Essential Graphics: the controls this comp exposes to instances and templates.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub essential: Option<essential::EssentialGraphics>,
- /// The Composition panel's Resolution, saved with the project as in After Effects. It changes
- /// what the viewer renders, not the comp's pixels ([`Comp::same_pixels`]), and stays out of
- /// the undo history.
- #[serde(default, skip_serializing_if = "Resolution::is_auto")]
- pub resolution: Resolution,
-}
-
-/// A viewer guide line: vertical guides sit at an x position, horizontal ones at a y position.
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Guide {
- pub vertical: bool,
- /// Comp pixels, or percent of the comp's width (vertical) / height (horizontal) when
- /// [`Guide::percent`] is set.
- pub position: f64,
- /// A percentage guide (After Effects 26.5): `position` is a percent of the comp's size, so the
- /// guide keeps its relative place when the comp is resized. Absent in older projects.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub percent: bool,
-}
-
-impl Guide {
- /// The comp's extent along this guide's axis, never zero.
- fn extent(&self, width: u32, height: u32) -> f64 {
- f64::from(if self.vertical { width } else { height }).max(1.0)
- }
-
- /// The guide's position in comp pixels for a comp of this size.
- pub fn px(&self, width: u32, height: u32) -> f64 {
- if self.percent { self.position / 100.0 * self.extent(width, height) } else { self.position }
- }
-
- /// Place the guide at `px` comp pixels, keeping its unit.
- pub fn set_px(&mut self, px: f64, width: u32, height: u32) {
- self.position = if self.percent { px / self.extent(width, height) * 100.0 } else { px };
- }
-
- /// Switch between pixels and percent without moving the guide on the comp.
- pub fn set_percent(&mut self, percent: bool, width: u32, height: u32) {
- let px = self.px(width, height);
- self.percent = percent;
- self.set_px(px, width, height);
- }
-}
-
-fn yes() -> bool {
- true
-}
-
-fn adaptive_limit_default() -> u32 {
- 128
-}
-
-impl Comp {
- pub fn new(width: u32, height: u32, frame_rate: FrameRate, duration: Tick) -> Comp {
- Comp {
- width,
- height,
- pixel_aspect: 1.0,
- frame_rate,
- duration,
- display_start: Tick::ZERO,
- background: [0.0, 0.0, 0.0],
- work_area: (Tick::ZERO, duration),
- layers: vec![],
- markers: vec![],
- shutter_angle: 180.0,
- shutter_phase: -90.0,
- motion_blur_samples: 16,
- motion_blur_adaptive_limit: 128,
- renderer: Renderer::Classic3D,
- hide_shy: false,
- enable_motion_blur: true,
- enable_frame_blending: true,
- draft_3d: false,
- preserve_frame_rate: false,
- preserve_resolution: false,
- poster_time: Tick::ZERO,
- guides: vec![],
- global_light: styles::GlobalLight::default(),
- essential: None,
- resolution: Resolution::Auto,
- }
- }
- /// Whether the composition has a frame at its time `t`: nested, it shows nothing before it
- /// starts or after it ends (a precomp layer trimmed or remapped past it).
- pub fn covers(&self, t: Tick) -> bool {
- t >= Tick::ZERO && t < self.duration
- }
- /// A new, empty composition with this one's settings (frame rate, pixel aspect, background,
- /// motion blur, frame blending and the 3D renderer), as Pre-compose makes.
- pub fn nested_like(&self, width: u32, height: u32, duration: Tick) -> Comp {
- Comp {
- pixel_aspect: self.pixel_aspect,
- background: self.background,
- shutter_angle: self.shutter_angle,
- shutter_phase: self.shutter_phase,
- motion_blur_samples: self.motion_blur_samples,
- motion_blur_adaptive_limit: self.motion_blur_adaptive_limit,
- renderer: self.renderer,
- enable_motion_blur: self.enable_motion_blur,
- enable_frame_blending: self.enable_frame_blending,
- preserve_frame_rate: self.preserve_frame_rate,
- preserve_resolution: self.preserve_resolution,
- ..Comp::new(width, height, self.frame_rate, duration)
- }
- }
- pub fn layer(&self, id: LayerId) -> Option<&Layer> {
- self.layers.iter().find(|l| l.id == id)
- }
- pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
- self.layers.iter_mut().find(|l| l.id == id)
- }
- /// 1-based layer number (#) of a layer.
- pub fn index_of(&self, id: LayerId) -> Option<usize> {
- self.layers.iter().position(|l| l.id == id).map(|i| i + 1)
- }
- pub fn layer_by_name(&self, name: &str) -> Option<&Layer> {
- self.layers.iter().find(|l| l.name == name)
- }
- pub fn frame_duration(&self) -> Tick {
- self.frame_rate.frame_duration()
- }
- /// Any 3D layer present (camera/lights or a 3D switch).
- pub fn has_3d(&self) -> bool {
- self.layers.iter().any(|l| l.switches.three_d || matches!(l.source, LayerSource::Camera | LayerSource::Light { .. }))
- }
- /// The active camera at `t`: the topmost enabled camera layer active at that time.
- pub fn active_camera(&self, t: Tick) -> Option<&Layer> {
- self.layers.iter().find(|l| matches!(l.source, LayerSource::Camera) && l.switches.video && l.is_active_at(t))
- }
- /// Unique layer name with a numeric suffix (`Shape Layer 2`).
- pub fn unique_layer_name(&self, base: &str) -> String {
- if !self.layers.iter().any(|l| l.name == base) {
- return base.to_string();
- }
- let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
- (2..).map(|i| format!("{stem} {i}")).find(|n| !self.layers.iter().any(|l| &l.name == n)).unwrap_or_default()
- }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum LightKind {
- Parallel,
- Spot,
- #[default]
- Point,
- Ambient,
- Environment,
-}
-
-impl LightKind {
- pub const ALL: [LightKind; 5] = [LightKind::Parallel, LightKind::Spot, LightKind::Point, LightKind::Ambient, LightKind::Environment];
- pub fn label(self) -> &'static str {
- match self {
- LightKind::Parallel => "Parallel",
- LightKind::Spot => "Spot",
- LightKind::Point => "Point",
- LightKind::Ambient => "Ambient",
- LightKind::Environment => "Environment",
- }
- }
-}
-
-/// A parametric 3D primitive (Layer ▸ New ▸ Cube/Sphere/Plane/Torus/Cone/Cylinder).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum PrimitiveKind {
- #[default]
- Cube,
- Sphere,
- Plane,
- Torus,
- Cone,
- Cylinder,
-}
-
-impl PrimitiveKind {
- pub const ALL: [PrimitiveKind; 6] =
- [PrimitiveKind::Cube, PrimitiveKind::Sphere, PrimitiveKind::Plane, PrimitiveKind::Torus, PrimitiveKind::Cone, PrimitiveKind::Cylinder];
- pub fn label(self) -> &'static str {
- match self {
- PrimitiveKind::Cube => "Cube",
- PrimitiveKind::Sphere => "Sphere",
- PrimitiveKind::Plane => "Plane",
- PrimitiveKind::Torus => "Torus",
- PrimitiveKind::Cone => "Cone",
- PrimitiveKind::Cylinder => "Cylinder",
- }
- }
- pub fn parse(s: &str) -> Option<PrimitiveKind> {
- PrimitiveKind::ALL.into_iter().find(|k| k.label().eq_ignore_ascii_case(s.trim()))
- }
-}
-
-/// What a layer shows.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum LayerSource {
- /// Footage item (video, still, sequence, audio).
- Footage {
- item: ItemId,
- },
- /// Nested composition (precomp).
- Comp {
- item: ItemId,
- },
- /// Solid item (solids also back adjustment layers).
- Solid {
- item: ItemId,
- },
- Text,
- Shape,
- Null,
- Camera,
- Light {
- kind: LightKind,
- },
- /// An imported 3D model (a footage item of kind [`FootageKind::Model`]; Advanced 3D).
- Model {
- item: ItemId,
- },
- /// A parametric 3D primitive (Advanced 3D).
- Primitive {
- kind: PrimitiveKind,
- },
-}
-
-impl LayerSource {
- pub fn item(&self) -> Option<ItemId> {
- match self {
- LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Solid { item } | LayerSource::Model { item } => Some(*item),
- _ => None,
- }
- }
- pub fn type_name(&self) -> &'static str {
- match self {
- LayerSource::Footage { .. } => "Footage",
- LayerSource::Comp { .. } => "Composition",
- LayerSource::Solid { .. } => "Solid",
- LayerSource::Text => "Text",
- LayerSource::Shape => "Shape",
- LayerSource::Null => "Null",
- LayerSource::Camera => "Camera",
- LayerSource::Light { .. } => "Light",
- LayerSource::Model { .. } => "3D Model",
- LayerSource::Primitive { .. } => "3D Primitive",
- }
- }
- /// Layers with pixels (cameras, lights and nulls have none).
- pub fn is_av(&self) -> bool {
- !matches!(self, LayerSource::Camera | LayerSource::Light { .. } | LayerSource::Null)
- }
- /// A 3D model or primitive layer (meshes; drawn by the Advanced 3D renderer).
- pub fn is_model(&self) -> bool {
- matches!(self, LayerSource::Model { .. } | LayerSource::Primitive { .. })
- }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Quality {
- #[default]
- Best,
- Draft,
- Wireframe,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Sampling {
- #[default]
- Bilinear,
- Bicubic,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum FrameBlend {
- #[default]
- Off,
- FrameMix,
- PixelMotion,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Switches {
- pub video: bool,
- pub audio: bool,
- pub solo: bool,
- pub locked: bool,
- pub shy: bool,
- /// Collapse transformations (precomps) / continuously rasterize (vector layers).
- pub collapse: bool,
- pub quality: Quality,
- pub sampling: Sampling,
- pub effects: bool,
- pub frame_blend: FrameBlend,
- pub motion_blur: bool,
- pub adjustment: bool,
- pub three_d: bool,
- pub guide: bool,
-}
-
-impl Default for Switches {
- fn default() -> Self {
- Switches {
- video: true,
- audio: true,
- solo: false,
- locked: false,
- shy: false,
- collapse: false,
- quality: Quality::Best,
- sampling: Sampling::Bilinear,
- effects: true,
- frame_blend: FrameBlend::Off,
- motion_blur: false,
- adjustment: false,
- three_d: false,
- guide: false,
- }
- }
-}
-
-// What a frame's pixels depend on. Caches key on it: the Audio, Lock and Shy switches and Hide
-// Shy Layers don't change pixels, so toggling them keeps cached frames (#103).
-
-impl Switches {
- /// These switches with Audio, Lock and Shy at their defaults.
- pub fn pixels(&self) -> Switches {
- Switches { audio: true, locked: false, shy: false, ..self.clone() }
- }
-}
-
-impl Layer {
- /// Draws the same pixels as `o`: equal but for the Audio, Lock and Shy switches.
- pub fn same_pixels(&self, o: &Layer) -> bool {
- // Every field (no `..`: a new field must be considered here); the property tree last.
- let Layer {
- id,
- name,
- source,
- label,
- comment,
- start_time,
- in_point,
- out_point,
- stretch,
- switches,
- blend_mode,
- preserve_transparency,
- track_matte,
- parent,
- markers,
- markers_locked,
- auto_orient,
- environment,
- environment_background,
- props,
- } = self;
- *id == o.id
- && *name == o.name
- && *source == o.source
- && *label == o.label
- && *comment == o.comment
- && *start_time == o.start_time
- && *in_point == o.in_point
- && *out_point == o.out_point
- && *stretch == o.stretch
- && switches.pixels() == o.switches.pixels()
- && *blend_mode == o.blend_mode
- && *preserve_transparency == o.preserve_transparency
- && *track_matte == o.track_matte
- && *parent == o.parent
- && *markers == o.markers
- && *markers_locked == o.markers_locked
- && *auto_orient == o.auto_orient
- && *environment == o.environment
- && *environment_background == o.environment_background
- && *props == o.props
- }
-}
-
-impl Comp {
- /// Draws the same pixels as `o`: equal but for its layers' Audio, Lock and Shy switches, Hide
- /// Shy Layers and the viewer's Resolution.
- pub fn same_pixels(&self, o: &Comp) -> bool {
- self.same_settings(o) && self.layers.len() == o.layers.len() && self.layers.iter().zip(&o.layers).all(|(a, b)| a.same_pixels(b))
- }
-
- /// [`Self::same_pixels`] but for the layers.
- fn same_settings(&self, o: &Comp) -> bool {
- // Every field (no `..`: a new field must be considered here).
- let Comp {
- width,
- height,
- pixel_aspect,
- frame_rate,
- duration,
- display_start,
- background,
- work_area,
- layers: _,
- markers,
- shutter_angle,
- shutter_phase,
- motion_blur_samples,
- motion_blur_adaptive_limit,
- renderer,
- hide_shy: _,
- enable_motion_blur,
- enable_frame_blending,
- draft_3d,
- preserve_frame_rate,
- preserve_resolution,
- poster_time,
- global_light,
- guides,
- essential,
- resolution: _,
- } = self;
- *width == o.width
- && *height == o.height
- && *pixel_aspect == o.pixel_aspect
- && *frame_rate == o.frame_rate
- && *duration == o.duration
- && *display_start == o.display_start
- && *background == o.background
- && *work_area == o.work_area
- && *markers == o.markers
- && *shutter_angle == o.shutter_angle
- && *shutter_phase == o.shutter_phase
- && *motion_blur_samples == o.motion_blur_samples
- && *motion_blur_adaptive_limit == o.motion_blur_adaptive_limit
- && *renderer == o.renderer
- && *enable_motion_blur == o.enable_motion_blur
- && *enable_frame_blending == o.enable_frame_blending
- && *draft_3d == o.draft_3d
- && *preserve_frame_rate == o.preserve_frame_rate
- && *preserve_resolution == o.preserve_resolution
- && *poster_time == o.poster_time
- && *global_light == o.global_light
- && *guides == o.guides
- && *essential == o.essential
- }
-
- /// The comp-time span (`in_point..out_point` of every layer changed, added or removed,
- /// widened by the shutter) outside which `self` draws the same pixels as `o`, so cached
- /// frames there stay valid (#1641). `None` when the edit can reach any frame: a comp setting,
- /// a layer reorder, Solo turning on or off, an expression (it reads anything), or a changed
- /// layer another layer parents to, mattes with or picks in an effect.
- pub fn changed_span(&self, o: &Comp) -> Option<(Tick, Tick)> {
- fn reads(g: &PropGroup, changed: &[LayerId]) -> bool {
- g.children.iter().any(|c| match c {
- Node::Prop(p) => {
- p.expr.is_some()
- || std::iter::once(&p.value)
- .chain(p.keys.iter().map(|k| &k.value))
- .any(|v| matches!(v, Value::Layer(Some(id)) if changed.contains(&LayerId(*id))))
- }
- Node::Group(g) => reads(g, changed),
- })
- }
- // Solo hides every other layer at every frame.
- if !self.same_settings(o) || self.any_solo() != o.any_solo() {
- return None;
- }
- let common = |a: &Comp, b: &Comp| a.layers.iter().map(|l| l.id).filter(|id| b.layer(*id).is_some()).collect::<Vec<_>>();
- if common(self, o) != common(o, self) {
- return None;
- }
- let mut changed = Vec::new();
- let mut span: Option<(Tick, Tick)> = None;
- // Each changed layer comes up from both sides: its old and its new span.
- for (l, other) in self.layers.iter().map(|l| (l, o.layer(l.id))).chain(o.layers.iter().map(|l| (l, self.layer(l.id)))) {
- if other.is_some_and(|b| l.same_pixels(b)) {
- continue;
- }
- changed.push(l.id);
- let (s, e) = (l.in_point.min(l.out_point), l.in_point.max(l.out_point));
- span = Some(span.map_or((s, e), |(a, b)| (a.min(s), b.max(e))));
- }
- let reaches = |l: &Layer| {
- l.parent.is_some_and(|p| changed.contains(&p)) || l.track_matte.as_ref().is_some_and(|m| changed.contains(&m.layer)) || reads(&l.props, &changed)
- };
- if self.layers.iter().chain(&o.layers).any(reaches) {
- return None;
- }
- // A frame at `t` samples cameras, lights and transforms over its shutter,
- // `t + (phase + angle * 0..=1) / 360` frames, and draws the layers active at `t` itself.
- let (a, p) = (self.shutter_angle / 360.0, self.shutter_phase / 360.0);
- let fd = self.frame_duration().seconds();
- let (before, after) = (Tick::from_seconds_f64(p.max(p + a).max(0.0) * fd), Tick::from_seconds_f64(-p.min(p + a).min(0.0) * fd));
- span.map(|(s, e)| (s - before, e + after))
- }
-
- /// Some layer is soloed: only the soloed layers draw.
- pub fn any_solo(&self) -> bool {
- self.layers.iter().any(|l| l.switches.solo && l.source.is_av())
- }
-
- /// Draws the same pixels as `o` once plain markers are ignored: they change no pixels. Protected
- /// time markers with a duration set the timing (Responsive Design), so those still count.
- pub fn same_pixels_ignoring_markers(&self, o: &Comp) -> bool {
- let protected =
- |m: &[Marker]| -> Vec<(Tick, Tick)> { m.iter().filter(|m| m.protected && m.duration > Tick::ZERO).map(|m| (m.time, m.duration)).collect() };
- if protected(&self.markers) != protected(&o.markers) {
- return false;
- }
- let mut c = self.clone();
- c.markers = o.markers.clone();
- for (a, b) in c.layers.iter_mut().zip(&o.layers) {
- a.markers = b.markers.clone();
- a.markers_locked = b.markers_locked;
- }
- c.same_pixels(o)
- }
-
- /// The comp with those switches and the Resolution at their defaults (borrowed when they
- /// already are), for keys that hash the whole comp.
- pub fn pixel_form(&self) -> std::borrow::Cow<'_, Comp> {
- if !self.hide_shy && self.resolution.is_auto() && self.layers.iter().all(|l| l.switches == l.switches.pixels()) {
- return std::borrow::Cow::Borrowed(self);
- }
- let mut c = self.clone();
- c.hide_shy = false;
- c.resolution = Resolution::Auto;
- for l in &mut c.layers {
- l.switches = l.switches.pixels();
- }
- std::borrow::Cow::Owned(c)
- }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum MatteKind {
- #[default]
- Alpha,
- AlphaInverted,
- Luma,
- LumaInverted,
-}
-
-impl MatteKind {
- pub const ALL: [MatteKind; 4] = [MatteKind::Alpha, MatteKind::AlphaInverted, MatteKind::Luma, MatteKind::LumaInverted];
- pub fn label(self) -> &'static str {
- match self {
- MatteKind::Alpha => "Alpha Matte",
- MatteKind::AlphaInverted => "Alpha Inverted Matte",
- MatteKind::Luma => "Luma Matte",
- MatteKind::LumaInverted => "Luma Inverted Matte",
- }
- }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TrackMatte {
- pub layer: LayerId,
- pub kind: MatteKind,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AutoOrient {
- #[default]
- Off,
- AlongPath,
- TowardsCamera,
- TowardsPointOfInterest,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Layer {
- pub id: LayerId,
- pub name: String,
- pub source: LayerSource,
- pub label: Label,
- #[serde(default)]
- pub comment: String,
- /// Comp time where the layer's time 0 sits.
- pub start_time: Tick,
- /// Visible span in comp time.
- pub in_point: Tick,
- pub out_point: Tick,
- /// Time stretch in percent (100 = normal, negative = reversed).
- pub stretch: f64,
- pub switches: Switches,
- pub blend_mode: BlendMode,
- #[serde(default)]
- pub preserve_transparency: bool,
- #[serde(default)]
- pub track_matte: Option<TrackMatte>,
- #[serde(default)]
- pub parent: Option<LayerId>,
- #[serde(default)]
- pub markers: Vec<Marker>,
- /// Layer ▸ Markers ▸ Lock Markers.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub markers_locked: bool,
- #[serde(default)]
- pub auto_orient: AutoOrient,
- /// Layer ▸ Environment Layer: the layer is the environment (image-based light and
- /// reflections) of Advanced 3D comps instead of being drawn.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub environment: bool,
- /// Layer ▸ Light ▸ Create Environment Light Background Layer: the layer's (equirectangular)
- /// image is drawn as the 3D scene's backdrop, seen through the camera, instead of as a card.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub environment_background: bool,
- /// The property tree (Masks, Effects, Transform, Text, Contents, Camera/Light options…).
- pub props: PropGroup,
-}
-
-impl Layer {
- pub fn is_active_at(&self, t: Tick) -> bool {
- t >= self.in_point && t < self.out_point
- }
- /// Layer time for a comp time (stretch-aware).
- pub fn layer_time(&self, comp_t: Tick) -> Tick {
- let d = comp_t - self.start_time;
- if (self.stretch - 100.0).abs() < 1e-9 { d } else { Tick((d.0 as f64 * 100.0 / self.stretch) as i64) }
- }
- /// Comp time for a layer time.
- pub fn comp_time(&self, layer_t: Tick) -> Tick {
- if (self.stretch - 100.0).abs() < 1e-9 { self.start_time + layer_t } else { self.start_time + Tick((layer_t.0 as f64 * self.stretch / 100.0) as i64) }
- }
- pub fn transform(&self) -> Option<&PropGroup> {
- self.props.sub("transform")
- }
- pub fn transform_mut(&mut self) -> Option<&mut PropGroup> {
- self.props.sub_mut("transform")
- }
- pub fn effects(&self) -> Option<&PropGroup> {
- self.props.sub("effects")
- }
- pub fn masks(&self) -> Option<&PropGroup> {
- self.props.sub("masks")
- }
- pub fn is_camera(&self) -> bool {
- matches!(self.source, LayerSource::Camera)
- }
- pub fn is_light(&self) -> bool {
- matches!(self.source, LayerSource::Light { .. })
- }
- /// The layer participates in 3D (3D switch, or cameras/lights which are always 3D).
- pub fn is_3d(&self) -> bool {
- self.switches.three_d || self.is_camera() || self.is_light()
- }
- pub fn has_video(&self) -> bool {
- self.source.is_av() && self.switches.video
- }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum FootageKind {
- #[default]
- Video,
- Still,
- Sequence,
- Audio,
- /// A 3D model (glTF 2.0 / OBJ), placed as a model layer.
- Model,
- /// A data file (JSON, CSV, TSV) for data-driven animation: read by expressions through
- /// `footage(name).sourceData` / `sourceText` / `dataValue`; it has no pixels.
- Data,
-}
-
-/// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum FieldOrder {
- /// Progressive frames.
- #[default]
- Off,
- /// Interlaced, upper (odd) field first: each field becomes a frame at twice the rate.
- UpperFirst,
- LowerFirst,
-}
-
-impl FieldOrder {
- pub fn label(self) -> &'static str {
- match self {
- FieldOrder::Off => "Off",
- FieldOrder::UpperFirst => "Upper Field First",
- FieldOrder::LowerFirst => "Lower Field First",
- }
- }
- pub fn parse(s: &str) -> Option<FieldOrder> {
- match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
- "off" | "none" | "progressive" => Some(FieldOrder::Off),
- "upper" | "upperfirst" | "upperfieldfirst" => Some(FieldOrder::UpperFirst),
- "lower" | "lowerfirst" | "lowerfieldfirst" => Some(FieldOrder::LowerFirst),
- _ => None,
- }
- }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AlphaMode {
- #[default]
- Straight,
- Premultiplied,
- Ignore,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Footage {
- pub path: String,
- pub kind: FootageKind,
- pub width: u32,
- pub height: u32,
- pub pixel_aspect: f64,
- pub frame_rate: FrameRate,
- /// Native rate before "Conform to frame rate".
- #[serde(default)]
- pub native_rate: Option<FrameRate>,
- pub duration: Tick,
- pub has_video: bool,
- pub has_audio: bool,
- pub alpha: AlphaMode,
- #[serde(default)]
- pub premul_color: [f32; 3],
- #[serde(default = "one")]
- pub loop_count: u32,
- #[serde(default)]
- pub codec: String,
- #[serde(default)]
- pub missing: bool,
- /// Image sequence files (when kind = Sequence).
- #[serde(default, skip_serializing_if = "Vec::is_empty")]
- pub sequence: Vec<String>,
- /// Colour profile (from the file's metadata, or Interpret Footage). `None` = sRGB.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub color_profile: Option<ColorSpace>,
- /// One layer of a layered file (Photoshop) instead of its merged image.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub layer: Option<SourceLayer>,
- /// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
- #[serde(default, skip_serializing_if = "is_default")]
- pub fields: FieldOrder,
- /// Interpret Footage ▸ Alpha ▸ Invert Alpha.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub invert_alpha: bool,
- /// Interpret Footage ▸ Color ▸ Interpret As Linear Light: the file's values are linear.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub linear_light: bool,
- /// Interpret Footage ▸ Color ▸ Preserve RGB: the file's values enter the composition
- /// unconverted. Float footage (OpenEXR, float TIFF) is not sRGB-encoded on decode, and the
- /// colour profile, Interpret As Linear Light and the working space don't apply.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub preserve_rgb: bool,
- /// Data footage ([`FootageKind::Data`]): the file's text (JSON, CSV or TSV), kept in the
- /// project so expressions read it everywhere (and on the web).
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub data: Option<String>,
- /// PDF / Illustrator footage: the page shown (0-based; File ▸ Import ▸ Page).
- #[serde(default, skip_serializing_if = "is_default")]
- pub page: u32,
- /// Image sequences imported with Force Alphabetical Order: the files play one after another
- /// and their numbering doesn't count (otherwise a gap in it shows a placeholder, as in After
- /// Effects; [`sequence`]).
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub alphabetical: bool,
- /// Interpret Footage ▸ Start Timecode ▸ Override Start: the frame (at the footage's frame
- /// rate) its timecode shows at its first frame. `None` = Use Source File Timecode (0: file
- /// timecode isn't read). It only relabels source time, as in After Effects.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub start_timecode: Option<i64>,
-}
-
-fn is_default<T: Default + PartialEq>(v: &T) -> bool {
- *v == T::default()
-}
-
-impl Default for Footage {
- fn default() -> Self {
- Footage {
- path: String::new(),
- kind: FootageKind::Still,
- width: 0,
- height: 0,
- pixel_aspect: 1.0,
- frame_rate: FrameRate::FPS_30,
- native_rate: None,
- duration: Tick::ZERO,
- has_video: false,
- has_audio: false,
- alpha: AlphaMode::Straight,
- premul_color: [0.0; 3],
- loop_count: 1,
- codec: String::new(),
- missing: false,
- sequence: vec![],
- color_profile: None,
- fields: FieldOrder::Off,
- invert_alpha: false,
- linear_light: false,
- preserve_rgb: false,
- data: None,
- layer: None,
- page: 0,
- alphabetical: false,
- start_timecode: None,
- }
- }
-}
-
-impl Footage {
- /// Interpret As Linear Light applies (Preserve RGB passes the file's values through).
- pub fn linear_light_applies(&self) -> bool {
- self.linear_light && !self.preserve_rgb
- }
-
- /// How long the footage plays: its duration times Interpret Footage ▸ Loop.
- pub fn looped_duration(&self) -> Tick {
- Tick(self.duration.0.saturating_mul(self.loop_count.max(1) as i64))
- }
-
- /// Source time as the footage's timecode: its frame `frame` from Start Timecode
- /// (`0:00:41:20`), as the Footage panel shows it.
- pub fn timecode(&self, frame: i64) -> String {
- effectcraft_time::format_timecode_ae(frame.saturating_add(self.start_timecode.unwrap_or(0)), self.frame_rate, false)
- }
-
- /// The data format of data footage: `json`, `csv` or `tsv` (from the file extension).
- pub fn data_format(&self) -> Option<&'static str> {
- if self.kind != FootageKind::Data {
- return None;
- }
- let ext = std::path::Path::new(&self.path).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase();
- Some(match ext.as_str() {
- "csv" => "csv",
- "tsv" | "tab" => "tsv",
- _ => "json",
- })
- }
-}
-
-/// A proxy: a stand-in file used instead of a footage item or composition (File ▸ Set Proxy /
-/// Create Proxy), when its Use Proxy switch is on and the render's Proxy Use allows it.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Proxy {
- /// The proxy's footage (path, size, rate…; File ▸ Interpret Footage ▸ Proxy edits it).
- pub footage: Footage,
- /// Use Proxy (the Project panel's proxy indicator: filled = in use, hollow = set but off).
- #[serde(default = "yes")]
- pub enabled: bool,
-}
-
-/// A layer of a layered still (a Photoshop document, or a PDF / Illustrator / EPS file) used as
-/// footage (File ▸ Import ▸ Composition / Composition – Retain Layer Sizes, or Choose Layer).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SourceLayer {
- /// Layer record index in the file (bottom of the stack = 0).
- pub index: u32,
- pub name: String,
- /// The footage is the layer's own bounds (Retain Layer Sizes) rather than the document size.
- #[serde(default)]
- pub layer_size: bool,
- /// A Photoshop smart object: the unique id of its embedded file (linked layer data), which
- /// is the footage instead of the layer's pixels.
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub embedded: Option<String>,
- /// A smart object with a perspective quad or a warp: the footage is its embedded file baked
- /// as placed (warped and pinned to its corners) over the placed bounds in document space.
- #[serde(default, skip_serializing_if = "std::ops::Not::not")]
- pub placed: bool,
-}
-
-fn one() -> u32 {
- 1
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Solid {
- pub color: [f32; 3],
- pub width: u32,
- pub height: u32,
- pub pixel_aspect: f64,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type")]
-#[allow(clippy::large_enum_variant)]
-pub enum ItemKind {
- Folder,
- Comp(Arc<Comp>),
- Footage(Footage),
- Solid(Solid),
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Item {
- pub id: ItemId,
- pub name: String,
- pub label: Label,
- #[serde(default)]
- pub comment: String,
- /// Containing folder (None = project root).
- #[serde(default)]
- pub parent: Option<ItemId>,
- pub kind: ItemKind,
- /// The item's proxy (footage and compositions).
- #[serde(default, skip_serializing_if = "Option::is_none")]
- pub proxy: Option<Box<Proxy>>,
-}
-
-impl Item {
- pub fn type_name(&self) -> &'static str {
- match &self.kind {
- ItemKind::Folder => "Folder",
- ItemKind::Comp(_) => "Composition",
- ItemKind::Footage(f) => match f.kind {
- FootageKind::Video => "Video",
- FootageKind::Still => "Image",
- FootageKind::Sequence => "Image Sequence",
- FootageKind::Audio => "Audio",
- FootageKind::Model => "3D Model",
- FootageKind::Data => "Data",
- },
- ItemKind::Solid(_) => "Solid",
- }
- }
- pub fn as_comp(&self) -> Option<&Comp> {
- if let ItemKind::Comp(c) = &self.kind { Some(c) } else { None }
- }
- pub fn is_folder(&self) -> bool {
- matches!(self.kind, ItemKind::Folder)
- }
- /// (width, height) for visual items.
- pub fn dimensions(&self) -> Option<(u32, u32)> {
- match &self.kind {
- ItemKind::Comp(c) => Some((c.width, c.height)),
- ItemKind::Footage(f) if f.has_video => Some((f.width, f.height)),
- ItemKind::Solid(s) => Some((s.width, s.height)),
- _ => None,
- }
- }
- pub fn duration(&self) -> Option<Tick> {
- match &self.kind {
- ItemKind::Comp(c) => Some(c.duration),
- ItemKind::Footage(f) if f.kind != FootageKind::Still => Some(f.looped_duration()),
- _ => None,
- }
- }
- pub fn frame_rate(&self) -> Option<FrameRate> {
- match &self.kind {
- ItemKind::Comp(c) => Some(c.frame_rate),
- ItemKind::Footage(f) if f.kind == FootageKind::Video || f.kind == FootageKind::Sequence => Some(f.frame_rate),
- _ => None,
- }
- }
-}
+mod comp;
+mod footage;
+mod item;
+mod layer;
+mod settings;
+
+pub use comp::{Comp, Guide, Renderer, Resolution};
+pub use footage::{AlphaMode, FieldOrder, Footage, FootageKind, Proxy, Solid, SourceLayer};
+pub use item::{Item, ItemId, ItemKind, LayerId};
+pub use layer::{AutoOrient, FrameBlend, Layer, LayerSource, LightKind, MatteKind, PrimitiveKind, Quality, Sampling, Switches, TrackMatte};
+pub use settings::{
+ APP_VERSION, BitDepth, ColorEngine, CuePoint, HdrMode, Marker, ProjectError, ProjectSettings, SCHEMA_EFFECT_SPACE, SCHEMA_VERSION, SavedView,
+ TimeDisplayStyle, is_newer_version, saved_by, saved_view,
+};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Project {
@@ -1434,229 +61,5 @@ pub struct Project {
pub render_prefs: render_queue::RenderQueuePrefs,
}
-impl Default for Project {
- fn default() -> Self {
- Project {
- schema: SCHEMA_VERSION,
- settings: ProjectSettings::default(),
- items: BTreeMap::new(),
- next_id: 1,
- render_queue: Vec::new(),
- render_templates: Default::default(),
- render_prefs: Default::default(),
- }
- }
-}
-
-impl Project {
- /// Allocate an id (items, layers and property uids share one counter).
- pub fn alloc(&mut self) -> u64 {
- let id = self.next_id;
- self.next_id += 1;
- id
- }
- pub fn item(&self, id: ItemId) -> Option<&Item> {
- self.items.get(&id)
- }
- pub fn item_mut(&mut self, id: ItemId) -> Option<&mut Item> {
- self.items.get_mut(&id)
- }
- pub fn comp(&self, id: ItemId) -> Option<&Comp> {
- self.items.get(&id)?.as_comp()
- }
- /// A shared handle on a comp: a snapshot that costs a reference count, not a deep copy of
- /// its layers (frontends hold one across a frame instead of cloning the comp).
- pub fn comp_arc(&self, id: ItemId) -> Option<Arc<Comp>> {
- match &self.items.get(&id)?.kind {
- ItemKind::Comp(c) => Some(c.clone()),
- _ => None,
- }
- }
- /// Mutable comp (copy-on-write).
- pub fn comp_mut(&mut self, id: ItemId) -> Option<&mut Comp> {
- match &mut self.items.get_mut(&id)?.kind {
- ItemKind::Comp(c) => Some(Arc::make_mut(c)),
- _ => None,
- }
- }
- /// Adds an item; its size, frame rate and the like are brought within [`limits`] first.
- pub fn add_item(&mut self, name: &str, label: Label, parent: Option<ItemId>, mut kind: ItemKind) -> ItemId {
- limits::repair_kind(name, &mut kind, &mut vec![]);
- let id = ItemId(self.alloc());
- self.items.insert(id, Item { id, name: name.into(), label, comment: String::new(), parent, kind, proxy: None });
- id
- }
- /// Children of a folder (None = root), folders first then by name.
- pub fn children(&self, folder: Option<ItemId>) -> Vec<&Item> {
- let mut v: Vec<&Item> = self.items.values().filter(|i| i.parent == folder).collect();
- v.sort_by(|a, b| b.is_folder().cmp(&a.is_folder()).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())));
- v
- }
- pub fn comps(&self) -> impl Iterator<Item = (&ItemId, &Comp)> {
- self.items.iter().filter_map(|(id, i)| i.as_comp().map(|c| (id, c)))
- }
- pub fn find_by_name(&self, name: &str) -> Option<&Item> {
- self.items.values().find(|i| i.name == name)
- }
- /// A numbered name for a copy of `base` that no project item has (Edit ▸ Duplicate): its
- /// trailing number is dropped and the lowest free one from 2 is added (`Comp 1` → `Comp 2`,
- /// `Name` → `Name 2`, then `Name 3`). Items for which `ignore` holds don't count.
- pub fn numbered_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
- let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
- let taken = |n: &str| self.items.values().any(|i| i.name == n && !ignore(i));
- (2u64..).map(|k| format!("{stem} {k}")).find(|n| !taken(n)).unwrap_or_default()
- }
- /// `base` when no project item has that name, else the next free numbered name as
- /// [`Project::numbered_item_name`] gives it. Items for which `ignore` holds don't count.
- pub fn unique_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
- if self.items.values().any(|i| i.name == base && !ignore(i)) { self.numbered_item_name(base, ignore) } else { base.to_string() }
- }
- pub fn folder_named(&self, name: &str) -> Option<ItemId> {
- self.items.values().find(|i| i.is_folder() && i.name == name).map(|i| i.id)
- }
- /// Find the comp that contains `layer`.
- pub fn comp_of_layer(&self, layer: LayerId) -> Option<ItemId> {
- self.comps().find(|(_, c)| c.layer(layer).is_some()).map(|(id, _)| *id)
- }
- /// The compositions whose layers use `item` as their source (footage, solid, 3D model or
- /// precomp), each with how many of its layers do, ordered by comp name then id. Only direct
- /// layers count, as in After Effects' Project panel ("used 3 times"): a solid inside a precomp
- /// is used by the precomp, not by the comps that nest it. The total is the sum of the counts.
- pub fn item_users(&self, item: ItemId) -> Vec<(ItemId, usize)> {
- let mut users: Vec<(ItemId, String, usize)> = self
- .items
- .iter()
- .filter_map(|(id, it)| {
- let comp = it.as_comp()?;
- let n = comp.layers.iter().filter(|l| l.source.item() == Some(item)).count();
- (n > 0).then(|| (*id, it.name.to_lowercase(), n))
- })
- .collect();
- users.sort_by(|a, b| a.1.cmp(&b.1).then(a.0.cmp(&b.0)));
- users.into_iter().map(|(id, _, n)| (id, n)).collect()
- }
- /// Whether comp `inner` is (transitively) nested inside comp `outer` (to prevent cycles).
- pub fn comp_contains(&self, outer: ItemId, inner: ItemId) -> bool {
- // A walk with a stack and a visited set rather than recursion (#1237): a damaged project
- // may hold a precomp cycle that doesn't pass `inner` (recursion never ended), a long
- // chain must not use up the call stack, and comps shared by many paths are visited once
- // (recursion re-walked them for every path).
- if outer == inner {
- return true;
- }
- let mut seen = std::collections::HashSet::new();
- let mut stack = vec![outer];
- while let Some(id) = stack.pop() {
- if !seen.insert(id) {
- continue;
- }
- let Some(c) = self.comp(id) else { continue };
- for l in &c.layers {
- if let LayerSource::Comp { item } = l.source {
- if item == inner {
- return true;
- }
- if !seen.contains(&item) {
- stack.push(item);
- }
- }
- }
- }
- false
- }
- /// Make sure `next_id` exceeds every id in the project (after loading or merging).
- pub fn fix_next_id(&mut self) {
- let mut m = self.next_id;
- for (id, it) in &self.items {
- // Saturating: a damaged file's ids must not overflow (the import then refuses it).
- m = m.max(id.0.saturating_add(1));
- if let ItemKind::Comp(c) = &it.kind {
- for l in &c.layers {
- m = m.max(l.id.0.saturating_add(1)).max(l.props.max_uid().saturating_add(1));
- }
- }
- }
- self.next_id = m;
- }
- /// Whether `other` holds the same content. An allocated id counts (an edit may hand it out
- /// beyond the project, so it must stay taken). Shared compositions compare by pointer first,
- /// so after a copy-on-write edit only the comps it touched are compared field by field.
- pub fn same_content(&self, other: &Project) -> bool {
- let item_eq = |a: &Item, b: &Item| {
- let kind = match (&a.kind, &b.kind) {
- (ItemKind::Comp(x), ItemKind::Comp(y)) => Arc::ptr_eq(x, y) || x == y,
- (x, y) => x == y,
- };
- kind && a.id == b.id && a.name == b.name && a.label == b.label && a.comment == b.comment && a.parent == b.parent && a.proxy == b.proxy
- };
- self.schema == other.schema
- && self.next_id == other.next_id
- && self.settings == other.settings
- && self.items.len() == other.items.len()
- && self.items.iter().zip(&other.items).all(|((ka, a), (kb, b))| ka == kb && item_eq(a, b))
- && self.render_queue == other.render_queue
- && self.render_templates == other.render_templates
- && self.render_prefs == other.render_prefs
- }
- /// The project file's text: the project with the version that wrote it (`savedBy`), checked
- /// to read back, so a save never writes a file that can't be opened. Values JSON can't hold
- /// (NaN or infinity, written as `null`, and nesting too deep to parse) are refused on every
- /// save; debug builds also read the text back.
- pub fn to_file_json(&self) -> Result<String, ProjectError> {
- self.to_file_json_with_view(&SavedView::default())
- }
- /// [`Project::to_file_json`] that also records the open compositions ([`SavedView`]).
- pub fn to_file_json_with_view(&self, view: &SavedView) -> Result<String, ProjectError> {
- if self.schema > SCHEMA_VERSION {
- return Err(ProjectError::Invalid(format!(
- "the project can't be saved: it holds a value a project file can't store (project schema {} is newer than this version supports ({SCHEMA_VERSION}))",
- self.schema
- )));
- }
- #[derive(Serialize)]
- struct File<'a> {
- #[serde(rename = "savedBy")]
- saved_by: &'a str,
- #[serde(flatten)]
- view: &'a SavedView,
- #[serde(flatten)]
- project: &'a Project,
- }
- let file = File { saved_by: APP_VERSION, view, project: self };
- file_check::check(&file)
- .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
- let text = serde_json::to_string_pretty(&file).map_err(|e| ProjectError::Invalid(format!("the project can't be saved: {e}")))?;
- #[cfg(debug_assertions)]
- Project::from_json(&text)
- .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
- Ok(text)
- }
- pub fn to_json(&self) -> String {
- serde_json::to_string_pretty(self).unwrap_or_default()
- }
- /// [`Project::to_json`] without indentation: smaller and faster (auto-saves).
- pub fn to_json_compact(&self) -> String {
- serde_json::to_string(self).unwrap_or_default()
- }
- pub fn from_json(s: &str) -> Result<Project, ProjectError> {
- Project::from_json_repaired(s).map(|(p, _)| p)
- }
- /// [`Project::from_json`], also returning one line per value that was out of [`limits`] and
- /// was corrected (a composition of a billion pixels, a zero frame rate…), so a corrupt or
- /// hostile file still opens, within bounds, and the user can be told what changed.
- pub fn from_json_repaired(s: &str) -> Result<(Project, Vec<String>), ProjectError> {
- let mut p: Project = serde_json::from_str(s).map_err(|e| ProjectError::Invalid(e.to_string()))?;
- if p.schema > SCHEMA_VERSION {
- return Err(ProjectError::Invalid(format!("project schema {} is newer than this version supports ({SCHEMA_VERSION})", p.schema)));
- }
- p.fix_next_id();
- let mut notes = vec![];
- for item in p.items.values_mut() {
- limits::repair_item(item, &mut notes);
- }
- Ok((p, notes))
- }
-}
-
#[cfg(test)]
mod tests;
diff --git a/crates/project/src/settings.rs b/crates/project/src/settings.rs
new file mode 100644
index 000000000..efd75fd14
--- /dev/null
+++ b/crates/project/src/settings.rs
@@ -0,0 +1,314 @@
+use super::item::{ItemId, LayerId};
+use super::*;
+
+/// The project file schema. 2: effects on layers without a source rectangle (shape, text)
+/// measure positions from the top-left of their comp-sized bounds (effect space), not from
+/// the layer's origin; projects from schema 1 are converted when opened (#227).
+pub const SCHEMA_VERSION: u32 = 2;
+
+/// The first schema in which effect positions are in effect space (see [`SCHEMA_VERSION`]).
+pub const SCHEMA_EFFECT_SPACE: u32 = 2;
+
+/// The EffectCraft version, written into project files as `savedBy`.
+pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// The EffectCraft version that wrote a project file (its `savedBy`), when it says.
+pub fn saved_by(text: &str) -> Option<String> {
+ #[derive(Deserialize)]
+ struct Meta {
+ #[serde(rename = "savedBy", default)]
+ saved_by: Option<String>,
+ }
+ serde_json::from_str::<Meta>(text).ok()?.saved_by
+}
+
+/// The compositions that were open when a project file was saved and their current times
+/// (`activeComp`, `openComps` and `compTimes` next to `savedBy`), so it reopens where it was left
+/// (#748, #1714). Editor state rather than project
+/// content: opening a comp doesn't make the project unsaved, and it isn't part of
+/// [`Project`]. Older files have none; older versions ignore it.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedView {
+ /// The comp shown in the viewer and the Timeline.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub active_comp: Option<ItemId>,
+ /// The open comps (Timeline tabs), in tab order.
+ #[serde(skip_serializing_if = "Vec::is_empty")]
+ pub open_comps: Vec<ItemId>,
+ /// Each comp's current time, so a project reopens on the frame it was saved at rather than
+ /// at 0, where its layers may not have started yet (#1714).
+ #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+ pub comp_times: BTreeMap<ItemId, Tick>,
+}
+
+/// The view a project file was saved with ([`SavedView`]); empty for older files. Values that
+/// aren't ids are ignored (whether an id still names a comp is up to the caller).
+pub fn saved_view(text: &str) -> SavedView {
+ #[derive(Deserialize)]
+ struct Meta {
+ #[serde(rename = "activeComp", default)]
+ active_comp: Option<serde_json::Value>,
+ #[serde(rename = "openComps", default)]
+ open_comps: Option<serde_json::Value>,
+ #[serde(rename = "compTimes", default)]
+ comp_times: Option<serde_json::Value>,
+ }
+ let Ok(m) = serde_json::from_str::<Meta>(text) else { return SavedView::default() };
+ SavedView {
+ active_comp: m.active_comp.as_ref().and_then(serde_json::Value::as_u64).map(ItemId),
+ open_comps: m
+ .open_comps
+ .as_ref()
+ .and_then(serde_json::Value::as_array)
+ .map_or_else(Vec::new, |a| a.iter().filter_map(serde_json::Value::as_u64).map(ItemId).collect()),
+ comp_times: m
+ .comp_times
+ .as_ref()
+ .and_then(serde_json::Value::as_object)
+ .map_or_else(BTreeMap::new, |o| o.iter().filter_map(|(k, v)| Some((ItemId(k.parse().ok()?), Tick(v.as_i64()?)))).collect()),
+ }
+}
+
+/// Whether version `a` (`major.minor.patch`, pre-release suffixes ignored) is newer than `b`.
+pub fn is_newer_version(a: &str, b: &str) -> bool {
+ let parts = |v: &str| -> [u64; 3] {
+ let mut n = v.split(['-', '+']).next().unwrap_or("").split('.').map(|x| x.parse().unwrap_or(0));
+ [n.next().unwrap_or(0), n.next().unwrap_or(0), n.next().unwrap_or(0)]
+ };
+ parts(a) > parts(b)
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ProjectError {
+ #[error("no item {0:?}")]
+ NoItem(ItemId),
+ #[error("item {0:?} is not a composition")]
+ NotComp(ItemId),
+ #[error("no layer {0:?}")]
+ NoLayer(LayerId),
+ #[error("no property `{0}`")]
+ NoProperty(String),
+ #[error("{0}")]
+ Invalid(String),
+}
+
+/// Project bit depth.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum BitDepth {
+ #[default]
+ Bpc8,
+ Bpc16,
+ Bpc32,
+}
+
+impl BitDepth {
+ pub fn label(self) -> &'static str {
+ match self {
+ BitDepth::Bpc8 => "8 bpc",
+ BitDepth::Bpc16 => "16 bpc",
+ BitDepth::Bpc32 => "32 bpc",
+ }
+ }
+ pub fn next(self) -> BitDepth {
+ match self {
+ BitDepth::Bpc8 => BitDepth::Bpc16,
+ BitDepth::Bpc16 => BitDepth::Bpc32,
+ BitDepth::Bpc32 => BitDepth::Bpc8,
+ }
+ }
+ pub fn is_float(self) -> bool {
+ self == BitDepth::Bpc32
+ }
+ /// Quantisation levels per channel of the integer depths (8 bpc: 255; 16 bpc: 32768, After
+ /// Effects' "15 + 1" bit range), `None` for 32 bpc float.
+ pub fn levels(self) -> Option<f32> {
+ match self {
+ BitDepth::Bpc8 => Some(255.0),
+ BitDepth::Bpc16 => Some(32768.0),
+ BitDepth::Bpc32 => None,
+ }
+ }
+ pub fn bits(self) -> u32 {
+ match self {
+ BitDepth::Bpc8 => 8,
+ BitDepth::Bpc16 => 16,
+ BitDepth::Bpc32 => 32,
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TimeDisplayStyle {
+ #[default]
+ Timecode,
+ Frames,
+ /// Feet + Frames, 35 mm film (16 frames per foot).
+ Feet35,
+ /// Feet + Frames, 16 mm film (40 frames per foot).
+ Feet16,
+}
+
+impl TimeDisplayStyle {
+ /// Frames per foot of the Feet + Frames styles.
+ pub fn frames_per_foot(self) -> Option<i64> {
+ match self {
+ TimeDisplayStyle::Feet35 => Some(16),
+ TimeDisplayStyle::Feet16 => Some(40),
+ _ => None,
+ }
+ }
+ pub fn id(self) -> &'static str {
+ match self {
+ TimeDisplayStyle::Timecode => "timecode",
+ TimeDisplayStyle::Frames => "frames",
+ TimeDisplayStyle::Feet35 => "feet35",
+ TimeDisplayStyle::Feet16 => "feet16",
+ }
+ }
+ pub fn parse(s: &str) -> Option<TimeDisplayStyle> {
+ let k: String = s.chars().filter(char::is_ascii_alphanumeric).collect::<String>().to_ascii_lowercase();
+ match k.as_str() {
+ "timecode" => Some(TimeDisplayStyle::Timecode),
+ "frames" => Some(TimeDisplayStyle::Frames),
+ "feet35" | "feetframes" | "feetandframes" | "feet35mm" | "35mm" | "feetframes35mm" => Some(TimeDisplayStyle::Feet35),
+ "feet16" | "feet16mm" | "16mm" | "feetframes16mm" => Some(TimeDisplayStyle::Feet16),
+ _ => None,
+ }
+ }
+}
+
+/// Project Settings ▸ Color ▸ Color Engine.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ColorEngine {
+ /// Built-in colour management (ICC-style working spaces).
+ #[default]
+ Adobe,
+ /// OCIO managed, with the built-in configuration (ACES working spaces).
+ Ocio,
+}
+
+/// Project Settings ▸ Color ▸ HDR: how over-range (HDR) values reach a standard-dynamic-range
+/// display or output.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum HdrMode {
+ /// Values above 1.0 clip.
+ #[default]
+ Clip,
+ /// Highlights above 80% are companded (an exponential knee) into the remaining range.
+ Compand,
+ /// Extended Reinhard tone mapping of luminance (white at 4.0).
+ ToneMap,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProjectSettings {
+ pub bit_depth: BitDepth,
+ /// Linearize Working Space: the working space uses linear light (1.0 gamma) for everything
+ /// (sources, effects, blending). Needs a working space.
+ pub linearize: bool,
+ /// Working Space (colour management). `None` = no colour management.
+ #[serde(default)]
+ pub working_space: Option<ColorSpace>,
+ /// Blend Colors Using 1.0 Gamma: layers blend in linear light (sources and effects stay in
+ /// the working space's encoding).
+ #[serde(default)]
+ pub blend_linear: bool,
+ pub time_display: TimeDisplayStyle,
+ /// Frame numbering starts at 0 (or 1).
+ pub frame_start: i64,
+ pub audio_sample_rate: u32,
+ /// Video Rendering and Effects ▸ Use: Mercury GPU Acceleration (`true`, the default; used
+ /// when a GPU adapter exists) or Mercury Software Only (`false`, the CPU compositor).
+ #[serde(default = "yes")]
+ pub gpu_acceleration: bool,
+ /// The project's comment (Metadata panel).
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ pub comment: String,
+ /// Color Engine (Adobe-style built-in or OCIO with ACES working spaces).
+ #[serde(default)]
+ pub color_engine: ColorEngine,
+ /// HDR handling for standard-dynamic-range output (display and renders).
+ #[serde(default)]
+ pub hdr: HdrMode,
+ /// The space the top-level comp is output in (renders and the viewer's source). `None` =
+ /// sRGB; Rec. 2100 PQ / HLG give HDR output.
+ #[serde(default)]
+ pub output_space: Option<ColorSpace>,
+ /// Working Gamma, 2.2 or 2.4 (`app.project.workingGamma`): with no working space, the curve
+ /// Interpret As Linear Light footage is encoded with and Blend Colors Using 1.0 Gamma
+ /// linearizes with: the sRGB curve at 2.2, a pure 2.4 power curve at 2.4. Ignored with a
+ /// working space (as in After Effects).
+ #[serde(default = "gamma_22")]
+ pub working_gamma: f64,
+}
+
+fn gamma_22() -> f64 {
+ 2.2
+}
+
+impl ProjectSettings {
+ /// Working Gamma is 2.4 (anything else reads as 2.2).
+ pub fn working_gamma_24(&self) -> bool {
+ (self.working_gamma - 2.4).abs() < 0.05
+ }
+}
+
+impl Default for ProjectSettings {
+ fn default() -> Self {
+ ProjectSettings {
+ bit_depth: BitDepth::Bpc8,
+ linearize: false,
+ working_space: None,
+ blend_linear: false,
+ time_display: TimeDisplayStyle::Timecode,
+ frame_start: 0,
+ audio_sample_rate: 48_000,
+ gpu_acceleration: true,
+ comment: String::new(),
+ color_engine: ColorEngine::Adobe,
+ hdr: HdrMode::Clip,
+ output_space: None,
+ working_gamma: 2.2,
+ }
+ }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct Marker {
+ pub time: Tick,
+ #[serde(default)]
+ pub duration: Tick,
+ #[serde(default)]
+ pub comment: String,
+ #[serde(default)]
+ pub label: Label,
+ #[serde(default)]
+ pub chapter: String,
+ #[serde(default)]
+ pub url: String,
+ #[serde(default)]
+ pub protected: bool,
+ /// Web link frame target (`_blank`, a frame name…).
+ #[serde(default, skip_serializing_if = "String::is_empty")]
+ pub frame_target: String,
+ /// Flash/video cue point (Event or Navigation) with name and parameters.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub cue_point: Option<CuePoint>,
+}
+
+/// A marker's cue point (Composition/Layer Marker dialog ▸ Cue Point).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct CuePoint {
+ pub name: String,
+ /// Navigation (true) or Event cue point.
+ #[serde(default)]
+ pub navigation: bool,
+ /// (name, value) parameter pairs.
+ #[serde(default)]
+ pub params: Vec<(String, String)>,
+}
+
+pub(crate) fn yes() -> bool {
+ true
+}