Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use cap_project::{SceneMode, SceneSegment};
pub const MIN_GAP_FOR_TRANSITION: f64 = 0.5;
fn same_mode(a: &SceneMode, b: &SceneMode) -> bool {
std::mem::discriminant(a) == std::mem::discriminant(b)
}
/// Modes where the screen and camera share the frame side-by-side (the
/// compositor morphs both layers toward per-pane target rects).
fn is_split_mode(mode: &SceneMode) -> bool {
matches!(mode, SceneMode::SplitScreen | SceneMode::Floating)
}
#[derive(Debug, Clone, Copy)]
pub struct SceneSegmentsCursor<'a> {
time: f64,
segment: Option<&'a SceneSegment>,
prev_segment: Option<&'a SceneSegment>,
segments: &'a [SceneSegment],
}
impl<'a> SceneSegmentsCursor<'a> {
pub fn new(time: f64, segments: &'a [SceneSegment]) -> Self {
match segments
.iter()
.position(|s| time >= s.start && time < s.end)
{
Some(segment_index) => SceneSegmentsCursor {
time,
segment: Some(&segments[segment_index]),
prev_segment: if segment_index > 0 {
Some(&segments[segment_index - 1])
} else {
None
},
segments,
},
None => {
let prev = segments
.iter()
.enumerate()
.rev()
.find(|(_, s)| s.end <= time);
SceneSegmentsCursor {
time,
segment: None,
prev_segment: prev.map(|(_, s)| s),
segments,
}
}
}
}
pub fn next_segment(&self) -> Option<&'a SceneSegment> {
let current_time = self.time;
self.segments.iter().find(|s| s.start > current_time)
}
}
#[derive(Debug, Clone, Copy)]
pub struct InterpolatedScene {
pub camera_opacity: f64,
pub screen_opacity: f64,
pub camera_scale: f64,
pub scene_mode: SceneMode,
pub transition_progress: f64,
pub from_mode: SceneMode,
pub to_mode: SceneMode,
pub camera_only_zoom: f64,
/// 0.0 = no split layout, 1.0 = fully side-by-side. Ramps with
/// `transition_progress` when entering/leaving [`SceneMode::SplitScreen`]
/// or [`SceneMode::Floating`] so the compositor morphs the screen+camera
/// rects toward their panes.
pub split_factor: f64,
/// Share of the split that is the floating-cards variant
/// ([`SceneMode::Floating`]). Always <= `split_factor`; the compositor
/// blends the pane targets from full-bleed halves toward padded cards by
/// `floating_factor / split_factor` and keeps rounding/shadow chrome alive
/// in proportion to it.
pub floating_factor: f64,
}
impl InterpolatedScene {
fn from_single_mode(scene_mode: SceneMode) -> Self {
let (camera_opacity, screen_opacity, camera_scale) = Self::get_scene_values(&scene_mode);
InterpolatedScene {
camera_opacity,
screen_opacity,
camera_scale,
scene_mode,
transition_progress: 1.0,
from_mode: scene_mode,
to_mode: scene_mode,
camera_only_zoom: 1.0,
split_factor: if is_split_mode(&scene_mode) { 1.0 } else { 0.0 },
floating_factor: if matches!(scene_mode, SceneMode::Floating) {
1.0
} else {
0.0
},
}
}
pub fn new(cursor: SceneSegmentsCursor) -> Self {
let ease_in_out = bezier_easing::bezier_easing(0.42, 0.0, 0.58, 1.0).unwrap();
let (current_mode, next_mode, transition_progress) = if let Some(segment) = cursor.segment {
let transition_in = segment.transition_in.max(0.0);
let transition_out = segment
.transition_out
.clamp(0.0, (segment.end - segment.start).max(0.0));
let transition_start = segment.start - transition_in;
let transition_end = segment.end - transition_out;
if cursor.time < segment.start && cursor.time >= transition_start {
// Check if we should skip transition for small gaps
let prev_mode = if let Some(prev_seg) = cursor.prev_segment {
let gap = segment.start - prev_seg.end;
if gap < MIN_GAP_FOR_TRANSITION && same_mode(&prev_seg.mode, &segment.mode) {
// Small gap between same modes, no transition needed
return InterpolatedScene::from_single_mode(segment.mode);
} else if gap > 0.01 {
SceneMode::Default
} else {
prev_seg.mode
}
} else {
SceneMode::Default
};
let progress = (cursor.time - transition_start) / transition_in.max(1e-4);
(prev_mode, segment.mode, ease_in_out(progress as f32) as f64)
} else if cursor.time >= transition_end && cursor.time < segment.end {
if let Some(next_seg) = cursor.next_segment() {
let gap = next_seg.start - segment.end;
// For small gaps between same-mode segments, don't transition
if gap < MIN_GAP_FOR_TRANSITION && same_mode(&segment.mode, &next_seg.mode) {
// Keep the current mode without transitioning
(segment.mode, segment.mode, 1.0)
} else if gap > 0.01 {
// There's a significant gap, so transition to default scene
let progress =
((cursor.time - transition_end) / transition_out.max(1e-4)).min(1.0);
(
segment.mode,
SceneMode::Default,
ease_in_out(progress as f32) as f64,
)
} else {
// No gap, segments are back-to-back, transition directly if modes differ
let progress =
((cursor.time - transition_end) / transition_out.max(1e-4)).min(1.0);
(
segment.mode,
next_seg.mode,
ease_in_out(progress as f32) as f64,
)
}
} else {
// No next segment, transition to default
let progress =
((cursor.time - transition_end) / transition_out.max(1e-4)).min(1.0);
(
segment.mode,
SceneMode::Default,
ease_in_out(progress as f32) as f64,
)
}
} else {
(segment.mode, segment.mode, 1.0)
}
} else if let Some(next_segment) = cursor.next_segment() {
let transition_in = next_segment.transition_in.max(0.0);
let transition_start = next_segment.start - transition_in;
if let Some(prev_seg) = cursor.prev_segment {
let gap = next_segment.start - prev_seg.end;
// For small gaps between same-mode segments, stay in that mode
if gap < MIN_GAP_FOR_TRANSITION && same_mode(&prev_seg.mode, &next_segment.mode) {
(prev_seg.mode, prev_seg.mode, 1.0)
} else if cursor.time >= transition_start {
// Start transitioning into the next segment
let prev_mode = if gap > 0.01 {
SceneMode::Default
} else {
prev_seg.mode
};
let progress = (cursor.time - transition_start) / transition_in.max(1e-4);
(
prev_mode,
next_segment.mode,
ease_in_out(progress as f32) as f64,
)
} else {
// We're in a gap that requires transition - should be at default
(SceneMode::Default, SceneMode::Default, 1.0)
}
} else if cursor.time >= transition_start {
// No previous segment, transitioning into the first segment
let progress = (cursor.time - transition_start) / transition_in.max(1e-4);
(
SceneMode::Default,
next_segment.mode,
ease_in_out(progress as f32) as f64,
)
} else {
(SceneMode::Default, SceneMode::Default, 1.0)
}
} else {
// No next segment (at the end of timeline)
// The transition should have already completed inside the last segment
(SceneMode::Default, SceneMode::Default, 1.0)
};
let (start_camera_opacity, start_screen_opacity, start_camera_scale) =
Self::get_scene_values(¤t_mode);
let (end_camera_opacity, end_screen_opacity, end_camera_scale) =
Self::get_scene_values(&next_mode);
let camera_opacity = Self::lerp(
start_camera_opacity,
end_camera_opacity,
transition_progress,
);
let screen_opacity = Self::lerp(
start_screen_opacity,
end_screen_opacity,
transition_progress,
);
let camera_scale = Self::lerp(start_camera_scale, end_camera_scale, transition_progress);
let camera_only_zoom = if matches!(next_mode, SceneMode::CameraOnly)
&& !matches!(current_mode, SceneMode::CameraOnly)
{
Self::lerp(1.1, 1.0, transition_progress)
} else if matches!(current_mode, SceneMode::CameraOnly)
&& !matches!(next_mode, SceneMode::CameraOnly)
{
Self::lerp(1.0, 1.1, transition_progress)
} else {
1.0
};
let from_split = is_split_mode(¤t_mode);
let to_split = is_split_mode(&next_mode);
let split_factor = match (from_split, to_split) {
(true, true) => 1.0,
(false, true) => transition_progress,
(true, false) => 1.0 - transition_progress,
(false, false) => 0.0,
};
let from_floating = matches!(current_mode, SceneMode::Floating);
let to_floating = matches!(next_mode, SceneMode::Floating);
let floating_factor = match (from_floating, to_floating) {
(true, true) => 1.0,
(false, true) => transition_progress,
(true, false) => 1.0 - transition_progress,
(false, false) => 0.0,
};
InterpolatedScene {
camera_opacity,
screen_opacity,
camera_scale,
scene_mode: if transition_progress > 0.5 {
next_mode
} else {
current_mode
},
transition_progress,
from_mode: current_mode,
to_mode: next_mode,
camera_only_zoom,
split_factor,
floating_factor,
}
}
fn get_scene_values(mode: &SceneMode) -> (f64, f64, f64) {
match mode {
SceneMode::Default => (1.0, 1.0, 1.0),
SceneMode::CameraOnly => (1.0, 1.0, 1.0),
SceneMode::HideCamera => (0.0, 1.0, 1.0),
// Both panes fully visible; the split geometry (50/50 halves or
// floating cards) is applied in the compositor, driven by
// `split_factor` + `floating_factor`.
SceneMode::SplitScreen | SceneMode::Floating => (1.0, 1.0, 1.0),
}
}
fn lerp(start: f64, end: f64, t: f64) -> f64 {
start + (end - start) * t
}
pub fn should_render_camera(&self) -> bool {
self.camera_opacity > 0.01
}
pub fn should_render_screen(&self) -> bool {
self.screen_opacity > 0.01
}
pub fn is_split(&self) -> bool {
self.split_factor > 0.001
}
pub fn is_transitioning_camera_only(&self) -> bool {
matches!(self.from_mode, SceneMode::CameraOnly)
|| matches!(self.to_mode, SceneMode::CameraOnly)
}
pub fn camera_only_transition_opacity(&self) -> f64 {
if matches!(self.from_mode, SceneMode::CameraOnly)
&& !matches!(self.to_mode, SceneMode::CameraOnly)
{
1.0 - self.transition_progress
} else if !matches!(self.from_mode, SceneMode::CameraOnly)
&& matches!(self.to_mode, SceneMode::CameraOnly)
{
self.transition_progress
} else if matches!(self.from_mode, SceneMode::CameraOnly)
&& matches!(self.to_mode, SceneMode::CameraOnly)
{
1.0
} else {
0.0
}
}
pub fn camera_only_motion(&self, previous: &Self) -> f32 {
if matches!(self.from_mode, SceneMode::CameraOnly)
== matches!(self.to_mode, SceneMode::CameraOnly)
{
return 0.0;
}
// The invisible camera jumps to 1.1x at entry. Opacity tracks the
// continuous part of that 10% zoom without counting the jump as motion.
((self.camera_only_transition_opacity() - previous.camera_only_transition_opacity()).abs()
* 0.1) as f32
}
pub fn regular_camera_transition_opacity(&self) -> f64 {
if matches!(self.to_mode, SceneMode::CameraOnly)
&& !matches!(self.from_mode, SceneMode::CameraOnly)
{
let fast_fade = (1.0 - self.transition_progress * 1.5).max(0.0);
fast_fade * self.camera_opacity
} else if matches!(self.from_mode, SceneMode::CameraOnly)
&& !matches!(self.to_mode, SceneMode::CameraOnly)
{
let fast_fade = (self.transition_progress * 1.5).min(1.0);
fast_fade * self.camera_opacity
} else if matches!(self.from_mode, SceneMode::CameraOnly)
&& matches!(self.to_mode, SceneMode::CameraOnly)
{
0.0
} else {
self.camera_opacity
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn scene_at(time: f64, segments: &[SceneSegment]) -> InterpolatedScene {
InterpolatedScene::new(SceneSegmentsCursor::new(time, segments))
}
fn camera_scene(transition: f64) -> SceneSegment {
SceneSegment {
start: 2.0,
end: 5.0,
mode: SceneMode::CameraOnly,
split_layout: None,
transition_in: transition,
transition_out: transition,
}
}
#[test]
fn long_exit_transition_does_not_jump_at_scene_start() {
let values = |scene: InterpolatedScene| {
[
scene.camera_opacity,
scene.camera_only_transition_opacity(),
scene.camera_only_zoom,
scene.split_factor,
scene.floating_factor,
]
};
for mode in [
SceneMode::CameraOnly,
SceneMode::HideCamera,
SceneMode::SplitScreen,
SceneMode::Floating,
] {
for duration in [0.1, 1.0] {
let segments = [SceneSegment {
end: 2.0 + duration,
mode,
transition_out: 2.0,
..camera_scene(0.3)
}];
let before = values(scene_at(2.0 - 1e-6, &segments));
let start = values(scene_at(2.0, &segments));
for (before, start) in before.into_iter().zip(start) {
assert!(
(before - start).abs() < 1e-5,
"{mode:?}, {duration}s: jumped from {before} to {start}"
);
}
let midpoint = scene_at(2.0 + duration / 2.0, &segments);
assert!((midpoint.transition_progress - 0.5).abs() < 1e-5);
let end = scene_at(segments[0].end, &segments);
assert!(matches!(end.scene_mode, SceneMode::Default));
}
}
}
#[test]
fn loaded_unsorted_scenes_fade_into_the_next_scene() {
let project = tempfile::tempdir().unwrap();
std::fs::write(
project.path().join("project-config.json"),
r#"{
"timeline": {
"segments": [{ "recordingSegment": 0, "start": 0.0, "end": 12.0, "timescale": 1.0 }],
"zoomSegments": [],
"sceneSegments": [
{ "start": 8.0, "end": 10.0, "mode": "cameraOnly" },
{ "start": 1.0, "end": 3.0, "mode": "cameraOnly" },
{ "start": 5.0, "end": 7.0, "mode": "hideCamera" }
]
}
}"#,
)
.unwrap();
let config = cap_project::ProjectConfiguration::load(project.path()).unwrap();
let segments = &config.timeline.as_ref().unwrap().scene_segments;
let before = scene_at(4.6, segments);
let during = scene_at(4.85, segments);
let after = scene_at(5.0, segments);
assert_eq!(before.camera_opacity, 1.0);
assert!(
(during.camera_opacity - 0.5).abs() < 1e-5,
"expected the camera halfway faded out, got {}",
during.camera_opacity
);
assert_eq!(after.camera_opacity, 0.0);
}
#[test]
fn camera_only_blur_tracks_motion_at_both_boundaries() {
let segments = [camera_scene(0.3)];
for fps in [30, 60, 120] {
let motion_at = |frame: u32| {
let scene = scene_at(f64::from(frame) / f64::from(fps), &segments);
let previous = scene_at(f64::from(frame - 1) / f64::from(fps), &segments);
scene.camera_only_motion(&previous) * fps as f32 / 60.0
};
let peak = (fps..6 * fps).map(motion_at).fold(0.0_f32, f32::max);
assert!(peak > 0.005 && peak < 0.011, "{fps} fps: {peak}");
for time in [1.7, 2.0, 4.7, 5.0] {
let frame = (time * f64::from(fps)).round() as u32;
assert!(motion_at(frame) < 0.003, "{fps} fps at {time}");
assert!(motion_at(frame + 1) < 0.003, "{fps} fps after {time}");
}
for time in [1, 3, 6] {
assert_eq!(motion_at(time * fps), 0.0);
}
}
}
#[test]
fn camera_only_cuts_and_contiguous_scenes_do_not_blur() {
let mut segments = [camera_scene(0.0), camera_scene(0.3)];
segments[1].start = segments[0].end;
segments[1].end = 8.0;
for time in [2.0, 4.99, 5.0, 5.01] {
let scene = scene_at(time, &segments);
let previous = scene_at(time - 1.0 / 60.0, &segments);
assert_eq!(scene.camera_only_motion(&previous), 0.0);
}
}
}