Skip to content

Visualize Your Ideas With Code

feat(ui): estimate remaining rendering time (#795)

Jacob1a4614801869
diff --git a/packages/core/src/app/Renderer.ts b/packages/core/src/app/Renderer.ts
index 0ea71287..171defdd 100644
--- a/packages/core/src/app/Renderer.ts
+++ b/packages/core/src/app/Renderer.ts
@@ -8,6 +8,8 @@ import {Vector2} from '../types';
import {PlaybackStatus} from './PlaybackStatus';
import {Semaphore} from '../utils';
import {ReadOnlyTimeEvents} from '../scenes/timeEvents';
+import {clampRemap} from '../tweening';
+import {TimeEstimator} from './TimeEstimator';
export interface RendererSettings extends StageSettings {
name: string;
@@ -58,6 +60,7 @@ export class Renderer {
private readonly frame = new ValueDispatcher(0);
public readonly stage = new Stage();
+ public readonly estimator = new TimeEstimator();
private readonly lock = new Semaphore();
private readonly playback: PlaybackManager;
@@ -92,6 +95,7 @@ export class Renderer {
public async render(settings: RendererSettings) {
if (this.state.current !== RendererState.Initial) return;
await this.lock.acquire();
+ this.estimator.reset();
this.state.current = RendererState.Working;
let result: RendererResult;
try {
@@ -110,6 +114,7 @@ export class Renderer {
}
}
+ this.estimator.update(1);
this.state.current = RendererState.Initial;
this.finished.dispatch(result);
this.lock.release();
@@ -190,22 +195,29 @@ export class Renderer {
this.playback.fps = settings.fps;
this.playback.state = PlaybackState.Rendering;
const from = this.status.secondsToFrames(settings.range[0]);
- const to = this.status.secondsToFrames(settings.range[1]);
+ this.frame.current = from;
await this.reloadScenes(settings);
await this.playback.recalculate();
if (signal.aborted) return RendererResult.Aborted;
await this.playback.reset();
if (signal.aborted) return RendererResult.Aborted;
+
+ const to = Math.min(
+ this.playback.duration,
+ this.status.secondsToFrames(settings.range[1]),
+ );
await this.playback.seek(from);
if (signal.aborted) return RendererResult.Aborted;
await this.exporter.start?.();
-
let lastRefresh = performance.now();
let result = RendererResult.Success;
try {
+ this.estimator.reset(1 / (to - from));
await this.exportFrame(signal);
+ this.estimator.update(clampRemap(from, to, 0, 1, this.playback.frame));
+
if (signal.aborted) {
result = RendererResult.Aborted;
} else {
@@ -213,6 +225,9 @@ export class Renderer {
while (!finished) {
await this.playback.progress();
await this.exportFrame(signal);
+ this.estimator.update(
+ clampRemap(from, to, 0, 1, this.playback.frame),
+ );
if (performance.now() - lastRefresh > 1 / 30) {
lastRefresh = performance.now();
await new Promise(resolve => setTimeout(resolve, 0));
diff --git a/packages/core/src/app/TimeEstimator.ts b/packages/core/src/app/TimeEstimator.ts
new file mode 100644
index 00000000..59cd8c6d
--- /dev/null
+++ b/packages/core/src/app/TimeEstimator.ts
@@ -0,0 +1,84 @@
+import {ValueDispatcher} from '../events';
+import {clamp} from '../tweening';
+
+/**
+ * An estimate of the time remaining until the process is finished.
+ */
+export interface TimeEstimate {
+ /**
+ * The completion percentage ranging from `0` to `1`.
+ */
+ completion: number;
+ /**
+ * The time passed since the beginning of the process in milliseconds.
+ */
+ elapsed: number;
+ /**
+ * The estimated time remaining until the process is finished in milliseconds.
+ */
+ eta: number;
+}
+
+/**
+ * Calculates the estimated time remaining until a process is finished.
+ */
+export class TimeEstimator {
+ public get onCompletionChanged() {
+ return this.completion.subscribable;
+ }
+ private readonly completion = new ValueDispatcher(0);
+ private startTimestamp = 0;
+ private lastUpdateTimestamp = 0;
+ private nextCompletion = 0;
+
+ /**
+ * Get the current time estimate.
+ *
+ * @param timestamp - The timestamp to calculate the estimate against.
+ * Defaults to `performance.now()`.
+ */
+ public estimate(timestamp = performance.now()): TimeEstimate {
+ const elapsed = timestamp - this.startTimestamp;
+ const completion = this.completion.current;
+
+ let eta = Infinity;
+ if (completion >= 1) {
+ eta = 0;
+ } else if (completion > 0) {
+ const lastUpdateDuration = this.lastUpdateTimestamp - this.startTimestamp;
+ eta = lastUpdateDuration / completion - elapsed;
+ eta = Math.max(0, eta);
+ } else if (this.nextCompletion > 0) {
+ eta = elapsed / this.nextCompletion - elapsed;
+ }
+
+ return {completion, elapsed, eta};
+ }
+
+ /**
+ * Update the completion percentage.
+ *
+ * @param completion - The completion percentage ranging from `0` to `1`.
+ * @param timestamp - A timestamp at which the process was updated.
+ * Defaults to `performance.now()`.
+ */
+ public update(completion: number, timestamp = performance.now()) {
+ this.completion.current = clamp(0, 1, completion);
+ this.lastUpdateTimestamp = timestamp;
+ }
+
+ /**
+ * Reset the estimator.
+ *
+ * @param nextCompletion - If known, the completion percentage of the next
+ * update.
+ * @param timestamp - A timestamp at which the process started.
+ * Defaults to `performance.now()`.
+ */
+ public reset(nextCompletion = 0, timestamp = performance.now()) {
+ this.startTimestamp = timestamp;
+ this.lastUpdateTimestamp = timestamp;
+ this.completion.current = 0;
+ this.nextCompletion = nextCompletion;
+ }
+}
diff --git a/packages/ui/src/components/playback/Playback.module.scss b/packages/ui/src/components/playback/Playback.module.scss
index 9cea1246..06618255 100644
--- a/packages/ui/src/components/playback/Playback.module.scss
+++ b/packages/ui/src/components/playback/Playback.module.scss
@@ -13,11 +13,6 @@
justify-content: center;
gap: 16px;
- &.disabled {
- opacity: 0.54;
- pointer-events: none;
- }
-
select,
input {
width: 100px;
diff --git a/packages/ui/src/components/playback/PlaybackControls.tsx b/packages/ui/src/components/playback/PlaybackControls.tsx
index fd7410a9..1252ff44 100644
--- a/packages/ui/src/components/playback/PlaybackControls.tsx
+++ b/packages/ui/src/components/playback/PlaybackControls.tsx
@@ -1,12 +1,10 @@
import styles from './Playback.module.scss';
import {IconButton, IconCheckbox, Input, Select} from '../controls';
-import {useDocumentEvent, usePlayerState, useRendererState} from '../../hooks';
+import {useDocumentEvent, usePlayerState} from '../../hooks';
import {Framerate} from './Framerate';
import {useCallback} from 'preact/hooks';
import {useApplication} from '../../contexts';
-import clsx from 'clsx';
-import React from 'react';
import {
Pause,
PhotoCamera,
@@ -17,12 +15,10 @@ import {
VolumeOff,
VolumeOn,
} from '../icons';
-import {RendererState} from '@motion-canvas/core';
export function PlaybackControls() {
const {player, renderer, meta, project} = useApplication();
const state = usePlayerState();
- const rendererState = useRendererState();
useDocumentEvent(
'keydown',
@@ -67,12 +63,7 @@ export function PlaybackControls() {
);
return (
- <div
- className={clsx(
- styles.controls,
- rendererState === RendererState.Working && styles.disabled,
- )}
- >
+ <div className={styles.controls}>
<Select
title="Playback speed"
options={[
@@ -127,13 +118,7 @@ export function PlaybackControls() {
<Input
title="Current framerate"
readOnly
- value={
- rendererState === RendererState.Working
- ? 'RENDERING'
- : paused
- ? 'PAUSED'
- : `${framerate} FPS`
- }
+ value={paused ? 'PAUSED' : `${framerate} FPS`}
/>
)}
/>
diff --git a/packages/ui/src/components/playback/PlaybackProgress.tsx b/packages/ui/src/components/playback/PlaybackProgress.tsx
index d04fcee2..f1c3aaf4 100644
--- a/packages/ui/src/components/playback/PlaybackProgress.tsx
+++ b/packages/ui/src/components/playback/PlaybackProgress.tsx
@@ -1,15 +1,31 @@
import styles from './Playback.module.scss';
-import {usePlayerTime} from '../../hooks';
+import {usePlayerTime, useSubscribableValue} from '../../hooks';
+import {useApplication} from '../../contexts';
export function PlaybackProgress() {
const state = usePlayerTime();
+ return <Progress completion={state.completion} />;
+}
+
+export function RenderingProgress() {
+ const {renderer} = useApplication();
+ const completion = useSubscribableValue(
+ renderer.estimator.onCompletionChanged,
+ );
+ return <Progress completion={completion} />;
+}
+
+interface ProgressProps {
+ completion: number;
+}
+function Progress({completion}: ProgressProps) {
return (
<div className={styles.progress}>
<div
className={styles.progressFill}
- style={{width: `${state.completion * 100}%`}}
+ style={{width: `${completion * 100}%`}}
/>
</div>
);
diff --git a/packages/ui/src/components/viewport/Timestamp.tsx b/packages/ui/src/components/viewport/Timestamp.tsx
new file mode 100644
index 00000000..41b0c0c5
--- /dev/null
+++ b/packages/ui/src/components/viewport/Timestamp.tsx
@@ -0,0 +1,31 @@
+import {JSX} from 'preact';
+import {useApplication} from '../../contexts';
+import {usePlayerState} from '../../hooks';
+import {formatDuration} from '../../utils';
+import styles from './Viewport.module.scss';
+
+interface TimestampProps extends JSX.HTMLAttributes<HTMLInputElement> {
+ frame: number;
+}
+
+export function Timestamp({frame, ...rest}: TimestampProps) {
+ const {player} = useApplication();
+ const {speed} = usePlayerState();
+
+ let precision = 0;
+ let padding = player.status.fps.toString().length;
+ if (speed % 1 !== 0) {
+ precision = 2;
+ padding += 3;
+ }
+
+ return (
+ <code {...rest}>
+ <span>
+ {formatDuration(player.status.framesToSeconds(frame))}:
+ {(frame % player.status.fps).toFixed(precision).padStart(padding, '0')}
+ </span>
+ <span className={styles.frames}>[{frame.toFixed(precision)}]</span>
+ </code>
+ );
+}
diff --git a/packages/ui/src/components/viewport/Viewport.tsx b/packages/ui/src/components/viewport/Viewport.tsx
index 1e1b9bdee..6bb35dee 100644
--- a/packages/ui/src/components/viewport/Viewport.tsx
+++ b/packages/ui/src/components/viewport/Viewport.tsx
@@ -1,5 +1,9 @@
-import {useDuration, usePlayerState, useRendererState} from '../../hooks';
-import {PlaybackControls, PlaybackProgress} from '../playback';
+import {useDuration, useRendererState} from '../../hooks';
+import {
+ PlaybackControls,
+ PlaybackProgress,
+ RenderingProgress,
+} from '../playback';
import {CurrentTime} from '../playback/CurrentTime';
import {EditorPreview} from './EditorPreview';
import styles from './Viewport.module.scss';
@@ -7,61 +11,80 @@ import {useApplication} from '../../contexts';
import {CustomStage} from './CustomStage';
import {RendererState} from '@motion-canvas/core';
import {useShortcut} from '../../hooks/useShortcut';
+import {formatDuration} from '../../utils';
+import {useEffect, useState} from 'preact/hooks';
+import {Timestamp} from './Timestamp';
export function Viewport() {
+ const state = useRendererState();
+ return state === RendererState.Working ? (
+ <RenderingViewport />
+ ) : (
+ <EditorViewport />
+ );
+}
+
+function EditorViewport() {
const [hoverRef] = useShortcut<HTMLDivElement>('viewport');
- const {player, renderer} = useApplication();
const duration = useDuration();
- const {speed} = usePlayerState();
- const state = useRendererState();
return (
<div ref={hoverRef} className={styles.root}>
- {state === RendererState.Working ? (
- <CustomStage stage={renderer.stage} />
- ) : (
- <EditorPreview />
- )}
+ <EditorPreview />
<PlaybackProgress />
<div className={styles.playback}>
<CurrentTime
- render={time => {
- return (
- <code className={styles.time} title="Current time">
- {formatDuration(player.status.framesToSeconds(time))}
- <span className={styles.frames}>
- [{formatFrames(time, speed)}]
- </span>
- </code>
- );
- }}
+ render={time => (
+ <Timestamp
+ className={styles.time}
+ title="Current Time"
+ frame={time}
+ />
+ )}
/>
<PlaybackControls />
- <code className={styles.duration} title="Duration">
- <span className={styles.frames}>
- [{formatFrames(duration, speed)}]
- </span>
- {formatDuration(player.status.framesToSeconds(duration))}
- </code>
+ <Timestamp
+ className={styles.duration}
+ title="Duration"
+ frame={duration}
+ />
</div>
</div>
);
}
-function formatDuration(duration: number) {
- const minutes = Math.floor(duration / 60) % 60;
- const seconds = Math.floor(duration % 60);
+function RenderingViewport() {
+ const {renderer} = useApplication();
+ const [estimate, setEstimate] = useState(renderer.estimator.estimate());
- return `${minutes.toString().padStart(2, '0')}:${seconds
- .toString()
- .padStart(2, '0')}`;
-}
+ useEffect(() => {
+ const id = setInterval(() => {
+ setEstimate(renderer.estimator.estimate());
+ }, 100);
+ return () => clearInterval(id);
+ }, []);
-function formatFrames(frames: number, speed: number) {
- const round = speed % 1 === 0;
- if (round) {
- return frames;
- } else {
- return frames.toFixed(2);
- }
+ return (
+ <div className={styles.root}>
+ <CustomStage stage={renderer.stage} />
+ <RenderingProgress />
+ <div className={styles.playback}>
+ <code
+ className={styles.time}
+ title="Time elapsed since the rendering started"
+ >
+ {formatDuration(estimate.elapsed / 1000)}
+ <span className={styles.frames}>Elapsed</span>
+ </code>
+ <div />
+ <code
+ className={styles.duration}
+ title="Estimated time remaining until the rendering is complete"
+ >
+ <span className={styles.frames}>ETA:</span>
+ {formatDuration(estimate.eta / 1000)}
+ </code>
+ </div>
+ </div>
+ );
}
diff --git a/packages/ui/src/hooks/useShortcut.ts b/packages/ui/src/hooks/useShortcut.ts
index e480d3ee..c5148fe1 100644
--- a/packages/ui/src/hooks/useShortcut.ts
+++ b/packages/ui/src/hooks/useShortcut.ts
@@ -1,4 +1,3 @@
-import React from 'react';
import {useShortcuts, ShortcutModules} from '../contexts/shortcuts';
import {useHover} from './useHover';
diff --git a/packages/ui/src/utils/compareVersions.tsx b/packages/ui/src/utils/compareVersions.ts
similarity index 100%
rename from packages/ui/src/utils/compareVersions.tsx
rename to packages/ui/src/utils/compareVersions.ts
diff --git a/packages/ui/src/utils/formatDuration.ts b/packages/ui/src/utils/formatDuration.ts
new file mode 100644
index 00000000..1309c815
--- /dev/null
+++ b/packages/ui/src/utils/formatDuration.ts
@@ -0,0 +1,18 @@
+/**
+ * Return the given duration in a HH:MM:SS format.
+ *
+ * @param duration - The duration in seconds.
+ */
+export function formatDuration(duration: number) {
+ if (duration === Infinity || duration === -Infinity || isNaN(duration)) {
+ return '??:??:??';
+ }
+
+ const hours = Math.floor(duration / 3600);
+ const minutes = Math.floor(duration / 60) % 60;
+ const seconds = Math.floor(duration % 60);
+
+ return `${hours.toString().padStart(2, '0')}:${minutes
+ .toString()
+ .padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+}
diff --git a/packages/ui/src/utils/index.ts b/packages/ui/src/utils/index.ts
index b69c26b4..c967d8bd 100644
--- a/packages/ui/src/utils/index.ts
+++ b/packages/ui/src/utils/index.ts
@@ -1,6 +1,7 @@
export * from './clamp';
+export * from './compareVersions';
+export * from './formatDuration';
export * from './localStorage';
export * from './openOutputPath';
export * from './sourceMaps';
export * from './withLoader';
-export * from './compareVersions';