allow per animation override on workflow

Author: Kyonru

src/components/panels/top/workflows.tsx

@@ -22,6 +22,7 @@ import {
   buildPlaybackClip,
   getAnimationClipFps,
   makeInPlaceClip,
+  type InPlaceAxisModeInput,
 } from "@/utils/animation-clips";
 import type { ResolvedWorkflowCamera } from "@/utils/workflow-camera";
 import type {
@@ -40,6 +41,7 @@ type WorkflowCameraPreviewProps = {
     modelUuid?: string;
     animationName?: string;
     forceAnimationsInPlace?: boolean;
+    forceAnimationsInPlaceMode?: InPlaceAxisModeInput;
   };
   onCameraChange: (camera: {
     distance: number;
@@ -66,6 +68,7 @@ function PreviewModel({
     modelUuid?: string;
     animationName?: string;
     forceAnimationsInPlace?: boolean;
+    forceAnimationsInPlaceMode?: InPlaceAxisModeInput;
   };
 }) {
   const clips = useModelsStore((state) => state.clips);
@@ -144,7 +147,10 @@ function PreviewModel({
     if (!clipRef) return;
 
     const playbackClip = previewAnimation.forceAnimationsInPlace
-      ? makeInPlaceClip(clipRef.clip)
+      ? makeInPlaceClip(
+          clipRef.clip,
+          previewAnimation.forceAnimationsInPlaceMode,
+        )
       : clipRef.clip;
 
     const [trimStart, trimEnd] = modelDurations[animationName] ?? [
@@ -182,6 +188,7 @@ function PreviewModel({
     previewAnimation?.animationName,
     previewAnimation?.modelUuid,
     previewAnimation?.forceAnimationsInPlace,
+    previewAnimation?.forceAnimationsInPlaceMode,
   ]);
 
   if (!object) return null;

src/components/workflows/workflow-camera-preview.tsx

@@ -40,6 +40,33 @@ const NORMAL_MAP_EXPORT_FORMATS = new Set<ExportFormat>([
   "unity",
 ]);
 
+function getCaptureTiming(
+  payload: CaptureStartPayload | null | undefined,
+  defaults: {
+    intervalMs: number;
+    frameCount: number;
+  },
+) {
+  return {
+    intervalMs: Math.max(
+      1,
+      Math.round(
+        Number.isFinite(payload?.frameIntervalMs)
+          ? (payload?.frameIntervalMs ?? defaults.intervalMs)
+          : defaults.intervalMs,
+      ),
+    ),
+    frameCount: Math.max(
+      1,
+      Math.round(
+        Number.isFinite(payload?.frameCount)
+          ? (payload?.frameCount ?? defaults.frameCount)
+          : defaults.frameCount,
+      ),
+    ),
+  };
+}
+
 export const useExport = () => {
   const images = useRef<{ name: string; dataURL: string }[]>([]);
   const normalImages = useRef<{ name: string; dataURL: string }[]>([]);
@@ -263,21 +290,25 @@ export const useExport = () => {
         }) ??
         `animation_${lastIndex.current + 1}`;
       const capturePayload = { ...(payload ?? {}), label: sequenceLabel };
+      const captureTiming = getCaptureTiming(capturePayload, {
+        intervalMs: intervals,
+        frameCount: iterations,
+      });
 
       images.current = [];
       normalImages.current = [];
       activeCaptureRef.current = capturePayload;
 
       intervalRef.current = scheduleInterval(
         captureScreenshotData,
-        intervals,
-        iterations,
+        captureTiming.intervalMs,
+        captureTiming.frameCount,
         () => {
           PubSub.emit(EventType.ASSETS_CREATION_PROGRESS, {
             label: capturePayload.label,
             workflowRunId: capturePayload.workflowRunId,
             capturedFrames: images.current.length,
-            expectedFrames: iterations,
+            expectedFrames: captureTiming.frameCount,
           });
         },
         async () => {
@@ -286,7 +317,7 @@ export const useExport = () => {
             label: capturePayload.label,
             workflowRunId: capturePayload.workflowRunId,
             capturedFrames: images.current.length,
-            expectedFrames: iterations,
+            expectedFrames: captureTiming.frameCount,
             status: "done",
           });
           activeCaptureRef.current = null;
@@ -300,7 +331,7 @@ export const useExport = () => {
               : undefined,
             exportWidth,
             exportHeight,
-            Math.round(1000 / intervals),
+            Math.round(1000 / captureTiming.intervalMs),
             capturePayload.rowMetadata,
           );
           lastIndex.current += 1;
@@ -328,18 +359,22 @@ export const useExport = () => {
     }
 
     const payload = activeCaptureRef.current;
+    const captureTiming = getCaptureTiming(payload, {
+      intervalMs: intervals,
+      frameCount: iterations,
+    });
     PubSub.emit(EventType.STOP_ASSETS_CREATION, {
       label: payload?.label,
       workflowRunId: payload?.workflowRunId,
       capturedFrames: images.current.length,
-      expectedFrames: iterations,
+      expectedFrames: captureTiming.frameCount,
       status: "cancelled",
     });
 
     activeCaptureRef.current = null;
     images.current = [];
     normalImages.current = [];
-  }, [iterations]);
+  }, [intervals, iterations]);
 
   const addScreenshot = useCallback(() => {
     if (!gl) return;

src/hooks/next/use-export.ts

@@ -19,7 +19,9 @@ import {
 import { useEntitiesStore } from "@/store/next/entities";
 import {
   buildWorkflowSteps,
+  getWorkflowStepCaptureSettings,
   type BuildWorkflowStepsInput,
+  type WorkflowCaptureSettings,
   type WorkflowStep,
 } from "@/utils/workflows";
 import {
@@ -198,7 +200,11 @@ async function setStepAnimation(
   if (!clip) return;
 
   if (options?.forceAnimationsInPlace) {
-    modelState.forceCurrentAnimationInPlace(step.modelUuid, step.animationName);
+    modelState.forceCurrentAnimationInPlace(
+      step.modelUuid,
+      step.animationName,
+      options.forceAnimationsInPlaceMode,
+    );
   }
 
   const currentAnimation = modelState.animations[step.modelUuid];
@@ -208,10 +214,6 @@ async function setStepAnimation(
     : Promise.resolve();
 
   modelState.setAnimation(step.modelUuid, step.animationName);
-  modelState.setDuration(step.modelUuid, step.animationName, [
-    0,
-    clip.clip.duration,
-  ]);
   modelState.mixerRef[step.modelUuid]?.setTime(0);
 
   await waiter;
@@ -295,8 +297,10 @@ export const useWorkflow = () => {
 
     const cameraDistance = useSettingsStore.getState().cameraDistance;
     const cameraAngle = useSettingsStore.getState().cameraAngle;
-    const intervals = useImagesStore.getState().intervals;
-    const iterations = useImagesStore.getState().iterations;
+    const defaultCaptureSettings: WorkflowCaptureSettings = {
+      frameIntervalMs: useImagesStore.getState().intervals,
+      frameCount: useImagesStore.getState().iterations,
+    };
     const cameraUUID = useCamerasStore.getState().mainCamera;
     const mainCameraType = cameraUUID
       ? useCamerasStore.getState().cameras[cameraUUID]?.type
@@ -314,7 +318,7 @@ export const useWorkflow = () => {
       currentStep: 0,
       totalSteps: steps.length,
       currentFrame: 0,
-      expectedFrames: iterations,
+      expectedFrames: defaultCaptureSettings.frameCount,
       currentLabel: "",
       currentAnimation: "",
       currentDirection: "",
@@ -327,12 +331,17 @@ export const useWorkflow = () => {
 
         const step = steps[index];
         const dir = getDirectionForStep(workflow, step);
+        const captureSettings = getWorkflowStepCaptureSettings(
+          step,
+          options?.captureSettingsByAnimation,
+          defaultCaptureSettings,
+        );
 
         setWorkflowState((prev) => ({
           ...prev,
           currentStep: index + 1,
           currentFrame: 0,
-          expectedFrames: iterations,
+          expectedFrames: captureSettings.frameCount,
           currentLabel: step.rowLabel,
           currentAnimation: step.animationName,
           currentDirection: step.directionLabel,
@@ -377,14 +386,18 @@ export const useWorkflow = () => {
         const captureDone = waitForCaptureDone({
           label: step.rowLabel,
           workflowRunId,
-          timeoutMs: intervals * iterations + CAPTURE_TIMEOUT_BUFFER_MS,
+          timeoutMs:
+            captureSettings.frameIntervalMs * captureSettings.frameCount +
+            CAPTURE_TIMEOUT_BUFFER_MS,
         });
 
         PubSub.emit(EventType.START_ASSETS_CREATION, {
           label: step.rowLabel,
           workflowRunId,
           stepIndex: index + 1,
           totalSteps: steps.length,
+          frameIntervalMs: captureSettings.frameIntervalMs,
+          frameCount: captureSettings.frameCount,
           rowMetadata: {
             workflow: {
               workflowId: workflow.id,

src/hooks/next/use-workflow.ts

@@ -81,6 +81,8 @@ export type CaptureStartPayload = {
   workflowRunId?: string;
   stepIndex?: number;
   totalSteps?: number;
+  frameIntervalMs?: number;
+  frameCount?: number;
   rowMetadata?: ExportRowMetadata;
 };
 

src/lib/events.ts

@@ -1,5 +1,7 @@
 import { computePosition, type WorkflowDirection } from "@/constants/workflows";
 import type { CameraType } from "@/types/camera";
+import type { WorkflowCaptureSettingsByAnimation } from "./workflows";
+import type { InPlaceAxisModeInput } from "./animation-clips";
 import * as THREE from "three";
 
 export type WorkflowCameraTarget = [number, number, number];
@@ -19,9 +21,11 @@ export type WorkflowRunOptions = {
   target?: WorkflowCameraTarget;
   directionOverrides?: Record<string, WorkflowCameraDirectionOverride>;
   forceAnimationsInPlace?: boolean;
+  forceAnimationsInPlaceMode?: InPlaceAxisModeInput;
   skipStepLabels?: string[];
   includeHiddenAnimations?: boolean;
   captureNormalMaps?: boolean;
+  captureSettingsByAnimation?: WorkflowCaptureSettingsByAnimation;
 };
 
 export type ResolvedWorkflowCamera = {

src/utils/workflow-camera.ts

@@ -7,6 +7,18 @@ export interface WorkflowStep {
   rowLabel: string;
 }
 
+export type WorkflowCaptureSettings = {
+  frameIntervalMs: number;
+  frameCount: number;
+};
+
+export type WorkflowCaptureSettingsInput = Partial<WorkflowCaptureSettings>;
+
+export type WorkflowCaptureSettingsByAnimation = Record<
+  string,
+  WorkflowCaptureSettingsInput
+>;
+
 export type WorkflowClipEntry = {
   clip: {
     name: string;
@@ -127,13 +139,47 @@ export function getDisabledWorkflowAnimationGroupKeys(
     .map((group) => group.key);
 }
 
+export function getWorkflowAnimationGroupKey(
+  step: Pick<WorkflowStep, "animationName">,
+): string {
+  return step.animationName;
+}
+
+export function normalizeWorkflowCaptureSettings(
+  settings: WorkflowCaptureSettingsInput | undefined,
+  defaults: WorkflowCaptureSettings,
+): WorkflowCaptureSettings {
+  const interval = Number.isFinite(settings?.frameIntervalMs)
+    ? settings?.frameIntervalMs
+    : defaults.frameIntervalMs;
+  const count = Number.isFinite(settings?.frameCount)
+    ? settings?.frameCount
+    : defaults.frameCount;
+
+  return {
+    frameIntervalMs: Math.max(1, Math.round(interval ?? 1)),
+    frameCount: Math.max(1, Math.round(count ?? 1)),
+  };
+}
+
+export function getWorkflowStepCaptureSettings(
+  step: WorkflowStep,
+  settingsByAnimation: WorkflowCaptureSettingsByAnimation | undefined,
+  defaults: WorkflowCaptureSettings,
+): WorkflowCaptureSettings {
+  return normalizeWorkflowCaptureSettings(
+    settingsByAnimation?.[getWorkflowAnimationGroupKey(step)],
+    defaults,
+  );
+}
+
 export function groupWorkflowStepsByAnimation(
   steps: WorkflowStep[],
 ): WorkflowStepGroup[] {
   const groups = new Map<string, WorkflowStepGroup>();
 
   for (const step of steps) {
-    const key = step.animationName;
+    const key = getWorkflowAnimationGroupKey(step);
     const group = groups.get(key);
 
     if (group) {

src/utils/workflows.ts

@@ -4,6 +4,7 @@ import {
   buildWorkflowSteps,
   getDisabledWorkflowAnimationGroupKeys,
   getHiddenWorkflowStepLabels,
+  getWorkflowStepCaptureSettings,
   groupWorkflowStepsByAnimation,
   isWorkflowStepHidden,
   type WorkflowClipEntry,
@@ -146,4 +147,49 @@ describe("workflow utilities", () => {
     expect(steps.map((step) => step.rowLabel)).toContain("model-a-_walk_N");
     expect(steps.map((step) => step.rowLabel)).toContain("model-b-_walk_N");
   });
+
+  it("resolves capture timing overrides by animation group", () => {
+    const timingSteps = buildWorkflowSteps(workflow, {
+      clips: { modelA: [clip("walk"), clip("idle")] },
+      modelUuids: ["modelA"],
+    });
+    const walkStep = timingSteps.find((step) => step.animationName === "walk")!;
+    const idleStep = timingSteps.find((step) => step.animationName === "idle")!;
+    const defaults = { frameIntervalMs: 100, frameCount: 10 };
+
+    expect(
+      getWorkflowStepCaptureSettings(
+        walkStep,
+        { walk: { frameIntervalMs: 50, frameCount: 24 } },
+        defaults,
+      ),
+    ).toEqual({ frameIntervalMs: 50, frameCount: 24 });
+    expect(
+      getWorkflowStepCaptureSettings(
+        idleStep,
+        { walk: { frameIntervalMs: 50, frameCount: 24 } },
+        defaults,
+      ),
+    ).toEqual(defaults);
+  });
+
+  it("normalizes partial and invalid capture timing overrides", () => {
+    const walkStep = buildWorkflowSteps(workflow, {
+      clips: { modelA: [clip("walk")] },
+      modelUuids: ["modelA"],
+    })[0];
+
+    expect(
+      getWorkflowStepCaptureSettings(
+        walkStep,
+        {
+          walk: {
+            frameIntervalMs: Number.NaN,
+            frameCount: 4.6,
+          },
+        },
+        { frameIntervalMs: 100, frameCount: 10 },
+      ),
+    ).toEqual({ frameIntervalMs: 100, frameCount: 5 });
+  });
 });