665bfac0b339
layer.rs
use super::item::{ItemId, LayerId};
use super::settings::Marker;
use super::{BlendMode, Deserialize, GroupKind, Label, Node, ParamUi, PropGroup, Property, Serialize, Tick, Value};
#[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 Lock and Shy switches and Hide Shy
// Layers never change pixels, and the Audio switch, the Audio group and audio effects change them
// only when something draws the layer's audio (a waveform or spectrum picks it, see
// [`crate::Project::heard_layers`]), so editing those keeps cached frames (#103).
/// Is `id` an audio effect (applied by the audio mix rather than the compositor)?
pub fn is_audio_effect(id: &str) -> bool {
id.starts_with("ec.audio.")
}
/// Does effect `id` read its own layer at other times (`EffectHost::self_at`, `layer_at` on
/// itself): the time effects (Echo, Posterize Time, Timewarp…), simulations, temporal smoothing
/// and analysis (Remove Grain, Auto Levels, Color Stabilizer's reference frame, Warp Stabilizer,
/// Roto Brush…) and Clone strokes with a time offset? On a precomp layer, a change at one nested
/// time then reaches frames of the layer far from where it shows. Plug-in effects (every id
/// outside `ec.`) count too: plug-in API 2 reads the input at other times (`PluginHost`).
// ponytail: hand-kept list of the effects that call `self_at`; a new one must be added here.
pub fn reads_other_frames(id: &str) -> bool {
!id.starts_with("ec.") || id.starts_with("ec.time.") || id.starts_with("ec.sim.") || READS_OTHER_FRAMES.contains(&id)
}
/// The effects outside `ec.time.` and `ec.sim.` that read their own layer at other times.
const READS_OTHER_FRAMES: &[&str] = &[
"ec.noise.removegrain",
"ec.color.autolevels",
"ec.color.autocontrast",
"ec.color.autocolor",
"ec.color.shadowhighlight",
"ec.color.colorstabilizer",
"ec.matte.refinesoft",
"ec.matte.refinehard",
"ec.matte.rotobrush",
"ec.matte.objectmatte",
"ec.blur.camerashakedeblur",
"ec.distort.rollingshutterrepair",
"ec.distort.warpstabilizer",
"ec.key.ccsimplewireremoval",
"ec.paint.paint",
];
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() }
}
/// The switches that change the pixels of a layer: [`Self::pixels`], keeping Audio when
/// something draws the layer's audio (`heard`).
pub fn picture(&self, heard: bool) -> Switches {
Switches { audio: if heard { self.audio } else { true }, ..self.pixels() }
}
}
/// A node only the audio mix reads: the layer's Audio group, an audio effect.
fn audio_only(n: &Node, root: bool) -> bool {
match n {
Node::Group(g) => (root && g.match_id == "audio") || matches!(&g.kind, GroupKind::Effect { effect } if is_audio_effect(effect)),
Node::Prop(_) => false,
}
}
/// `a` and `b` are equal but for their audio-only nodes ([`audio_only`]: the root's Audio group,
/// the effects in its Effects group that are audio effects).
fn same_picture_props(a: &PropGroup, b: &PropGroup) -> bool {
fn head(a: &PropGroup, b: &PropGroup) -> bool {
// Every field (no `..`: a new field must be considered here).
let PropGroup { uid, match_id, name, kind, enabled, label, children: _ } = a;
*uid == b.uid && *match_id == b.match_id && *name == b.name && *kind == b.kind && *enabled == b.enabled && *label == b.label
}
fn children(a: &PropGroup, b: &PropGroup, root: bool) -> bool {
let mut x = a.children.iter().filter(|n| !audio_only(n, root));
let mut y = b.children.iter().filter(|n| !audio_only(n, root));
loop {
match (x.next(), y.next()) {
(None, None) => return true,
(Some(Node::Group(g)), Some(Node::Group(h))) if root && g.match_id == "effects" && h.match_id == "effects" => {
if !(head(g, h) && children(g, h, false)) {
return false;
}
}
(Some(m), Some(n)) if m == n => {}
_ => return false,
}
}
}
head(a, b) && children(a, b, true)
}
/// `g` (a layer's property tree) without its audio-only nodes ([`same_picture_props`]).
fn picture_props(g: &PropGroup) -> PropGroup {
let mut g = g.clone();
g.children.retain(|n| !audio_only(n, true));
for n in &mut g.children {
if let Node::Group(e) = n
&& e.match_id == "effects"
{
e.children.retain(|n| !audio_only(n, false));
}
}
g
}
impl Layer {
/// Draws the same pixels as `o`: equal but for the Audio, Lock and Shy switches and what only
/// the audio mix reads (nothing draws its audio).
pub fn same_pixels(&self, o: &Layer) -> bool {
self.same_pixels_with(o, true, false)
}
/// [`Self::same_pixels`], with the markers counting only when `with_markers` (they are read by
/// expressions alone, so a project without any can edit them freely) and the audio (the Audio
/// switch, the Audio group, audio effects) only when `heard`: something draws it.
pub fn same_pixels_with(&self, o: &Layer, with_markers: bool, heard: bool) -> bool {
// Every field (no `..`: a new field must be considered here); the property tree last.
let Layer {
id,
name,
// Whether the name follows the text changes no pixels until the name changes.
name_follows_text: _,
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.picture(heard) == o.switches.picture(heard)
&& *blend_mode == o.blend_mode
&& *preserve_transparency == o.preserve_transparency
&& *track_matte == o.track_matte
&& *parent == o.parent
&& (!with_markers || *markers == o.markers)
&& *markers_locked == o.markers_locked
&& *auto_orient == o.auto_orient
&& *environment == o.environment
&& *environment_background == o.environment_background
&& (if heard { *props == o.props } else { same_picture_props(props, &o.props) })
}
/// The comp-time spans where `self` draws differently than `o` when the two differ only in
/// the keyframes of Transform properties (a key's value, ease or interpolation moved in the
/// Timeline or Graph Editor): from two keys before the first changed key to two after the
/// last (auto-Bezier and continuous tangents reach the neighbouring segments), to the
/// layer's in or out point past the first or last key (values hold there). `None` for any
/// other difference, a static value, an expression on the layer (it can read the keyed
/// property at other times), roving or muted keys, a time remap or a time effect (it reads other
/// times): those reach the layer's whole span.
pub fn keyframe_spans(&self, o: &Layer, with_markers: bool, heard: bool) -> Option<Vec<(Tick, Tick)>> {
let transform = |l: &Layer| l.props.group("transform").cloned();
let (t1, t0) = (transform(self)?, transform(o)?);
let reads_time = |l: &Layer| {
l.props.get("timeRemap").is_some()
|| l.props.group("effects").is_some_and(|e| {
e.children.iter().any(|n| matches!(n, Node::Group(f) if matches!(&f.kind, GroupKind::Effect { effect } if reads_other_frames(effect))))
})
};
let has_expr = |l: &Layer| {
let mut any = false;
l.props.walk("", &mut |_, p| any |= p.has_expression());
any
};
if reads_time(self) || reads_time(o) || has_expr(self) || has_expr(o) {
return None;
}
// Everything but the Transform group draws the same.
let rest = |l: &Layer| {
let mut l = l.clone();
l.props.children.retain(|n| !matches!(n, Node::Group(g) if g.match_id == "transform"));
l
};
let head = |g: &PropGroup| PropGroup { children: vec![], ..g.clone() };
if !rest(self).same_pixels_with(&rest(o), with_markers, heard) || head(&t1) != head(&t0) || t1.children.len() != t0.children.len() {
return None;
}
let mut spans = Vec::new();
for (n1, n0) in t1.children.iter().zip(&t0.children) {
if n1 == n0 {
continue;
}
let (Node::Prop(p1), Node::Prop(p0)) = (n1, n0) else { return None };
let bare = |p: &Property| Property { keys: vec![], value: Value::Scalar(0.0), ..p.clone() };
// (muted keys are skipped: the keys around an edit that play can be any distance away)
if bare(p1) != bare(p0) || p1.keys.is_empty() || p0.keys.is_empty() || p1.keys.iter().chain(&p0.keys).any(|k| k.roving || k.muted) {
return None;
}
// Keys only one side has as they are (added, removed, edited, moved).
let changed: Vec<Tick> =
p1.keys.iter().filter(|k| !p0.keys.contains(k)).chain(p0.keys.iter().filter(|k| !p1.keys.contains(k))).map(|k| k.time).collect();
let (Some(first), Some(last)) = (changed.iter().min(), changed.iter().max()) else { continue };
// Two keys before the first changed one and two after the last, on either side (the
// first or last key when there are fewer: values hold beyond it). Past the first or
// last key the change reaches the in or out point (`None`).
let mut lo = Some(Tick(i64::MAX));
let mut hi = Some(Tick(i64::MIN));
for keys in [&p1.keys, &p0.keys] {
let before = keys.iter().filter(|k| k.time < *first).count();
let back = if before == 0 { None } else { keys.get(before.saturating_sub(2)) };
lo = lo.zip(back).map(|(a, k)| a.min(k.time));
let upto = keys.iter().filter(|k| k.time <= *last).count();
let ahead = if upto >= keys.len() { None } else { keys.get(upto.saturating_add(1).min(keys.len().saturating_sub(1))) };
hi = hi.zip(ahead).map(|(a, k)| a.max(k.time));
}
let (x, y) = (lo.map_or(self.in_point, |t| self.comp_time(t)), hi.map_or(self.out_point, |t| self.comp_time(t)));
let (x, y) = (x.min(y).max(self.in_point), x.max(y).min(self.out_point));
if x <= y {
spans.push((x, y));
}
}
Some(spans)
}
/// This layer with what doesn't change its pixels at its defaults (see
/// [`Self::same_pixels_with`]), for keys that hash it; `None` when it already is.
pub fn picture_form(&self, heard: bool) -> Option<Layer> {
let switches = self.switches.picture(heard);
let audio = !heard
&& (self.props.children.iter().any(|n| audio_only(n, true))
|| self
.props
.children
.iter()
.any(|n| matches!(n, Node::Group(e) if e.match_id == "effects" && e.children.iter().any(|n| audio_only(n, false)))));
if switches == self.switches && !audio {
return None;
}
let mut l = Layer { switches, ..self.clone() };
if audio {
l.props = picture_props(&self.props);
}
Some(l)
}
}
#[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,
}
/// A stretch written as `null` (a NaN or infinite stretch: JSON holds neither, and auto-saves
/// write it so) reads as NaN, so the project still opens and loading brings it to 100 % with a
/// note ([`crate::limits::stretch`], #3247) instead of the whole file being refused. An infinite
/// stretch therefore also reopens at 100 %, not at ±9900 %.
fn stretch_or_nan<'de, D: serde::Deserializer<'de>>(d: D) -> Result<f64, D::Error> {
Ok(Option::<f64>::deserialize(d)?.unwrap_or(f64::NAN))
}
/// `t × mul / div` in ticks, within [`Tick::MIN`]..=[`Tick::MAX`] (the cast saturates, NaN is 0),
/// so a layer time of an extreme stretch can't overflow later tick arithmetic.
fn scaled(t: Tick, mul: f64, div: f64) -> Tick {
Tick(((t.0 as f64 * mul / div) as i64).clamp(Tick::MIN.0, Tick::MAX.0))
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Layer {
pub id: LayerId,
pub name: String,
/// A text layer's name follows the first line of its Source Text until the user renames it
/// (After Effects). `Some(true)`: it follows, `Some(false)`: the user named it. `None` (older
/// projects, layers made before this was recorded): see [`Layer::name_follows_text()`].
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name_follows_text: Option<bool>,
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).
#[serde(deserialize_with = "stretch_or_nan")]
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,
}
/// The name a text layer takes from its text: the first 40 characters of the first line. A line
/// ends at a line feed or at a bare carriage return (After Effects' paragraph break).
pub fn text_layer_name(text: &str) -> String {
text.split(['\r', '\n']).next().unwrap_or("").chars().take(40).collect()
}
/// A text layer's default name when its text gives none: "Text", numbered "Text 2", "Text 3"…
fn is_default_text_name(name: &str) -> bool {
name == "Text" || name.strip_prefix("Text ").is_some_and(|n| !n.is_empty() && n.chars().all(|c| c.is_ascii_digit()))
}
impl Layer {
/// Whether this text layer's name follows its Source Text, whose first line gives the name
/// `current` (see [`text_layer_name`]). Without a recorded state (an older project), a name
/// that is empty, the text's own, or the default "Text"/"Text 2"… follows; any other name was
/// given by the user.
pub fn name_follows_text(&self, current: &str) -> bool {
self.name_follows_text.unwrap_or_else(|| self.name.is_empty() || self.name == current || is_default_text_name(&self.name))
}
/// The layers this layer reads: its parent, track matte, layer parameters (Displacement Map,
/// Audio Spectrum's Audio Layer…) and tracker targets.
pub fn referenced_layers(&self) -> Vec<LayerId> {
fn walk(g: &PropGroup, depth: usize, out: &mut Vec<LayerId>) {
if depth > 64 {
return;
}
if let GroupKind::Tracker { settings } = &g.kind
&& let Some(t) = settings.target
{
out.push(t);
}
for c in &g.children {
match c {
Node::Prop(p) => {
for v in std::iter::once(&p.value).chain(p.keys.iter().map(|k| &k.value)) {
if let Value::Layer(Some(id)) = v {
out.push(LayerId(*id));
}
}
}
Node::Group(sub) => walk(sub, depth + 1, out),
}
}
}
let mut out: Vec<LayerId> = self.parent.iter().copied().chain(self.track_matte.iter().map(|m| m.layer)).collect();
walk(&self.props, 0, &mut out);
out
}
/// Layers this one picks in an effect or tracker (an Audio Spectrum's Audio Layer, a
/// Displacement Map's map layer…), itself included: [`Self::referenced_layers`] without the
/// parent and the track matte.
pub fn picked_layers(&self) -> Vec<LayerId> {
let skip = usize::from(self.parent.is_some()) + usize::from(self.track_matte.is_some());
self.referenced_layers().into_iter().skip(skip).collect()
}
pub fn is_active_at(&self, t: Tick) -> bool {
t >= self.in_point && t < self.out_point
}
/// The time stretch the layer plays at: [`Layer::stretch`] within
/// [`limits::stretch`](crate::limits::stretch) (a damaged value that got past loading, 0 or
/// NaN, never divides the layer's time by zero).
pub fn effective_stretch(&self) -> f64 {
crate::limits::stretch(self.stretch)
}
/// Layer time for a comp time (stretch-aware).
pub fn layer_time(&self, comp_t: Tick) -> Tick {
let d = comp_t - self.start_time;
let s = self.effective_stretch();
if (s - 100.0).abs() < 1e-9 { d } else { scaled(d, 100.0, s) }
}
/// Comp time for a layer time.
pub fn comp_time(&self, layer_t: Tick) -> Tick {
let s = self.effective_stretch();
if (s - 100.0).abs() < 1e-9 { self.start_time + layer_t } else { self.start_time + scaled(layer_t, s, 100.0) }
}
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")
}
/// The labels popup property `p` of this layer offers: Text Path Options ▸ Path lists None and
/// the layer's masks (value k = mask k), every other popup its own options. `None` when `p` is
/// not a popup.
pub fn popup_options<'a>(&'a self, p: &'a Property) -> Option<std::borrow::Cow<'a, [String]>> {
if self.props.prop("text/pathOptions/path").is_some_and(|q| q.uid == p.uid) {
let masks = self.masks().into_iter().flat_map(|m| m.groups().map(|g| g.name.clone()));
return Some(std::iter::once("None".to_string()).chain(masks).collect::<Vec<_>>().into());
}
match &p.ui {
ParamUi::Popup { options } => Some(options.as_slice().into()),
_ => None,
}
}
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
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.