//! Content selected by layer parameters participates in the owner's cache key. Keep the //! ordinary layer cache (including static self reads), and conservatively decline only //! cyclic/over-budget graphs or expressions sampled at unknown times. use super::{KeyHasher, hash_debug, hash_values}; use crate::EvalCtx; use effectcraft_project::{ItemId, ItemKind, Layer, LayerId, LayerSource, LightKind, Node, PropGroup}; use std::hash::Hash; pub(super) fn hash(h: &mut KeyHasher, ctx: &EvalCtx, layer: &Layer, effects: super::EffectScope) -> Option<()> { // A footprint runs no effects: nothing they read is in its pixels or its key. let limit = match effects { super::EffectScope::Footprint => return Some(()), super::EffectScope::All => None, super::EffectScope::First(n) => Some(n), }; let mut deps = Dependencies { h, path: vec![(ctx.comp_id, layer.id)], remaining: 1024, other_times: super::reads_other_times(layer, None) }; deps.effects(ctx, layer, limit) } struct Dependencies<'a> { h: &'a mut KeyHasher, path: Vec<(ItemId, LayerId)>, remaining: usize, other_times: bool, } impl Dependencies<'_> { fn effects(&mut self, ctx: &EvalCtx, layer: &Layer, limit: Option) -> Option<()> { let previous = self.other_times; self.other_times |= super::reads_other_times(layer, None); if layer.switches.effects && let Some(fx) = layer.effects() { for g in fx.groups().take(limit.unwrap_or(usize::MAX)).filter(|g| g.enabled) { self.group(ctx, layer, g, 0)?; // A LUT file edited on disk changes the pixels without an edit (#3493). crate::reads::lut_files(ctx, layer, g).hash(self.h); } } self.other_times = previous; Some(()) } fn group(&mut self, ctx: &EvalCtx, layer: &Layer, g: &PropGroup, depth: usize) -> Option<()> { if depth >= 32 { return None; } for node in &g.children { match node { Node::Prop(p) => { if let Some(id) = ctx.value(layer, p).as_layer() { p.uid.hash(self.h); id.hash(self.h); let other = ctx.layer(LayerId(id)); other.is_some().hash(self.h); if let Some(other) = other { if other.id == layer.id { // Source/Masks never enter the same stack again. The owner // key already covers its source and mask properties. hash_debug(self.h, &ctx.world_matrix(other)); } else { self.layer(ctx, other)?; } } } } Node::Group(sub) if sub.enabled => self.group(ctx, layer, sub, depth + 1)?, _ => {} } } Some(()) } /// What a referenced 3D model or primitive layer's solo render depends on: the layer itself /// (geometry, materials, switches, in/out), its animated values and transform at the time, /// the mesh item, the comp's camera (with its depth of field) and its lights at the time /// (the lights are off in draft 3D, and the renderer setting changes the pixels), the model's /// layer time while it plays an animation clip, and the in/out gate (outside the range the /// read is transparent). An Environment light's image can be any layer's render: with one on /// the read is not cached. Comp size and render scale are in the owner's key already. fn soloed_model(&mut self, ctx: &EvalCtx, layer: &Layer) -> Option<()> { self.remaining = self.remaining.checked_sub(1)?; // Expressions sampled at other times: not cacheable, as in the ordinary path. if (self.other_times || super::reads_other_times(layer, None)) && super::has_expression(&layer.props) { return None; } hash_debug(self.h, layer); // An overridden clip plays on the layer clock and a keyed one from its key: the same // selection at the same time can pose differently. super::hash_overrides(self.h, ctx, layer.id); hash_values(self.h, ctx, layer, &layer.props); hash_debug(self.h, &ctx.world_matrix(layer)); if let Some(item) = layer.source.item() { hash_debug(self.h, &ctx.project.item(item)); } // The solo render goes through the comp's camera and lights. The camera's depth of // field blurs it (focus, aperture, iris, highlights) — none of that is in the // projection hashed above. hash_debug(self.h, &ctx.camera()); hash_debug(self.h, &crate::three_d::active_camera(ctx).dof); hash_debug(self.h, &crate::three_d::light::lights_at(ctx)); hash_debug(self.h, &ctx.comp.draft_3d); hash_debug(self.h, &ctx.comp.renderer); // An Environment light's image lights Advanced 3D models (its source can be any // layer's render, or any environment layer) — too open-ended to hash: while one is // on (and lighting: Draft 3D lights nothing), don't cache the read. if ctx.comp.renderer == effectcraft_project::Renderer::Advanced3D && !ctx.comp.draft_3d && ctx.comp.layers.iter().any(|l| { l.is_light() && l.switches.video && l.is_active_at(ctx.time) && matches!(l.source, LayerSource::Light { kind: LightKind::Environment }) }) { return None; } // A model with an animation clip selected is posed at its layer time (Animation Speed // and Looping are static, hashed above): every time is its own entry. Without one the // pose is the same at every time: keep the static key. if layer.props.sub("geometryOptions").map_or(0, |g| ctx.e(layer, g, "animation")) != 0 { layer.layer_time(ctx.time).0.hash(self.h); } // Outside the layer's in/out range the read is transparent: fold the gate in, so a // static model renders once inside it and again when it leaves. layer.is_active_at(ctx.time).hash(self.h); Some(()) } /// Folds what the layer contributes at this time into the dependency cache key, including its source, effects and frame blend state. /// Returns `None` when the layer cannot be keyed: past the depth limit, in a reference cycle, or with expressions that read other times. fn layer(&mut self, ctx: &EvalCtx, layer: &Layer) -> Option<()> { let id = (ctx.comp_id, layer.id); if self.path.len() > crate::MAX_FX_DEPTH || self.path.contains(&id) { return None; } // A referenced 3D model or primitive layer renders through the comp's camera and lights // (an effect layer parameter reads it that way — Create 3D Layer Instance): hash what // moves its pixels, so the owner keeps a cache entry that changes when any of it does. if layer.source.is_model() { self.soloed_model(ctx, layer)?; return Some(()); } self.remaining = self.remaining.checked_sub(1)?; if (self.other_times || super::reads_other_times(layer, None)) && super::has_expression(&layer.props) { return None; } self.path.push(id); // Include transforms/parents as well as pixels: selected-layer anchors and // continuously rasterized sources can depend on them. hash_debug(self.h, layer); // A referenced layer's static values can be overridden by the collapsed instance without // editing it (`hash_values` only sees animated ones), so the owner's key needs them too. super::hash_overrides(self.h, ctx, layer.id); hash_values(self.h, ctx, layer, &layer.props); hash_debug(self.h, &ctx.world_matrix(layer)); // A cached owner never runs this layer's effects, so the comp camera and lights its // scene-reading effects see belong in the owner's key too (#1252). if super::reads_comp_scene(layer) { hash_debug(self.h, &crate::comp_scene(ctx, layer)); } if super::time_dependent(layer, true) { layer.layer_time(ctx.time).0.hash(self.h); } match layer.source { LayerSource::Solid { item } | LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Model { item } => { let item = match layer.source { LayerSource::Footage { .. } => ctx.media_item(layer, item), _ => item, }; let source = ctx.project.item(item); hash_debug(self.h, &source); if let Some(source) = source { match &source.kind { ItemKind::Footage(_) => { ctx.source_time(layer).0.hash(self.h); super::hash_blend_spans(self.h, ctx, layer); } ItemKind::Comp(comp) => { let time = ctx.source_time(layer); time.0.hash(self.h); // The nested layers are walked without this instance's Essential // Properties overrides, which the render applies: a LUT file one of // them names is read too (#3493). for o in crate::fx_host::essential_overrides(ctx, layer) { if let effectcraft_keyframe::Value::Str(src) = &o.value { crate::reads::source_files(src).hash(self.h); } } let nested = EvalCtx::new(ctx.project, item, comp, time); for child in &comp.layers { self.layer(&nested, child)?; } } _ => {} } } } _ => {} } self.effects(ctx, layer, None)?; self.path.pop(); Some(()) } }