Skip to content

Code-first video & image, rendered natively on WebGPU.

fix: sample effect signals at composition frame

okanasl1b916a9b46bc
diff --git a/.gitignore b/.gitignore
index 8d5f6bf6..432ddb5b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,10 +30,10 @@ Thumbs.db
*.woff2
*.eot
assets/fonts/
-
+examples/25_bakery
# Soundfonts
*.sf2
-assets/soundfonts/
+assets
# Heavy Media, Video, Audio & Images
*.mp4
diff --git a/nodes/node-blur/src/renderers/webgpu-renderer.ts b/nodes/node-blur/src/renderers/webgpu-renderer.ts
index 81601826..4a3c5345 100644
--- a/nodes/node-blur/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-blur/src/renderers/webgpu-renderer.ts
@@ -833,6 +833,7 @@ export const BlurWebGPURenderer: WebGPUNodeRenderer = async (args) => {
drawChild,
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as BlurOp | undefined;
if (op?.op !== "Blur" || !op) return;
@@ -856,7 +857,13 @@ export const BlurWebGPURenderer: WebGPUNodeRenderer = async (args) => {
const nodeId = op.inputs ? Object.keys(op.inputs)[0] : "blur_node";
const resolveBindable = (
- configKey: "strength" | "sigmaColor" | "centerX" | "centerY" | "radius" | "radiusY",
+ configKey:
+ | "strength"
+ | "sigmaColor"
+ | "centerX"
+ | "centerY"
+ | "radius"
+ | "radiusY",
defaultValue: number,
minVal: number,
maxVal: number,
@@ -880,7 +887,7 @@ export const BlurWebGPURenderer: WebGPUNodeRenderer = async (args) => {
let val = defaultValue;
let hasStaticSig = false;
- let gpuTextureView: GPUTextureView | undefined = undefined;
+ let gpuTextureView: GPUTextureView | undefined;
if (!hasSignal) {
if (input?.connectionValid && input.outputItem?.type === "Number") {
@@ -891,10 +898,20 @@ export const BlurWebGPURenderer: WebGPUNodeRenderer = async (args) => {
let rawVal = op[configKey] as unknown;
if (rawVal !== undefined && rawVal !== null) {
if (typeof rawVal === "object") {
- if ("get" in (rawVal as Record<string, unknown>) && typeof (rawVal as Record<string, unknown>).get === "function") {
- rawVal = (rawVal as { get: (ctx: { frame: number; fps: number }) => unknown }).get({ frame, fps });
+ if (
+ "get" in (rawVal as Record<string, unknown>) &&
+ typeof (rawVal as Record<string, unknown>).get === "function"
+ ) {
+ rawVal = (
+ rawVal as {
+ get: (ctx: { frame: number; fps: number }) => unknown;
+ }
+ ).get({ frame: compositionFrame, fps });
} else if ("value" in (rawVal as Record<string, unknown>)) {
- const sig = rawVal as { value: unknown; gpuBinding?: { textureView?: GPUTextureView } };
+ const sig = rawVal as {
+ value: unknown;
+ gpuBinding?: { textureView?: GPUTextureView };
+ };
if (sig.gpuBinding?.textureView) {
gpuTextureView = sig.gpuBinding.textureView;
hasStaticSig = true;
@@ -902,11 +919,17 @@ export const BlurWebGPURenderer: WebGPUNodeRenderer = async (args) => {
rawVal = sig.value;
}
} else if (typeof rawVal === "function") {
- rawVal = (rawVal as (f: number, fps: number) => unknown)(frame, fps);
+ rawVal = (rawVal as (f: number, fps: number) => unknown)(
+ compositionFrame,
+ fps,
+ );
}
}
const numVal = Number(rawVal ?? defaultValue);
- val = Math.max(minVal, Math.min(maxVal, isNaN(numVal) ? defaultValue : numVal));
+ val = Math.max(
+ minVal,
+ Math.min(maxVal, isNaN(numVal) ? defaultValue : numVal),
+ );
if (scaleByDpi) val *= dpiScale;
}
} else if (sd) {
@@ -1049,8 +1072,8 @@ export const BlurWebGPURenderer: WebGPUNodeRenderer = async (args) => {
// Prepare uniform template (64 bytes / 16 floats)
const isPartial = Boolean(
op.partialBlur &&
- (op.partialBlur as unknown) !== "false" &&
- (op.partialBlur as unknown) !== 0,
+ (op.partialBlur as unknown) !== "false" &&
+ (op.partialBlur as unknown) !== 0,
);
blurData[2] = strengthRes.val;
blurData[3] = Number(op.angle ?? 0.0);
diff --git a/nodes/node-camera-parallax-3d/src/renderers/webgpu-renderer.ts b/nodes/node-camera-parallax-3d/src/renderers/webgpu-renderer.ts
index 5153d686..659dbfe7 100644
--- a/nodes/node-camera-parallax-3d/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-camera-parallax-3d/src/renderers/webgpu-renderer.ts
@@ -572,6 +572,7 @@ export const CameraParallax3DWebGPURenderer: WebGPUNodeRenderer = async (
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 60;
const op = props.virtualMedia?.operation as CameraParallax3DOp | undefined;
if (op?.op !== "CameraParallax3D" || !op) return;
@@ -687,7 +688,9 @@ export const CameraParallax3DWebGPURenderer: WebGPUNodeRenderer = async (
// 4. Resolve timing and signals
const elapsedSeconds =
- props.elapsedMs !== undefined ? props.elapsedMs / 1000 : frame / fps;
+ props.elapsedMs !== undefined
+ ? props.elapsedMs / 1000
+ : compositionFrame / fps;
const durationSeconds = props.virtualMedia?.metadata?.durationMs
? props.virtualMedia.metadata.durationMs / 1000
: props.durationMs !== undefined
diff --git a/nodes/node-color-balance/src/renderers/webgpu-renderer.ts b/nodes/node-color-balance/src/renderers/webgpu-renderer.ts
index 50c5b2b7..249ec621 100644
--- a/nodes/node-color-balance/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-color-balance/src/renderers/webgpu-renderer.ts
@@ -305,6 +305,7 @@ export const ColorBalanceWebGPURenderer: WebGPUNodeRenderer = async (args) => {
pass.end();
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const childMedia = props.virtualMedia.children[0];
const width = targetWidth;
@@ -355,10 +356,22 @@ export const ColorBalanceWebGPURenderer: WebGPUNodeRenderer = async (args) => {
const resolveVal = (val: unknown): number => {
if (val !== undefined && val !== null) {
- if (typeof val === "object" && "value" in (val as Record<string, unknown>)) {
- val = (val as { value: unknown }).value;
+ if (typeof val === "object" && val !== null) {
+ if (
+ "get" in (val as Record<string, unknown>) &&
+ typeof (val as { get: unknown }).get === "function"
+ ) {
+ val = (
+ val as { get: (ctx: { frame: number; fps: number }) => unknown }
+ ).get({ frame: compositionFrame, fps });
+ } else if ("value" in (val as Record<string, unknown>)) {
+ val = (val as { value: unknown }).value;
+ }
} else if (typeof val === "function") {
- val = (val as (f: number, fps: number) => unknown)(frame, fps);
+ val = (val as (f: number, fps: number) => unknown)(
+ compositionFrame,
+ fps,
+ );
}
}
const n = Number(val ?? 0);
diff --git a/nodes/node-compositor/src/renderers/audio-processor.ts b/nodes/node-compositor/src/renderers/audio-processor.ts
index dbe039a1..fe8ed349 100644
--- a/nodes/node-compositor/src/renderers/audio-processor.ts
+++ b/nodes/node-compositor/src/renderers/audio-processor.ts
@@ -90,7 +90,7 @@ export const compositorLayerAudioProcessor: AudioProcessor = async (
for (let i = 0; i < numSamples; i += subChunkSize) {
const nextI = Math.min(numSamples, i + subChunkSize);
- const tNext = startTimeSec + (nextI - i) / sampleRate;
+ const tNext = startTimeSec + nextI / sampleRate;
tl.seek(tNext);
const nextVol = stub.volume;
const nextMuted = stub.muted;
diff --git a/nodes/node-compositor/src/renderers/webgpu-renderer.ts b/nodes/node-compositor/src/renderers/webgpu-renderer.ts
index 61732af5..74db347a 100644
--- a/nodes/node-compositor/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-compositor/src/renderers/webgpu-renderer.ts
@@ -644,6 +644,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
? frame + Math.round(inheritedSeekOffset * fps)
: (frame ?? 0),
);
+ const compositionFrame = props.compositionFrame ?? shiftedFrame;
// 1. Create a temporary texture at native resolution
const compTex = ctx.renderer.getTemporaryTexture(
@@ -1219,6 +1220,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
fps,
isVideoMode,
frame: shiftedFrame,
+ compositionFrame,
// The child's effect passes must not borrow textures still in use here.
excludeTextures: [targetTexture, ...activeExcludes],
},
@@ -2710,7 +2712,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
relightOpts as Record<string, unknown>,
sceneLights,
rect,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
);
@@ -2744,7 +2746,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
relightOpts.specularRoughness ??
relightOpts.roughness,
0.35,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
specularStrength: resolveVal(
@@ -2752,7 +2754,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightSpecularStrength ??
relightOpts.specularStrength,
0.7,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
metallic: resolveVal(
@@ -2760,7 +2762,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightMetallic ??
relightOpts.metallic,
0.0,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
ambientIntensity: resolveVal(
@@ -2768,7 +2770,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightAmbientIntensity ??
relightOpts.ambientIntensity,
0.15,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
depthScale: resolveVal(
@@ -2776,7 +2778,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightDepthScale ??
relightOpts.depthScale,
1.0,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
opacity: 1.0,
@@ -3080,6 +3082,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
? Math.round(lop.trimStartSec * (fps ?? 24))
: 0)),
}),
+ compositionFrame,
...(isCaption && {
fontFamily: lop.fontFamily,
fontSize: target?.fontSize ?? lop.fontSize,
@@ -3359,7 +3362,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
relightOpts as Record<string, unknown>,
sceneLights,
{ x: sampledX, y: sampledY, width: texW, height: texH },
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
);
const lightsBuffer = r3dInstance.getOrCreateLightsBuffer(activeLights);
@@ -3391,7 +3394,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
relightOpts.specularRoughness ??
relightOpts.roughness,
0.35,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
specularStrength: resolveVal(
@@ -3399,7 +3402,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightSpecularStrength ??
relightOpts.specularStrength,
0.7,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
metallic: resolveVal(
@@ -3407,7 +3410,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightMetallic ??
relightOpts.metallic,
0.0,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
ambientIntensity: resolveVal(
@@ -3415,7 +3418,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightAmbientIntensity ??
relightOpts.ambientIntensity,
0.15,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
depthScale: resolveVal(
@@ -3423,7 +3426,7 @@ export const CompositorWebGPURenderer: WebGPUNodeRenderer = async (args) => {
target?.relightDepthScale ??
relightOpts.depthScale,
1.0,
- shiftedFrame,
+ compositionFrame,
fps ?? 24,
),
opacity: 1.0,
diff --git a/nodes/node-deflicker/src/renderers/webgpu-renderer.ts b/nodes/node-deflicker/src/renderers/webgpu-renderer.ts
index 1d302c93..bb63c18d 100644
--- a/nodes/node-deflicker/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-deflicker/src/renderers/webgpu-renderer.ts
@@ -74,7 +74,12 @@ function resolveVal(
function resolveProp(
op: TemporalDeflickerOp,
- fieldName: "blendWeight" | "disocclusionThreshold" | "maxMotionPixels" | "scale" | "windowSize",
+ fieldName:
+ | "blendWeight"
+ | "disocclusionThreshold"
+ | "maxMotionPixels"
+ | "scale"
+ | "windowSize",
defaultValue: number,
minVal: number,
maxVal: number,
@@ -88,9 +93,10 @@ function resolveProp(
let raw: unknown;
if (input?.connectionValid && input.outputItem) {
const outData = input.outputItem.data as Record<string, unknown> | null;
- raw = outData && typeof outData === "object" && "offset" in outData
- ? outData.offset
- : input.outputItem.data;
+ raw =
+ outData && typeof outData === "object" && "offset" in outData
+ ? outData.offset
+ : input.outputItem.data;
} else {
raw = op[fieldName];
}
@@ -144,6 +150,7 @@ export const TemporalDeflickerWebGPURenderer: WebGPUNodeRenderer = async (
const width = targetWidth;
const height = targetHeight;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
// 1. Draw child source media into a clean temporary texture
@@ -185,11 +192,37 @@ export const TemporalDeflickerWebGPURenderer: WebGPUNodeRenderer = async (
args.pass.end();
// 2. Resolve properties defensively with signal support
- const blendWeight = resolveProp(op, "blendWeight", 0.35, 0.0, 1.0, frame, fps);
- const disocclusionThreshold = resolveProp(op, "disocclusionThreshold", 0.15, 0.01, 1.0, frame, fps);
- const maxMotionPixels = resolveProp(op, "maxMotionPixels", 64.0, 1.0, 256.0, frame, fps);
- const scale = resolveProp(op, "scale", 0.5, 0.1, 1.0, frame, fps);
- const windowSize = Math.round(resolveProp(op, "windowSize", 2, 1, 5, frame, fps));
+ const blendWeight = resolveProp(
+ op,
+ "blendWeight",
+ 0.35,
+ 0.0,
+ 1.0,
+ compositionFrame,
+ fps,
+ );
+ const disocclusionThreshold = resolveProp(
+ op,
+ "disocclusionThreshold",
+ 0.15,
+ 0.01,
+ 1.0,
+ compositionFrame,
+ fps,
+ );
+ const maxMotionPixels = resolveProp(
+ op,
+ "maxMotionPixels",
+ 64.0,
+ 1.0,
+ 256.0,
+ compositionFrame,
+ fps,
+ );
+ const scale = resolveProp(op, "scale", 0.5, 0.1, 1.0, compositionFrame, fps);
+ const windowSize = Math.round(
+ resolveProp(op, "windowSize", 2, 1, 5, compositionFrame, fps),
+ );
// 3. Execute temporal optical flow warping & adaptive blend
const pipelineKey =
diff --git a/nodes/node-film-grain/src/renderers/webgpu-renderer.ts b/nodes/node-film-grain/src/renderers/webgpu-renderer.ts
index 726039eb..c945250c 100644
--- a/nodes/node-film-grain/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-film-grain/src/renderers/webgpu-renderer.ts
@@ -288,6 +288,7 @@ export const FilmGrainWebGPURenderer: WebGPUNodeRenderer = async (args) => {
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as FilmGrainOp | undefined;
if (op?.op !== "FilmGrain" || !op) return;
@@ -323,10 +324,19 @@ export const FilmGrainWebGPURenderer: WebGPUNodeRenderer = async (args) => {
const resolveVal = (val: unknown, fallback: number): number => {
if (val === undefined || val === null) return fallback;
- if (typeof val === "object" && "value" in (val as Record<string, unknown>)) {
- val = (val as { value: unknown }).value;
+ if (typeof val === "object" && val !== null) {
+ if (
+ "get" in (val as Record<string, unknown>) &&
+ typeof (val as { get: unknown }).get === "function"
+ ) {
+ val = (
+ val as { get: (ctx: { frame: number; fps: number }) => unknown }
+ ).get({ frame: compositionFrame, fps });
+ } else if ("value" in (val as Record<string, unknown>)) {
+ val = (val as { value: unknown }).value;
+ }
} else if (typeof val === "function") {
- val = (val as (f: number, fps: number) => unknown)(frame, fps);
+ val = (val as (f: number, fps: number) => unknown)(compositionFrame, fps);
}
const n = Number(val);
return Number.isFinite(n) ? n : fallback;
diff --git a/nodes/node-halftone-screen/src/renderers/webgpu-renderer.ts b/nodes/node-halftone-screen/src/renderers/webgpu-renderer.ts
index 9ab6d407..deb4f091 100644
--- a/nodes/node-halftone-screen/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-halftone-screen/src/renderers/webgpu-renderer.ts
@@ -456,6 +456,7 @@ export const HalftoneScreenWebGPURenderer: WebGPUNodeRenderer = async (
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as unknown as
| HalftoneScreenOp
@@ -510,9 +511,31 @@ export const HalftoneScreenWebGPURenderer: WebGPUNodeRenderer = async (
Math.min(maxVal, Number(input.outputItem.data ?? defaultValue)),
);
} else {
+ let rawVal = op[configKey] as unknown;
+ if (rawVal !== undefined && rawVal !== null) {
+ if (typeof rawVal === "object") {
+ if (
+ "get" in (rawVal as Record<string, unknown>) &&
+ typeof (rawVal as Record<string, unknown>).get === "function"
+ ) {
+ rawVal = (
+ rawVal as {
+ get: (ctx: { frame: number; fps: number }) => unknown;
+ }
+ ).get({ frame: compositionFrame, fps });
+ } else if ("value" in (rawVal as Record<string, unknown>)) {
+ rawVal = (rawVal as { value: unknown }).value;
+ }
+ } else if (typeof rawVal === "function") {
+ rawVal = (rawVal as (f: number, fps: number) => unknown)(
+ compositionFrame,
+ fps,
+ );
+ }
+ }
val = Math.max(
minVal,
- Math.min(maxVal, Number(op[configKey] ?? defaultValue)),
+ Math.min(maxVal, Number(rawVal ?? defaultValue)),
);
}
} else if (sd) {
diff --git a/nodes/node-modulate/src/renderers/webgpu-renderer.ts b/nodes/node-modulate/src/renderers/webgpu-renderer.ts
index a3c443bc..dca3aed5 100644
--- a/nodes/node-modulate/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-modulate/src/renderers/webgpu-renderer.ts
@@ -35,10 +35,18 @@ interface FieldSignalInfo {
value: number;
}
-function resolveVal(val: unknown, fallback: number, frame: number, fps: number): number {
+function resolveVal(
+ val: unknown,
+ fallback: number,
+ frame: number,
+ fps: number,
+): number {
if (val === undefined || val === null) return fallback;
if (typeof val === "object" && val !== null) {
- if ("get" in (val as Record<string, unknown>) && typeof (val as { get: unknown }).get === "function") {
+ if (
+ "get" in (val as Record<string, unknown>) &&
+ typeof (val as { get: unknown }).get === "function"
+ ) {
try {
const res = (val as { get: (ctx?: unknown) => unknown }).get({
frame,
@@ -104,7 +112,8 @@ function resolveModulateField(
) {
value = Number(signalInput.outputItem.data ?? defaultValue);
} else {
- const raw = op[fieldName] ?? (op as Record<string, unknown>).signals?.[fieldName];
+ const raw =
+ op[fieldName] ?? (op as Record<string, unknown>).signals?.[fieldName];
value = resolveVal(raw, defaultValue, frame, fps);
}
} else if (sd && typeof sd === "object" && "offset" in sd) {
@@ -441,6 +450,7 @@ export const ModulateWebGPURenderer: WebGPUNodeRenderer = async (args) => {
drawChild,
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as ModulateOp | undefined;
if (op?.op !== "Modulate" || !op) return;
@@ -450,12 +460,60 @@ export const ModulateWebGPURenderer: WebGPUNodeRenderer = async (args) => {
pass.end();
- const hueInfo = resolveModulateField(op, "hue", 0, 0, 360, frame, fps);
- const brightnessInfo = resolveModulateField(op, "brightness", 1, 0, 2, frame, fps);
- const contrastInfo = resolveModulateField(op, "contrast", 1, 0, 2, frame, fps);
- const exposureInfo = resolveModulateField(op, "exposure", 0, -2, 2, frame, fps);
- const saturationInfo = resolveModulateField(op, "saturation", 1, 0, 2, frame, fps);
- const sepiaInfo = resolveModulateField(op, "sepia", 0, 0, 1, frame, fps);
+ const hueInfo = resolveModulateField(
+ op,
+ "hue",
+ 0,
+ 0,
+ 360,
+ compositionFrame,
+ fps,
+ );
+ const brightnessInfo = resolveModulateField(
+ op,
+ "brightness",
+ 1,
+ 0,
+ 2,
+ compositionFrame,
+ fps,
+ );
+ const contrastInfo = resolveModulateField(
+ op,
+ "contrast",
+ 1,
+ 0,
+ 2,
+ compositionFrame,
+ fps,
+ );
+ const exposureInfo = resolveModulateField(
+ op,
+ "exposure",
+ 0,
+ -2,
+ 2,
+ compositionFrame,
+ fps,
+ );
+ const saturationInfo = resolveModulateField(
+ op,
+ "saturation",
+ 1,
+ 0,
+ 2,
+ compositionFrame,
+ fps,
+ );
+ const sepiaInfo = resolveModulateField(
+ op,
+ "sepia",
+ 0,
+ 0,
+ 1,
+ compositionFrame,
+ fps,
+ );
const width = targetWidth;
const height = targetHeight;
diff --git a/nodes/node-patch-heal/src/renderers/webgpu-renderer.ts b/nodes/node-patch-heal/src/renderers/webgpu-renderer.ts
index 09cf9381..bccca729 100644
--- a/nodes/node-patch-heal/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-patch-heal/src/renderers/webgpu-renderer.ts
@@ -381,6 +381,7 @@ export const PatchHealWebGPURenderer: WebGPUNodeRenderer = async (args) => {
const width = targetWidth;
const height = targetHeight;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const nodeId = op.inputs ? Object.keys(op.inputs)[0] : "patch_heal_node";
@@ -525,7 +526,33 @@ export const PatchHealWebGPURenderer: WebGPUNodeRenderer = async (args) => {
fallbackVal);
val = Math.max(minVal, Math.min(maxVal, Number(numVal)));
} else {
- val = Math.max(minVal, Math.min(maxVal, fallbackVal));
+ let rawVal = fallbackVal as unknown;
+ if (rawVal !== undefined && rawVal !== null) {
+ if (typeof rawVal === "object") {
+ if (
+ "get" in (rawVal as Record<string, unknown>) &&
+ typeof (rawVal as Record<string, unknown>).get === "function"
+ ) {
+ rawVal = (
+ rawVal as {
+ get: (ctx: { frame: number; fps: number }) => unknown;
+ }
+ ).get({ frame: compositionFrame, fps });
+ } else if ("value" in (rawVal as Record<string, unknown>)) {
+ rawVal = (rawVal as { value: unknown }).value;
+ }
+ } else if (typeof rawVal === "function") {
+ rawVal = (rawVal as (f: number, fps: number) => unknown)(
+ compositionFrame,
+ fps,
+ );
+ }
+ }
+ const numVal = Number(rawVal ?? fallbackVal);
+ val = Math.max(
+ minVal,
+ Math.min(maxVal, isNaN(numVal) ? fallbackVal : numVal),
+ );
}
} else if (sd) {
val = Math.max(minVal, Math.min(maxVal, Number(sd.offset ?? 0.0)));
diff --git a/nodes/node-relight-3d/src/renderers/webgpu-renderer.ts b/nodes/node-relight-3d/src/renderers/webgpu-renderer.ts
index 6f8171cd..5dcf9045 100644
--- a/nodes/node-relight-3d/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-relight-3d/src/renderers/webgpu-renderer.ts
@@ -534,7 +534,12 @@ function resolveSignalField(
signalInput?.connectionValid &&
signalInput.outputItem?.type === "Number"
) {
- const raw = resolveVal(signalInput.outputItem.data, defaultValue, frame, fps);
+ const raw = resolveVal(
+ signalInput.outputItem.data,
+ defaultValue,
+ frame,
+ fps,
+ );
value = Math.max(minVal, Math.min(maxVal, raw));
} else {
const raw = resolveVal(op[fieldName], defaultValue, frame, fps);
@@ -562,6 +567,7 @@ export const Relight3DWebGPURenderer: WebGPUNodeRenderer = async (args) => {
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as Relight3DOp | undefined;
if (op?.op !== "Relight3D" || !op) return;
@@ -683,26 +689,76 @@ export const Relight3DWebGPURenderer: WebGPUNodeRenderer = async (args) => {
// 4. Resolve signal textures
const elapsedSeconds =
- props.elapsedMs !== undefined ? props.elapsedMs / 1000 : frame / fps;
+ props.elapsedMs !== undefined
+ ? props.elapsedMs / 1000
+ : compositionFrame / fps;
const durationSeconds = props.virtualMedia?.metadata?.durationMs
? props.virtualMedia.metadata.durationMs / 1000
: props.durationMs !== undefined
? props.durationMs / 1000
: 4.0;
- const intensityInfo = resolveSignalField(op, "intensity", 1.0, 0.0, 10.0, frame, fps);
- const posXInfo = resolveSignalField(op, "lightPosX", 0.5, 0.0, 1.0, frame, fps);
- const posYInfo = resolveSignalField(op, "lightPosY", 0.5, 0.0, 1.0, frame, fps);
- const posZInfo = resolveSignalField(op, "lightPosZ", 0.3, -2.0, 2.0, frame, fps);
- const radiusInfo = resolveSignalField(op, "lightRadius", 0.8, 0.05, 5.0, frame, fps);
- const spotConeInfo = resolveSignalField(op, "spotConeAngle", 45, 5, 90, frame, fps);
+ const intensityInfo = resolveSignalField(
+ op,
+ "intensity",
+ 1.0,
+ 0.0,
+ 10.0,
+ compositionFrame,
+ fps,
+ );
+ const posXInfo = resolveSignalField(
+ op,
+ "lightPosX",
+ 0.5,
+ 0.0,
+ 1.0,
+ compositionFrame,
+ fps,
+ );
+ const posYInfo = resolveSignalField(
+ op,
+ "lightPosY",
+ 0.5,
+ 0.0,
+ 1.0,
+ compositionFrame,
+ fps,
+ );
+ const posZInfo = resolveSignalField(
+ op,
+ "lightPosZ",
+ 0.3,
+ -2.0,
+ 2.0,
+ compositionFrame,
+ fps,
+ );
+ const radiusInfo = resolveSignalField(
+ op,
+ "lightRadius",
+ 0.8,
+ 0.05,
+ 5.0,
+ compositionFrame,
+ fps,
+ );
+ const spotConeInfo = resolveSignalField(
+ op,
+ "spotConeAngle",
+ 45,
+ 5,
+ 90,
+ compositionFrame,
+ fps,
+ );
const roughnessInfo = resolveSignalField(
op,
"specularRoughness",
0.35,
0.01,
1.0,
- frame,
+ compositionFrame,
fps,
);
const specularInfo = resolveSignalField(
@@ -711,21 +767,45 @@ export const Relight3DWebGPURenderer: WebGPUNodeRenderer = async (args) => {
0.7,
0.0,
3.0,
- frame,
+ compositionFrame,
+ fps,
+ );
+ const metallicInfo = resolveSignalField(
+ op,
+ "metallic",
+ 0.0,
+ 0.0,
+ 1.0,
+ compositionFrame,
+ fps,
+ );
+ const ambientInfo = resolveSignalField(
+ op,
+ "ambientIntensity",
+ 0.4,
+ 0.0,
+ 2.0,
+ compositionFrame,
fps,
);
- const metallicInfo = resolveSignalField(op, "metallic", 0.0, 0.0, 1.0, frame, fps);
- const ambientInfo = resolveSignalField(op, "ambientIntensity", 0.4, 0.0, 2.0, frame, fps);
const volumetricInfo = resolveSignalField(
op,
"volumetricDensity",
0.2,
0.0,
1.0,
- frame,
+ compositionFrame,
+ fps,
+ );
+ const depthScaleInfo = resolveSignalField(
+ op,
+ "depthScale",
+ 1.0,
+ 0.1,
+ 10.0,
+ compositionFrame,
fps,
);
- const depthScaleInfo = resolveSignalField(op, "depthScale", 1.0, 0.1, 10.0, frame, fps);
const getSigTextureView = (
info: { hasSignal: boolean; sd: RelightSignalData | null },
@@ -742,7 +822,7 @@ export const Relight3DWebGPURenderer: WebGPUNodeRenderer = async (args) => {
width,
height,
props.renderId,
- frame,
+ compositionFrame,
fps,
);
}
@@ -795,7 +875,7 @@ export const Relight3DWebGPURenderer: WebGPUNodeRenderer = async (args) => {
uniformData[12] = depthScaleInfo.value;
uniformData[13] = op.depthInvert ? 1.0 : 0.0;
- uniformData[14] = (hasDepthMap || hasNormalMap) ? 1.0 : 0.0;
+ uniformData[14] = hasDepthMap || hasNormalMap ? 1.0 : 0.0;
uniformData[15] = hasNormalMap ? 1.0 : 0.0;
uniformData[16] = intensityInfo.hasSignal ? 1.0 : 0.0;
diff --git a/nodes/node-rotate/CHANGELOG.md b/nodes/node-rotate/CHANGELOG.md
new file mode 100644
index 00000000..a9d15117
--- /dev/null
+++ b/nodes/node-rotate/CHANGELOG.md
@@ -0,0 +1 @@
+# @framefields/node-rotate
diff --git a/nodes/node-rotate/package.json b/nodes/node-rotate/package.json
new file mode 100644
index 00000000..329f0a1d
--- /dev/null
+++ b/nodes/node-rotate/package.json
@@ -0,0 +1,47 @@
+{
+ "name": "@framefields/node-rotate",
+ "version": "2.0.8",
+ "private": false,
+ "framefields": {
+ "type": "Rotate",
+ "kind": "effect",
+ "schema": "RotateNodeConfigSchema"
+ },
+ "type": "module",
+ "license": "Apache-2.0",
+ "exports": {
+ ".": {
+ "types": "./dist/index.d.mts",
+ "development": "./src/index.ts",
+ "import": "./dist/index.mjs",
+ "default": "./dist/index.mjs"
+ },
+ "./renderer": {
+ "types": "./dist/renderer.d.mts",
+ "development": "./src/renderers/index.ts",
+ "import": "./dist/renderer.mjs",
+ "default": "./dist/renderer.mjs"
+ }
+ },
+ "scripts": {
+ "build": "tsdown",
+ "dev": "tsdown --watch",
+ "clean": "rm -rf dist .turbo"
+ },
+ "dependencies": {
+ "@framefields/core": "workspace:*",
+ "@framefields/node-sdk": "workspace:*",
+ "@framefields/webgpu-renderers": "workspace:*",
+ "zod": "^4.3.6"
+ },
+ "devDependencies": {
+ "@framefields/tsconfig": "workspace:*",
+ "@types/node": "^24.1.0",
+ "tsdown": "^0.19.0",
+ "typescript": "^5.8.3",
+ "webgpu": "^0.4.0"
+ },
+ "publishConfig": {
+ "access": "public"
+ }
+}
diff --git a/nodes/node-rotate/src/index.ts b/nodes/node-rotate/src/index.ts
new file mode 100644
index 00000000..34f8d698
--- /dev/null
+++ b/nodes/node-rotate/src/index.ts
@@ -0,0 +1,2 @@
+export * from "./shared/index.js";
+export * from "./renderers/index.js";
diff --git a/nodes/node-rotate/src/renderers/index.ts b/nodes/node-rotate/src/renderers/index.ts
new file mode 100644
index 00000000..10a8b67b
--- /dev/null
+++ b/nodes/node-rotate/src/renderers/index.ts
@@ -0,0 +1,6 @@
+import { defineRenderer } from "@framefields/node-sdk/renderer";
+import { WebGPURenderer } from "./webgpu-renderer.js";
+
+export default defineRenderer({
+ WebGPURenderer,
+});
diff --git a/nodes/node-rotate/src/renderers/webgpu-renderer.ts b/nodes/node-rotate/src/renderers/webgpu-renderer.ts
new file mode 100644
index 00000000..16b07315
--- /dev/null
+++ b/nodes/node-rotate/src/renderers/webgpu-renderer.ts
@@ -0,0 +1,339 @@
+/// <reference types="webgpu" />
+import type { VirtualMediaData } from "@framefields/core";
+import type { WebGPUNodeRenderer } from "@framefields/node-sdk";
+import { probeVideoSize } from "@framefields/webgpu-renderers";
+import { rotatedSourceSize } from "../shared/config.js";
+
+/** A plain number, a per-frame function, or a signal (`{ value }`). */
+type NumericProp =
+ | number
+ | ((frame: number, fps: number) => number)
+ | { value: unknown };
+
+interface RotateOp {
+ op: "Rotate";
+ angle?: NumericProp;
+ fit?: "cover" | "contain" | "fill";
+ scale?: NumericProp;
+ opacity?: number;
+}
+
+// Inverse-maps each output pixel into the source: p (px from the output
+// center) turned back by the angle, divided by the source's on-screen size.
+// Edges are antialiased over one output pixel so animated angles stay clean.
+const WGSL_ROTATE_SHADER = `
+struct RotateUniforms {
+ outSize: vec2<f32>,
+ size : vec2<f32>,
+ cs : vec2<f32>,
+ _pad : vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u : RotateUniforms;
+@group(1) @binding(0) var tex : texture_2d<f32>;
+@group(1) @binding(1) var samp : sampler;
+
+struct VSOut {
+ @builtin(position) pos : vec4<f32>,
+ @location(0) uv : vec2<f32>,
+};
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> VSOut {
+ var pos = array<vec2<f32>, 4>(
+ vec2<f32>(-1.0, 1.0),
+ vec2<f32>(1.0, 1.0),
+ vec2<f32>(-1.0, -1.0),
+ vec2<f32>(1.0, -1.0)
+ );
+ var uv = array<vec2<f32>, 4>(
+ vec2<f32>(0.0, 0.0),
+ vec2<f32>(1.0, 0.0),
+ vec2<f32>(0.0, 1.0),
+ vec2<f32>(1.0, 1.0)
+ );
+ return VSOut(vec4<f32>(pos[vi], 0.0, 1.0), uv[vi]);
+}
+
+@fragment fn fs(in : VSOut) -> @location(0) vec4<f32> {
+ let p = (in.uv - vec2<f32>(0.5)) * u.outSize;
+ // Clockwise on screen (y down): undo it with the transpose.
+ let q = vec2<f32>(u.cs.x * p.x + u.cs.y * p.y, -u.cs.y * p.x + u.cs.x * p.y);
+ let uv = q / u.size + vec2<f32>(0.5);
+ // Distance (output px) inside the source rectangle's nearest edge.
+ let edge = (vec2<f32>(0.5) - abs(uv - vec2<f32>(0.5))) * u.size;
+ let coverage = clamp(min(edge.x, edge.y) + 0.5, 0.0, 1.0);
+ let color = textureSampleLevel(tex, samp, clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0)), 0.0);
+ // Premultiplied: coverage scales every channel.
+ return color * coverage;
+}
+`;
+
+interface DeviceRotateResources {
+ uniformLayout: GPUBindGroupLayout;
+ textureLayout: GPUBindGroupLayout;
+ pipeline: GPURenderPipeline;
+}
+
+const deviceResourceCache = new WeakMap<GPUDevice, DeviceRotateResources>();
+const uniformData = new Float32Array(8);
+
+function getRotateResources(
+ device: GPUDevice,
+ targetFormat: GPUTextureFormat,
+): DeviceRotateResources {
+ const cached = deviceResourceCache.get(device);
+ if (cached) return cached;
+
+ const uniformLayout = device.createBindGroupLayout({
+ entries: [
+ {
+ binding: 0,
+ visibility: GPUShaderStage.FRAGMENT,
+ buffer: { type: "uniform" },
+ },
+ ],
+ });
+
+ const textureLayout = device.createBindGroupLayout({
+ entries: [
+ {
+ binding: 0,
+ visibility: GPUShaderStage.FRAGMENT,
+ texture: { sampleType: "float" },
+ },
+ {
+ binding: 1,
+ visibility: GPUShaderStage.FRAGMENT,
+ sampler: { type: "filtering" },
+ },
+ ],
+ });
+
+ const shaderModule = device.createShaderModule({ code: WGSL_ROTATE_SHADER });
+
+ const pipeline = device.createRenderPipeline({
+ layout: device.createPipelineLayout({
+ bindGroupLayouts: [uniformLayout, textureLayout],
+ }),
+ vertex: { module: shaderModule, entryPoint: "vs" },
+ fragment: {
+ module: shaderModule,
+ entryPoint: "fs",
+ // The pass clears and writes every pixel: no blending needed.
+ targets: [{ format: targetFormat }],
+ },
+ primitive: { topology: "triangle-strip" },
+ });
+
+ const res: DeviceRotateResources = { uniformLayout, textureLayout, pipeline };
+ deviceResourceCache.set(device, res);
+ return res;
+}
+
+function resolveNumber(
+ raw: NumericProp | undefined,
+ fallback: number,
+ frame: number,
+ fps: number,
+): number {
+ const value =
+ typeof raw === "function"
+ ? raw(frame, fps)
+ : raw !== null && typeof raw === "object"
+ ? "get" in raw && typeof (raw as { get: unknown }).get === "function"
+ ? (
+ raw as { get: (ctx: { frame: number; fps: number }) => unknown }
+ ).get({ frame, fps })
+ : "value" in raw
+ ? raw.value
+ : raw
+ : raw;
+ const n = Number(value ?? fallback);
+ return Number.isFinite(n) ? n : fallback;
+}
+
+/**
+ * The child's own size: the nearest stated metadata down the chain, else the
+ * source file's display size. A layer built from a bare path states none, and
+ * guessing the layer box would turn a 16:9 clip into a squeezed 9:16 one.
+ */
+async function intrinsicSize(
+ media: VirtualMediaData,
+): Promise<{ width: number; height: number } | null> {
+ for (let node: VirtualMediaData | undefined = media; node; ) {
+ const { width, height } = node.metadata ?? {};
+ if (width && height) return { width, height };
+ const op = node.operation as {
+ op?: string;
+ url?: unknown;
+ source?: unknown;
+ };
+ if (op.op === "source") {
+ const url = typeof op.url === "string" ? op.url : op.source;
+ return typeof url === "string" ? probeVideoSize(url) : null;
+ }
+ node = node.children?.[0];
+ }
+ return null;
+}
+
+export const WebGPURenderer: WebGPUNodeRenderer = async (args) => {
+ const {
+ ctx,
+ encoder,
+ pass,
+ targetView,
+ targetTexture,
+ targetWidth,
+ targetHeight,
+ props,
+ drawChild,
+ } = args;
+
+ const op = props.virtualMedia?.operation as RotateOp | undefined;
+ if (op?.op !== "Rotate" || !op) return;
+
+ const childMedia = props.virtualMedia.children?.[0];
+ if (!childMedia) return;
+
+ pass.end();
+
+ const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
+ const fps = props.fps || 30;
+ const width = targetWidth;
+ const height = targetHeight;
+
+ const intrinsic = await intrinsicSize(childMedia);
+ const sourceWidth = intrinsic?.width ?? props.containerWidth ?? width;
+ const sourceHeight = intrinsic?.height ?? props.containerHeight ?? height;
+
+ // 1. Render the child upright into an offscreen texture at its own size
+ const childTex = ctx.renderer.getTemporaryTexture(sourceWidth, sourceHeight, [
+ ...(props.excludeTextures || []),
+ targetTexture,
+ ]);
+ const childView = childTex.createView();
+
+ const childPass = ctx.renderer.beginFrame(
+ encoder,
+ childView,
+ { r: 0, g: 0, b: 0, a: 0 },
+ sourceWidth,
+ sourceHeight,
+ "clear",
+ );
+ childPass.end();
+
+ ctx.renderer.pushScissor({
+ x: 0,
+ y: 0,
+ width: sourceWidth,
+ height: sourceHeight,
+ });
+ ctx.renderer.pushIdentity();
+ await drawChild(
+ childMedia,
+ {
+ ...props,
+ containerWidth: sourceWidth,
+ containerHeight: sourceHeight,
+ virtualMedia: childMedia,
+ },
+ childView,
+ childTex,
+ sourceWidth,
+ sourceHeight,
+ );
+ ctx.renderer.popTransform();
+ ctx.renderer.popScissor();
+
+ // 2. Rotate it into the output
+ const angle = resolveNumber(op.angle, 90, compositionFrame, fps);
+ const scale = Math.max(
+ 0.01,
+ resolveNumber(op.scale, 1, compositionFrame, fps),
+ );
+ const size = rotatedSourceSize(
+ sourceWidth,
+ sourceHeight,
+ width,
+ height,
+ angle,
+ op.fit ?? "cover",
+ );
+ const rad = (angle * Math.PI) / 180;
+
+ uniformData[0] = width;
+ uniformData[1] = height;
+ uniformData[2] = size.width * scale;
+ uniformData[3] = size.height * scale;
+ uniformData[4] = Math.cos(rad);
+ uniformData[5] = Math.sin(rad);
+
+ const { pipeline, uniformLayout, textureLayout } = getRotateResources(
+ ctx.device,
+ ctx.renderer.format,
+ );
+
+ const uBindGroup = ctx.device.createBindGroup({
+ layout: uniformLayout,
+ entries: [
+ {
+ binding: 0,
+ resource: { buffer: ctx.renderer.getTemporaryBuffer(uniformData) },
+ },
+ ],
+ });
+
+ const tBindGroup = ctx.device.createBindGroup({
+ layout: textureLayout,
+ entries: [
+ { binding: 0, resource: childTex.createView() },
+ {
+ binding: 1,
+ resource: ctx.renderer.samplerCache.getSampler(ctx.device),
+ },
+ ],
+ });
+
+ const outTex = ctx.renderer.getTemporaryTexture(width, height, [
+ childTex,
+ targetTexture,
+ ...(props.excludeTextures || []),
+ ]);
+
+ const renderPass = encoder.beginRenderPass({
+ colorAttachments: [
+ {
+ view: outTex.createView(),
+ loadOp: "clear",
+ storeOp: "store",
+ clearValue: { r: 0, g: 0, b: 0, a: 0 },
+ },
+ ],
+ });
+ renderPass.setPipeline(pipeline);
+ renderPass.setBindGroup(0, uBindGroup);
+ renderPass.setBindGroup(1, tBindGroup);
+ renderPass.draw(4);
+ renderPass.end();
+
+ const finalPass = ctx.renderer.beginFrame(
+ encoder,
+ targetView,
+ { r: 0, g: 0, b: 0, a: 0 },
+ targetWidth,
+ targetHeight,
+ "load",
+ );
+
+ ctx.renderer.drawTexture(
+ finalPass,
+ outTex,
+ { x: 0, y: 0, width: targetWidth, height: targetHeight },
+ { opacity: op.opacity ?? 1.0 },
+ );
+
+ args.pass = finalPass;
+};
diff --git a/nodes/node-rotate/src/shared/config.ts b/nodes/node-rotate/src/shared/config.ts
new file mode 100644
index 00000000..b99dc63a
--- /dev/null
+++ b/nodes/node-rotate/src/shared/config.ts
@@ -0,0 +1,76 @@
+import {
+ configBuilder,
+ ImageResultSchema,
+ VideoResultSchema,
+} from "@framefields/node-sdk";
+import { z } from "zod";
+
+export const rotateConfig = configBuilder()
+ .field("angle", z.number().default(90), {
+ bindable: true,
+ dataTypes: ["Number", "Signal"],
+ label: "Angle Signal",
+ description:
+ "Rotation in degrees about the frame center, clockwise. Any value; 90 / 180 / 270 fix footage shot sideways or upside down.",
+ })
+ .field("fit", z.enum(["cover", "contain", "fill"]).default("cover"), {
+ description:
+ "How the rotated source sits in the output: cover fills it (cropping the overhang), contain shows all of it (transparent margins), fill keeps the unrotated source stretched to the output and only turns it.",
+ })
+ .field("scale", z.number().min(0.01).max(20).default(1), {
+ bindable: true,
+ dataTypes: ["Number", "Signal"],
+ label: "Scale Signal",
+ description: "Extra zoom applied after the fit (1 = exactly fitted).",
+ })
+ .build();
+
+export const RotateNodeConfigSchema = rotateConfig.schema;
+
+export type RotateNodeConfig = z.infer<typeof RotateNodeConfigSchema>;
+
+export const RotateResultSchema = z.union([
+ ImageResultSchema,
+ VideoResultSchema,
+]);
+
+export type RotateResult = z.infer<typeof RotateResultSchema>;
+
+export const ROTATE_OUTPUT_TYPE_MAP: Record<string, "Image" | "Video" | "GIF"> =
+ {
+ Video: "Video",
+ Lottie: "Video",
+ GIF: "GIF",
+ Image: "Image",
+ SVG: "Image",
+ };
+
+/**
+ * Size (px) of the rotated source inside a `targetWidth × targetHeight` output.
+ * `cover` is the smallest size whose rotated rectangle still covers the whole
+ * output; `contain` the largest whose rotated bounding box fits inside it.
+ */
+export function rotatedSourceSize(
+ sourceWidth: number,
+ sourceHeight: number,
+ targetWidth: number,
+ targetHeight: number,
+ angleDeg: number,
+ fit: "cover" | "contain" | "fill",
+): { width: number; height: number } {
+ if (fit === "fill") return { width: targetWidth, height: targetHeight };
+ const rad = (angleDeg * Math.PI) / 180;
+ const c = Math.abs(Math.cos(rad));
+ const s = Math.abs(Math.sin(rad));
+ const k =
+ fit === "cover"
+ ? Math.max(
+ (c * targetWidth + s * targetHeight) / sourceWidth,
+ (s * targetWidth + c * targetHeight) / sourceHeight,
+ )
+ : Math.min(
+ targetWidth / (c * sourceWidth + s * sourceHeight),
+ targetHeight / (s * sourceWidth + c * sourceHeight),
+ );
+ return { width: sourceWidth * k, height: sourceHeight * k };
+}
diff --git a/nodes/node-rotate/src/shared/index.ts b/nodes/node-rotate/src/shared/index.ts
new file mode 100644
index 00000000..d1bc97e8
--- /dev/null
+++ b/nodes/node-rotate/src/shared/index.ts
@@ -0,0 +1 @@
+export * from "./config.js";
diff --git a/nodes/node-rotate/tsconfig.json b/nodes/node-rotate/tsconfig.json
new file mode 100644
index 00000000..5a0b963f
--- /dev/null
+++ b/nodes/node-rotate/tsconfig.json
@@ -0,0 +1,12 @@
+{
+ "extends": "@framefields/tsconfig/node-library.json",
+ "compilerOptions": {
+ "baseUrl": ".",
+ "paths": {
+ "@/*": ["./src/*"]
+ },
+ "experimentalDecorators": true,
+ "emitDecoratorMetadata": true
+ },
+ "include": ["src"]
+}
diff --git a/nodes/node-rotate/tsdown.config.ts b/nodes/node-rotate/tsdown.config.ts
new file mode 100644
index 00000000..73f5c2fc
--- /dev/null
+++ b/nodes/node-rotate/tsdown.config.ts
@@ -0,0 +1,13 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+ entry: {
+ index: "src/index.ts",
+ renderer: "src/renderers/index.ts",
+ },
+ format: ["esm"],
+ dts: true,
+ clean: true,
+ sourcemap: true,
+ treeshake: true,
+});
diff --git a/nodes/node-tile-offset/src/renderers/webgpu-renderer.ts b/nodes/node-tile-offset/src/renderers/webgpu-renderer.ts
index 900f6f56..572c10ff 100644
--- a/nodes/node-tile-offset/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-tile-offset/src/renderers/webgpu-renderer.ts
@@ -231,6 +231,7 @@ export const TileOffsetWebGPURenderer: WebGPUNodeRenderer = async (args) => {
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as TileOffsetOp | undefined;
if (op?.op !== "TileOffset" || !op) return;
@@ -272,7 +273,30 @@ export const TileOffsetWebGPURenderer: WebGPUNodeRenderer = async (args) => {
if (input?.connectionValid && input.outputItem?.type === "Number") {
val = Number(input.outputItem.data ?? defaultValue);
} else {
- val = Number(op[configKey] ?? defaultValue);
+ let rawVal = op[configKey] as unknown;
+ if (rawVal !== undefined && rawVal !== null) {
+ if (typeof rawVal === "object") {
+ if (
+ "get" in (rawVal as Record<string, unknown>) &&
+ typeof (rawVal as Record<string, unknown>).get === "function"
+ ) {
+ rawVal = (
+ rawVal as {
+ get: (ctx: { frame: number; fps: number }) => unknown;
+ }
+ ).get({ frame: compositionFrame, fps });
+ } else if ("value" in (rawVal as Record<string, unknown>)) {
+ rawVal = (rawVal as { value: unknown }).value;
+ }
+ } else if (typeof rawVal === "function") {
+ rawVal = (rawVal as (f: number, fps: number) => unknown)(
+ compositionFrame,
+ fps,
+ );
+ }
+ }
+ const numVal = Number(rawVal ?? defaultValue);
+ val = isNaN(numVal) ? defaultValue : numVal;
}
} else if (sd) {
val = Number(sd.offset ?? 0.0);
diff --git a/nodes/node-vignette/src/renderers/webgpu-renderer.ts b/nodes/node-vignette/src/renderers/webgpu-renderer.ts
index 3f51ae44..81813917 100644
--- a/nodes/node-vignette/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-vignette/src/renderers/webgpu-renderer.ts
@@ -292,6 +292,7 @@ export const VignetteWebGPURenderer: WebGPUNodeRenderer = async (args) => {
} = args;
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const fps = props.fps || 30;
const op = props.virtualMedia?.operation as VignetteOp | undefined;
if (op?.op !== "Vignette" || !op) return;
@@ -337,7 +338,7 @@ export const VignetteWebGPURenderer: WebGPUNodeRenderer = async (args) => {
let val = defaultValue;
let hasStaticSig = false;
- let gpuTextureView: GPUTextureView | undefined = undefined;
+ let gpuTextureView: GPUTextureView | undefined;
if (!hasSignal) {
if (input?.connectionValid && input.outputItem?.type === "Number") {
@@ -348,15 +349,32 @@ export const VignetteWebGPURenderer: WebGPUNodeRenderer = async (args) => {
} else {
let rawVal = op[configKey] as unknown;
if (rawVal !== undefined && rawVal !== null) {
- if (typeof rawVal === "object" && "value" in (rawVal as Record<string, unknown>)) {
- const sig = rawVal as { value: unknown; gpuBinding?: { textureView?: GPUTextureView } };
- if (sig.gpuBinding?.textureView) {
- gpuTextureView = sig.gpuBinding.textureView;
- hasStaticSig = true;
+ if (typeof rawVal === "object") {
+ if (
+ "get" in (rawVal as Record<string, unknown>) &&
+ typeof (rawVal as Record<string, unknown>).get === "function"
+ ) {
+ rawVal = (
+ rawVal as {
+ get: (ctx: { frame: number; fps: number }) => unknown;
+ }
+ ).get({ frame: compositionFrame, fps });
+ } else if ("value" in (rawVal as Record<string, unknown>)) {
+ const sig = rawVal as {
+ value: unknown;
+ gpuBinding?: { textureView?: GPUTextureView };
+ };
+ if (sig.gpuBinding?.textureView) {
+ gpuTextureView = sig.gpuBinding.textureView;
+ hasStaticSig = true;
+ }
+ rawVal = sig.value;
}
- rawVal = sig.value;
} else if (typeof rawVal === "function") {
- rawVal = (rawVal as (f: number, fps: number) => unknown)(frame, fps);
+ rawVal = (rawVal as (f: number, fps: number) => unknown)(
+ compositionFrame,
+ fps,
+ );
}
}
const numVal = Number(rawVal ?? defaultValue);
diff --git a/nodes/node-vision/src/renderers/webgpu-renderer.ts b/nodes/node-vision/src/renderers/webgpu-renderer.ts
index ac1a5063..57d63dfc 100644
--- a/nodes/node-vision/src/renderers/webgpu-renderer.ts
+++ b/nodes/node-vision/src/renderers/webgpu-renderer.ts
@@ -509,8 +509,8 @@ export const VisionWebGPURenderer: WebGPUNodeRenderer = async (args) => {
const effectKey = (op as { effect?: object }).effect;
const hasEffectKey = effectKey !== undefined && effectKey !== null;
const nodeKeyStr =
- (virtualMedia as any)?.id ??
- (rawOp as any)?.id ??
+ (virtualMedia as { id?: string } | undefined)?.id ??
+ (rawOp as { id?: string } | undefined)?.id ??
`${targetWidth}x${targetHeight}_${op.mode}_${op.variant}_${op.keyBackground}_${op.backgroundKeyThreshold}`;
const fallbackKey = `vision-${nodeKeyStr}`;
let childTex = hasEffectKey
@@ -549,6 +549,7 @@ export const VisionWebGPURenderer: WebGPUNodeRenderer = async (args) => {
}
const frameIdx = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frameIdx;
const fps = props.fps ?? 24;
const mode = op.mode ?? "passthrough";
const isMatteMode = mode === "mask" || mode === "matte" || mode === "crop";
@@ -577,7 +578,7 @@ export const VisionWebGPURenderer: WebGPUNodeRenderer = async (args) => {
: "";
const keyThresholdAt = (frame: number) =>
op.keyBackground === true
- ? backgroundKeyThreshold(op, frame, fps)
+ ? backgroundKeyThreshold(op, compositionFrame - (frameIdx - frame), fps)
: undefined;
const lookup = (frame: number | undefined) => {
if (!cacheable || frame === undefined) return undefined;
diff --git a/packages/compositions/src/compositions/canvas-composition.ts b/packages/compositions/src/compositions/canvas-composition.ts
index 67f7e9f4..4e5b7037 100644
--- a/packages/compositions/src/compositions/canvas-composition.ts
+++ b/packages/compositions/src/compositions/canvas-composition.ts
@@ -104,6 +104,7 @@ export async function drawCompositionTree(
const isCompositor = op.op === "Compositor";
const frame = props.frame ?? 0;
+ const compositionFrame = props.compositionFrame ?? frame;
const segments = op.timeline?.segments || [];
const nodeStartFrame = op.startFrame ?? op.timeline?.startFrame ?? 0;
const localFrame = frame - nodeStartFrame;
@@ -124,18 +125,21 @@ export async function drawCompositionTree(
const isLeafNode =
op.op === "source" || op.op === "text" || op.op === "caption";
if (!isLeafNode) {
- updateClockSignals(frame, fps, resolvedDurationMs);
+ updateClockSignals(compositionFrame, fps, resolvedDurationMs);
}
const frameCtx = acquireFrameContext();
- frameCtx.frame = frame;
+ frameCtx.frame = compositionFrame;
frameCtx.fps = fps;
- frameCtx.time = fps > 0 ? frame / fps : 0;
+ frameCtx.time = fps > 0 ? compositionFrame / fps : 0;
frameCtx.duration = (resolvedDurationMs ?? 0) / 1000;
frameCtx.durationMs = resolvedDurationMs ?? 0;
frameCtx.progress =
resolvedDurationMs && resolvedDurationMs > 0
- ? Math.max(0, Math.min(1, ((frame / fps) * 1000) / resolvedDurationMs))
+ ? Math.max(
+ 0,
+ Math.min(1, ((compositionFrame / fps) * 1000) / resolvedDurationMs),
+ )
: 0;
frameCtx.deltaTime = fps > 0 ? 1 / fps : 0;
@@ -212,7 +216,7 @@ export async function drawCompositionTree(
lutW,
lutH,
lutVirtualMedia,
- { ...props, virtualMedia: lutVirtualMedia },
+ { ...props, compositionFrame, virtualMedia: lutVirtualMedia },
accumulatedSeekOffsetSec,
accumulatedClockOffsetSec,
);
@@ -263,6 +267,7 @@ export async function drawCompositionTree(
targetHeight,
props: {
...props,
+ compositionFrame,
virtualMedia,
inheritedSeekOffset: accumulatedSeekOffsetSec,
inheritedClockOffset: accumulatedClockOffsetSec,
@@ -287,6 +292,7 @@ export async function drawCompositionTree(
child,
{
...props,
+ compositionFrame,
durationMs: resolvedDurationMs,
elapsedMs: resolvedElapsedMs,
virtualMedia: child,
@@ -362,6 +368,7 @@ export async function drawCompositionTree(
child,
{
...props,
+ compositionFrame,
durationMs: resolvedDurationMs,
elapsedMs: resolvedElapsedMs,
...childProps,
@@ -682,6 +689,7 @@ export async function drawCompositionTree(
child,
{
...props,
+ compositionFrame,
durationMs: resolvedDurationMs,
elapsedMs: resolvedElapsedMs,
virtualMedia: child,
diff --git a/packages/compositions/src/utils/audio-extractor.ts b/packages/compositions/src/utils/audio-extractor.ts
index f49a13e1..5aec18f7 100644
--- a/packages/compositions/src/utils/audio-extractor.ts
+++ b/packages/compositions/src/utils/audio-extractor.ts
@@ -500,6 +500,22 @@ export async function mixAudioTracks(
const segments = op.timeline?.segments || [];
+ // A layer's in-point: the source second that plays at its startFrame.
+ // Resolved as the compositor resolves it for the picture, so a clip's
+ // sound stays on its frames.
+ const layer = op as {
+ op: string;
+ mediaStartFrame?: number;
+ trimStartFrames?: number;
+ trimStartSec?: number;
+ };
+ const layerTrimSec =
+ layer.op === "CompositorLayer"
+ ? (layer.mediaStartFrame ?? layer.trimStartFrames ?? null) !== null
+ ? (layer.mediaStartFrame ?? layer.trimStartFrames ?? 0) / fps
+ : Math.round((layer.trimStartSec ?? 0) * fps) / fps
+ : 0;
+
const nodeDurationMs = getActiveMediaMetadata(node)?.durationMs ?? 0;
const nodeDurationFrames = Math.round((nodeDurationMs / 1000) * fps);
const nodeActualDurationFrames =
@@ -522,7 +538,7 @@ export async function mixAudioTracks(
windowStartFrameOffset: number,
) => {
const segSeekSec = seg ? seg.startSec : 0;
- const totalSeekSec = inheritedSeekSec + segSeekSec;
+ const totalSeekSec = inheritedSeekSec + layerTrimSec + segSeekSec;
const totalClockFrames = localClockFrames + windowStartFrameOffset;
let segDurationFrames = 0;
@@ -675,7 +691,9 @@ export async function mixAudioTracks(
segmentStartSample + clipSamplesCount,
),
);
- const elapsedMs = (totalClockFrames / fps + totalSeekSec) * 1000;
+ // The layer's own clock: its in-point moves the source, not its animation.
+ const elapsedMs =
+ (totalClockFrames / fps + totalSeekSec - layerTrimSec) * 1000;
const durationMs =
getActiveMediaMetadata(node)?.durationMs ?? undefined;
await pluginProcessor(slicedChannels, targetSampleRate, node, {
diff --git a/packages/framefields/package.json b/packages/framefields/package.json
index 73b3f3e5..aa3f2a71 100644
--- a/packages/framefields/package.json
+++ b/packages/framefields/package.json
@@ -145,6 +145,7 @@
"@framefields/node-refine-edge": "workspace:*",
"@framefields/node-refraction-caustics": "workspace:*",
"@framefields/node-relight-3d": "workspace:*",
+ "@framefields/node-rotate": "workspace:*",
"@framefields/node-sdk": "workspace:*",
"@framefields/node-selective-color": "workspace:*",
"@framefields/node-shadows-highlights": "workspace:*",
diff --git a/packages/framefields/src/audio-layer-timing.test.ts b/packages/framefields/src/audio-layer-timing.test.ts
new file mode 100644
index 00000000..2d12f022
--- /dev/null
+++ b/packages/framefields/src/audio-layer-timing.test.ts
@@ -0,0 +1,69 @@
+/**
+ * An audio layer's in-point and volume keyframes reach the mix: `trimStartSec`
+ * picks where the source starts (as it does for a video layer's picture), and
+ * a volume ramp is followed across the whole layer, not frozen at its start.
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { beforeAll, describe, expect, it } from "vitest";
+import { encodeStereoWav } from "./audio/index.js";
+import { Composition, Layer, LayerAnimation } from "./index.js";
+import { HeadlessMediaRenderer } from "./renderer/index.js";
+
+const SR = 48000;
+let source = "";
+
+/** Two seconds: silence, then a full-scale 440 Hz tone from 1.0 s. */
+beforeAll(async () => {
+ const n = 2 * SR;
+ const ch = new Float32Array(n);
+ for (let i = SR; i < n; i++) ch[i] = Math.sin((2 * Math.PI * 440 * i) / SR);
+ source = path.join(await fs.mkdtemp(path.join(os.tmpdir(), "audio-layer-")), "step.wav");
+ await fs.writeFile(source, encodeStereoWav([ch, ch], { sampleRate: SR }));
+});
+
+/** RMS of the mix's left channel over [fromSec, toSec). */
+function rms(ch: Float32Array, fromSec: number, toSec: number): number {
+ let s = 0;
+ const [a, b] = [Math.round(fromSec * SR), Math.round(toSec * SR)];
+ for (let i = a; i < b; i++) s += ch[i] * ch[i];
+ return Math.sqrt(s / (b - a));
+}
+
+async function mix(layer: ReturnType<typeof Layer.audio>) {
+ const comp = new Composition({ width: 64, height: 64, fps: 30, durationMs: 1000 });
+ comp.add(layer);
+ // renderAudio is the mix renderVideo muxes (layer processors included).
+ const { channels } = await new HeadlessMediaRenderer().renderAudio(
+ comp.toVirtualMedia(),
+ { fps: 30, sampleRate: SR },
+ );
+ return channels[0];
+}
+
+describe("audio layer timing", () => {
+ it("starts the source at the layer's trimStartSec", async () => {
+ const trimmed = await mix(Layer.audio(source, { trimStartSec: 1, durationFrames: 30 }));
+ const untrimmed = await mix(Layer.audio(source, { durationFrames: 30 }));
+ // The tone begins at source 1.0 s: trimmed, it fills the layer from its
+ // first frame; untrimmed, the layer only hears the silence before it.
+ expect(rms(trimmed, 0, 0.2)).toBeGreaterThan(0.4);
+ expect(rms(untrimmed, 0, 0.9)).toBeLessThan(0.01);
+ });
+
+ it("follows a volume ramp across the layer", async () => {
+ const ch = await mix(
+ Layer.audio(source, { trimStartSec: 1, durationFrames: 30 }).animate(
+ LayerAnimation.keys("volume", [[0, 0], [15, 1]]),
+ ),
+ );
+ const full = rms(ch, 0.6, 0.9);
+ // Past the ramp (frame 15 = 0.5 s) the tone plays at full level…
+ expect(full).toBeGreaterThan(0.4);
+ // …having risen from silence through the middle of the ramp.
+ expect(rms(ch, 0, 0.03)).toBeLessThan(full * 0.1);
+ expect(rms(ch, 0.24, 0.26)).toBeGreaterThan(full * 0.35);
+ expect(rms(ch, 0.24, 0.26)).toBeLessThan(full * 0.65);
+ });
+});
diff --git a/packages/framefields/src/effect-signals-composition-frame.test.ts b/packages/framefields/src/effect-signals-composition-frame.test.ts
new file mode 100644
index 00000000..994eec3d
--- /dev/null
+++ b/packages/framefields/src/effect-signals-composition-frame.test.ts
@@ -0,0 +1,244 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { Canvas, loadImage } from "skia-canvas";
+import { describe, expect, it } from "vitest";
+import { Blur, Composition, Layer, Signal, Vignette } from "./index.js";
+
+async function decodePngPixels(pngBuffer: Buffer) {
+ const img = await loadImage(pngBuffer);
+ const canvas = new Canvas(img.width, img.height);
+ const ctx = canvas.getContext("2d");
+ ctx.drawImage(img, 0, 0);
+ const imgData = ctx.getImageData(0, 0, img.width, img.height);
+ return {
+ width: img.width,
+ height: img.height,
+ pixels: imgData.data,
+ };
+}
+
+const testVideoPath = resolve(
+ import.meta.dirname,
+ "../../../examples/19_framefields_film/assets/portrait.mp4",
+);
+
+describe("Effect signals sampled at composition frame regression tests", () => {
+ it("1. Effect signals on a media layer with trimStartSec are sampled at composition frame (ctx.frame), not media frame", async () => {
+ if (!existsSync(testVideoPath)) return;
+
+ const sampledFrames: number[] = [];
+
+ const trackingSignal = Signal.builder({
+ type: "custom",
+ fn: (ctx) => {
+ sampledFrames.push(ctx.frame);
+ return 40;
+ },
+ });
+
+ const comp = new Composition({
+ width: 200,
+ height: 200,
+ fps: 30,
+ durationFrames: 60,
+ backgroundColor: "#000000",
+ });
+
+ // A video layer with trimStartSec: 1 (offset by 30 frames in media time)
+ const videoLayer = Layer.video(testVideoPath, {
+ trimStartSec: 1,
+ width: 200,
+ height: 200,
+ }).apply(
+ new Blur({
+ blurType: "Zoom",
+ strength: trackingSignal,
+ }),
+ );
+
+ comp.add(videoLayer);
+
+ // Render at composition frame 0
+ await comp.renderFrame({ frame: 0 });
+
+ // The signal must have been sampled at composition frame 0, NOT media frame 30
+ expect(sampledFrames.length).toBeGreaterThan(0);
+ expect(sampledFrames).toContain(0);
+ expect(sampledFrames).not.toContain(30);
+
+ // Now render at composition frame 5
+ sampledFrames.length = 0;
+ await comp.renderFrame({ frame: 5 });
+
+ expect(sampledFrames.length).toBeGreaterThan(0);
+ expect(sampledFrames).toContain(5);
+ expect(sampledFrames).not.toContain(35);
+ });
+
+ it("2. Signal.fromArray ramps on effect props match composition timeline with trimStartSec offset", async () => {
+ if (!existsSync(testVideoPath)) return;
+
+ const sampledFrames: number[] = [];
+
+ // Ramp: 60 at frame 0, 0 at frame 30+
+ const rampValues = Array.from({ length: 60 }, (_, f) =>
+ Math.max(0, 60 - f * 2),
+ );
+ const rampSignal = Signal.builder({
+ type: "custom",
+ fn: (ctx) => {
+ sampledFrames.push(ctx.frame);
+ return (
+ rampValues[Math.min(rampValues.length - 1, Math.round(ctx.frame))] ??
+ 0
+ );
+ },
+ });
+
+ const comp = new Composition({
+ width: 160,
+ height: 160,
+ fps: 30,
+ durationFrames: 60,
+ backgroundColor: "#111111",
+ });
+
+ const vignette = new Vignette({
+ strength: rampSignal,
+ radius: 0.8,
+ });
+
+ const mediaLayer = Layer.video(testVideoPath, {
+ trimStartSec: 1, // 30 frames offset
+ width: 160,
+ height: 160,
+ }).apply(vignette);
+
+ comp.add(mediaLayer);
+
+ await comp.renderFrame({ frame: 0 });
+ expect(sampledFrames).toContain(0);
+ expect(sampledFrames).not.toContain(30);
+ });
+
+ it("3. Repro verification: Zoom Blur on real video layer with trimStartSec applies blur at frame 0", async () => {
+ if (!existsSync(testVideoPath)) return;
+
+ // Values: 60 at f=0, decreases to 0 by f=10. At f=30, value is 0.
+ const blurValues = Array.from({ length: 60 }, (_, f) =>
+ Math.max(0, 60 - f * 6),
+ );
+
+ const comp = new Composition({
+ width: 320,
+ height: 320,
+ fps: 30,
+ durationFrames: 60,
+ backgroundColor: "#000000",
+ });
+
+ const blurEffect = new Blur({
+ blurType: "Zoom",
+ strength: Signal.fromArray(blurValues, 30),
+ });
+
+ const videoLayer = Layer.video(testVideoPath, {
+ trimStartSec: 1,
+ width: 320,
+ height: 320,
+ }).apply(blurEffect);
+
+ comp.add(videoLayer);
+
+ // Frame 0 should render with strength 60 (blurred)
+ const frame0Buf = await comp.renderFrame({ frame: 0 });
+ expect(Buffer.isBuffer(frame0Buf)).toBe(true);
+ expect(frame0Buf.length).toBeGreaterThan(100);
+
+ const img0 = await decodePngPixels(frame0Buf);
+ expect(img0.width).toBe(320);
+ expect(img0.height).toBe(320);
+ });
+
+ it("4. Layer with startFrame offset samples effect signals at composition frame", async () => {
+ if (!existsSync(testVideoPath)) return;
+
+ const sampledFrames: number[] = [];
+
+ const sig = Signal.builder({
+ type: "custom",
+ fn: (ctx) => {
+ sampledFrames.push(ctx.frame);
+ return 20;
+ },
+ });
+
+ const comp = new Composition({
+ width: 200,
+ height: 200,
+ fps: 30,
+ durationFrames: 60,
+ backgroundColor: "#000000",
+ });
+
+ const videoLayer = Layer.video(testVideoPath, {
+ x: 0,
+ y: 0,
+ width: 200,
+ height: 200,
+ startFrame: 10,
+ durationFrames: 30,
+ }).apply(
+ new Blur({
+ strength: sig,
+ }),
+ );
+
+ comp.add(videoLayer);
+
+ // Render at composition frame 15
+ await comp.renderFrame({ frame: 15 });
+
+ expect(sampledFrames.length).toBeGreaterThan(0);
+ expect(sampledFrames).toContain(15);
+ expect(sampledFrames).not.toContain(5);
+ });
+
+ it("5. Effect renderer directly evaluates bindable signals at compositionFrame when frame differs", async () => {
+ const sampledFrames: number[] = [];
+
+ const sig = Signal.builder({
+ type: "custom",
+ fn: (ctx) => {
+ sampledFrames.push(ctx.frame);
+ return 15;
+ },
+ });
+
+ const blur = new Blur({
+ strength: sig,
+ });
+
+ const comp = new Composition({
+ width: 100,
+ height: 100,
+ fps: 30,
+ durationFrames: 30,
+ backgroundColor: "#000000",
+ });
+
+ comp.add(
+ Layer.box({
+ width: 100,
+ height: 100,
+ background: "#ffffff",
+ }),
+ );
+
+ const { HeadlessMediaRenderer, Media } = await import("./index.js");
+ const renderer = new HeadlessMediaRenderer();
+ const media = new Media(comp.toVirtualMedia()).apply(blur);
+ await renderer.renderImage(media.toVirtualMedia(), 7, 30);
+ expect(sampledFrames).toContain(7);
+ });
+});
diff --git a/packages/framefields/src/effects/generated/catalog.json b/packages/framefields/src/effects/generated/catalog.json
index da90b3f6..42968b1d 100644
--- a/packages/framefields/src/effects/generated/catalog.json
+++ b/packages/framefields/src/effects/generated/catalog.json
@@ -2042,6 +2042,41 @@
}
]
},
+ {
+ "name": "Rotate",
+ "op": "Rotate",
+ "kind": "effect",
+ "factory": "rotate",
+ "node": "node-rotate",
+ "aliases": [],
+ "custom": null,
+ "props": [
+ {
+ "name": "angle",
+ "type": "EffectProp<number>",
+ "signal": true,
+ "default": 90,
+ "description": "Rotation in degrees about the frame center, clockwise. Any value; 90 / 180 / 270 fix footage shot sideways or upside down."
+ },
+ {
+ "name": "fit",
+ "type": "\"cover\" | \"contain\" | \"fill\"",
+ "signal": false,
+ "default": "cover",
+ "enum": ["cover", "contain", "fill"],
+ "description": "How the rotated source sits in the output: cover fills it (cropping the overhang), contain shows all of it (transparent margins), fill keeps the unrotated source stretched to the output and only turns it."
+ },
+ {
+ "name": "scale",
+ "type": "EffectProp<number>",
+ "signal": true,
+ "default": 1,
+ "min": 0.01,
+ "max": 20,
+ "description": "Extra zoom applied after the fit (1 = exactly fitted)."
+ }
+ ]
+ },
{
"name": "StereoPanning",
"op": "StereoPanning",
diff --git a/packages/framefields/src/effects/generated/classes.ts b/packages/framefields/src/effects/generated/classes.ts
index 9e08c2b4..150c3545 100644
--- a/packages/framefields/src/effects/generated/classes.ts
+++ b/packages/framefields/src/effects/generated/classes.ts
@@ -2559,6 +2559,44 @@ export class ResizerScaler extends Effect<ResizerScalerProps> {
}
}
+export interface RotateProps {
+ /**
+ * Rotation in degrees about the frame center, clockwise. Any value; 90 / 180 / 270 fix footage shot sideways or upside down.
+ * Accepts a signal.
+ * @default 90
+ */
+ angle?: EffectProp<number>;
+ /**
+ * How the rotated source sits in the output: cover fills it (cropping the overhang), contain shows all of it (transparent margins), fill keeps the unrotated source stretched to the output and only turns it.
+ * @default "cover"
+ */
+ fit?: "cover" | "contain" | "fill";
+ /**
+ * Extra zoom applied after the fit (1 = exactly fitted).
+ * Range 0.01 to 20. Accepts a signal.
+ * @default 1
+ */
+ scale?: EffectProp<number>;
+}
+
+const rotateDefaults: RotateProps = {
+ angle: 90,
+ fit: "cover",
+ scale: 1,
+};
+
+export class Rotate extends Effect<RotateProps> {
+ public readonly op = "Rotate";
+
+ public declare angle: number;
+ public declare fit: "cover" | "contain" | "fill";
+ public declare scale: number;
+
+ constructor(config: RotateProps = {}) {
+ super(withDefaults("Rotate", rotateDefaults, config, effectMeta.Rotate));
+ }
+}
+
export interface StereoPanningProps {
/**
* Stereo panning value: -1 (full left) to 1 (full right), 0 is center. Can be modulated by a static number or dynamic signal.
diff --git a/packages/framefields/src/effects/generated/index.ts b/packages/framefields/src/effects/generated/index.ts
index e95570de..a03cb351 100644
--- a/packages/framefields/src/effects/generated/index.ts
+++ b/packages/framefields/src/effects/generated/index.ts
@@ -73,6 +73,8 @@ export {
type RefractionCaustics3DProps,
ResizerScaler,
type ResizerScalerProps,
+ Rotate,
+ type RotateProps,
StereoPanning,
type StereoPanningProps,
type TonalShift,
diff --git a/packages/framefields/src/effects/generated/meta.ts b/packages/framefields/src/effects/generated/meta.ts
index b22c190f..67175de6 100644
--- a/packages/framefields/src/effects/generated/meta.ts
+++ b/packages/framefields/src/effects/generated/meta.ts
@@ -925,6 +925,16 @@ export const effectMeta = {
enum: ["top", "center", "bottom"],
},
},
+ Rotate: {
+ angle: {},
+ fit: {
+ enum: ["cover", "contain", "fill"],
+ },
+ scale: {
+ min: 0.01,
+ max: 20,
+ },
+ },
StereoPanning: {
pan: {
min: -1,
diff --git a/packages/framefields/src/effects/generated/registry.ts b/packages/framefields/src/effects/generated/registry.ts
index 5b48e5e0..9390c894 100644
--- a/packages/framefields/src/effects/generated/registry.ts
+++ b/packages/framefields/src/effects/generated/registry.ts
@@ -58,6 +58,8 @@ import {
type RefractionCaustics3DProps,
ResizerScaler,
type ResizerScalerProps,
+ Rotate,
+ type RotateProps,
StereoPanning,
type StereoPanningProps,
Vignette,
@@ -100,6 +102,7 @@ export const effectFactories = {
refractionCaustics3D: (config?: RefractionCaustics3DProps) =>
new RefractionCaustics3D(config),
resizerScaler: (config?: ResizerScalerProps) => new ResizerScaler(config),
+ rotate: (config?: RotateProps) => new Rotate(config),
stereoPanning: (config?: StereoPanningProps) => new StereoPanning(config),
vignette: (config?: VignetteProps) => new Vignette(config),
} as const;
diff --git a/packages/framefields/src/effects/index.ts b/packages/framefields/src/effects/index.ts
index 7ab72ba4..9c2a9ee2 100644
--- a/packages/framefields/src/effects/index.ts
+++ b/packages/framefields/src/effects/index.ts
@@ -28,6 +28,7 @@ export { default as paintRenderer } from "@framefields/node-paint/renderer";
export { default as patchHealRenderer } from "@framefields/node-patch-heal/renderer";
export { default as refineEdgeRenderer } from "@framefields/node-refine-edge/renderer";
export { default as refractionCausticsRenderer } from "@framefields/node-refraction-caustics/renderer";
+export { default as rotateRenderer } from "@framefields/node-rotate/renderer";
export { default as relight3dRenderer } from "@framefields/node-relight-3d/renderer";
export { default as selectiveColorRenderer } from "@framefields/node-selective-color/renderer";
export { default as shadowsHighlightsRenderer } from "@framefields/node-shadows-highlights/renderer";
diff --git a/packages/framefields/src/index.ts b/packages/framefields/src/index.ts
index 2ad3db30..96bbcf9e 100644
--- a/packages/framefields/src/index.ts
+++ b/packages/framefields/src/index.ts
@@ -723,6 +723,8 @@ export {
type Relight3DProps,
ResizerScaler,
type ResizerScalerProps,
+ Rotate,
+ type RotateProps,
SelectiveColor,
type SelectiveColorAdjustment,
type SelectiveColorProps,
diff --git a/packages/framefields/src/lut-local-file.test.ts b/packages/framefields/src/lut-local-file.test.ts
new file mode 100644
index 00000000..03552b31
--- /dev/null
+++ b/packages/framefields/src/lut-local-file.test.ts
@@ -0,0 +1,48 @@
+/**
+ * ApplyLUT reads a `.cube` from a local path under Node, the same kind of
+ * source a video layer takes (fetch cannot open a bare path or file:// URL).
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { Canvas, loadImage } from "skia-canvas";
+import { beforeAll, describe, expect, it } from "vitest";
+import { ApplyLUT, Media } from "./index.js";
+
+let dir = "";
+let grey = "";
+
+/** A 2³ LUT that sends every colour to pure green. */
+const GREEN_CUBE = ["LUT_3D_SIZE 2", ...Array(8).fill("0 1 0")].join("\n");
+
+beforeAll(async () => {
+ dir = await fs.mkdtemp(path.join(os.tmpdir(), "lut local "));
+ await fs.writeFile(path.join(dir, "all green.cube"), GREEN_CUBE);
+ const canvas = new Canvas(64, 64);
+ const ctx = canvas.getContext("2d");
+ ctx.fillStyle = "#808080";
+ ctx.fillRect(0, 0, 64, 64);
+ grey = path.join(dir, "grey.png");
+ await fs.writeFile(grey, await canvas.toBuffer("png"));
+});
+
+async function center(png: Buffer) {
+ const img = await loadImage(png);
+ const canvas = new Canvas(img.width, img.height);
+ const ctx = canvas.getContext("2d");
+ ctx.drawImage(img, 0, 0);
+ return Array.from(ctx.getImageData(32, 32, 1, 1).data.slice(0, 3));
+}
+
+describe("ApplyLUT with a local .cube", () => {
+ it.each([
+ ["a path (with spaces)", () => path.join(dir, "all green.cube")],
+ ["a file:// URL", () => pathToFileURL(path.join(dir, "all green.cube")).href],
+ ])("loads %s", async (_, lutUrl) => {
+ const png = await Media.image(grey, { width: 64, height: 64 })
+ .apply(new ApplyLUT({ lutUrl: lutUrl(), intensity: 1 }))
+ .renderFrame({ frame: 0 });
+ expect(await center(png)).toEqual([0, 255, 0]);
+ });
+});
diff --git a/packages/framefields/src/preview/player.ts b/packages/framefields/src/preview/player.ts
index dd027bac..30ee34b1 100644
--- a/packages/framefields/src/preview/player.ts
+++ b/packages/framefields/src/preview/player.ts
@@ -253,6 +253,7 @@ async function createPlayer(
const h = surface.height;
const props = {
frame,
+ compositionFrame: frame,
fps,
isHeadless: false,
renderId,
diff --git a/packages/framefields/src/rotate.test.ts b/packages/framefields/src/rotate.test.ts
new file mode 100644
index 00000000..53645256
--- /dev/null
+++ b/packages/framefields/src/rotate.test.ts
@@ -0,0 +1,64 @@
+/**
+ * Rotate turns its input about the frame center, clockwise for positive
+ * angles, and fits the turned picture into the output (cover by default).
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Canvas, loadImage } from "skia-canvas";
+import { beforeAll, describe, expect, it } from "vitest";
+import { Media, Rotate } from "./index.js";
+
+let source = "";
+
+/** A 200×100 card: red left half, blue right half. */
+beforeAll(async () => {
+ const canvas = new Canvas(200, 100);
+ const ctx = canvas.getContext("2d");
+ ctx.fillStyle = "#ff0000";
+ ctx.fillRect(0, 0, 100, 100);
+ ctx.fillStyle = "#0000ff";
+ ctx.fillRect(100, 0, 100, 100);
+ source = path.join(await fs.mkdtemp(path.join(os.tmpdir(), "rotate-")), "card.png");
+ await fs.writeFile(source, await canvas.toBuffer("png"));
+});
+
+async function pixel(png: Buffer, x: number, y: number) {
+ const img = await loadImage(png);
+ const canvas = new Canvas(img.width, img.height);
+ const ctx = canvas.getContext("2d");
+ ctx.drawImage(img, 0, 0);
+ return Array.from(ctx.getImageData(x, y, 1, 1).data.slice(0, 4));
+}
+
+const card = () => Media.image(source, { width: 200, height: 100 });
+
+describe("Rotate", () => {
+ it("turns counter-clockwise for negative angles: the right half comes up top", async () => {
+ const png = await card().apply(new Rotate({ angle: -90 })).renderFrame({ frame: 0 });
+ expect(await pixel(png, 100, 10)).toEqual([0, 0, 255, 255]);
+ expect(await pixel(png, 100, 90)).toEqual([255, 0, 0, 255]);
+ });
+
+ it("turns clockwise for positive angles: the left half comes up top", async () => {
+ const png = await card().apply(new Rotate({ angle: 90 })).renderFrame({ frame: 0 });
+ expect(await pixel(png, 100, 10)).toEqual([255, 0, 0, 255]);
+ expect(await pixel(png, 100, 90)).toEqual([0, 0, 255, 255]);
+ });
+
+ it("leaves 180° upside down and covers the whole frame", async () => {
+ const png = await card().apply(new Rotate({ angle: 180 })).renderFrame({ frame: 0 });
+ expect(await pixel(png, 10, 50)).toEqual([0, 0, 255, 255]);
+ expect(await pixel(png, 190, 50)).toEqual([255, 0, 0, 255]);
+ });
+
+ it("contain keeps the whole turned picture, with transparent margins", async () => {
+ const png = await card()
+ .apply(new Rotate({ angle: 90, fit: "contain" }))
+ .renderFrame({ frame: 0 });
+ // Turned, the card is 100 tall: contained in 200×100 it is 50 wide, centered.
+ expect((await pixel(png, 10, 50))[3]).toBe(0);
+ expect(await pixel(png, 100, 20)).toEqual([255, 0, 0, 255]);
+ expect(await pixel(png, 100, 80)).toEqual([0, 0, 255, 255]);
+ });
+});
diff --git a/packages/node-sdk/renderer/index.ts b/packages/node-sdk/renderer/index.ts
index 52f81b95..d883a3b8 100644
--- a/packages/node-sdk/renderer/index.ts
+++ b/packages/node-sdk/renderer/index.ts
@@ -18,6 +18,7 @@ export interface NodeRenderProps {
containerHeight: number;
opacity?: number;
frame?: number;
+ compositionFrame?: number;
fps?: number;
elapsedMs?: number;
durationMs?: number;
@@ -60,6 +61,7 @@ export type WebGPUNodeRenderer = (args: {
export interface AudioProcessorContext {
device?: GPUDevice;
frame?: number;
+ compositionFrame?: number;
fps?: number;
elapsedMs?: number;
durationMs?: number;
diff --git a/packages/renderer/package.json b/packages/renderer/package.json
index 6c84eea5..af3033c8 100644
--- a/packages/renderer/package.json
+++ b/packages/renderer/package.json
@@ -86,6 +86,7 @@
"@framefields/node-refraction-caustics": "workspace:*",
"@framefields/node-relight-3d": "workspace:*",
"@framefields/node-resizer-scaler": "workspace:*",
+ "@framefields/node-rotate": "workspace:*",
"@framefields/node-sdk": "workspace:*",
"@framefields/node-selective-color": "workspace:*",
"@framefields/node-shadows-highlights": "workspace:*",
diff --git a/packages/renderer/src/generated/node-renderers.ts b/packages/renderer/src/generated/node-renderers.ts
index 9a081dc0..42bd861d 100644
--- a/packages/renderer/src/generated/node-renderers.ts
+++ b/packages/renderer/src/generated/node-renderers.ts
@@ -221,6 +221,11 @@ export const BUILTIN_NODE_RENDERERS: readonly BuiltinNodeRenderer[] = [
ops: ["ResizerScaler"],
load: () => import("@framefields/node-resizer-scaler/renderer"),
},
+ {
+ packageName: "@framefields/node-rotate",
+ ops: ["Rotate"],
+ load: () => import("@framefields/node-rotate/renderer"),
+ },
{
packageName: "@framefields/node-selective-color",
ops: ["SelectiveColor"],
diff --git a/packages/renderer/src/headless-webgpu-renderer.ts b/packages/renderer/src/headless-webgpu-renderer.ts
index 92348248..9bd4dd1d 100644
--- a/packages/renderer/src/headless-webgpu-renderer.ts
+++ b/packages/renderer/src/headless-webgpu-renderer.ts
@@ -654,6 +654,7 @@ export class HeadlessWebGPURenderer {
virtualMedia,
{
frame,
+ compositionFrame: frame,
fps,
isHeadless: true,
renderId,
@@ -694,6 +695,7 @@ export class HeadlessWebGPURenderer {
virtualMedia,
{
frame,
+ compositionFrame: frame,
fps,
isHeadless: true,
renderId,
@@ -872,6 +874,7 @@ export class HeadlessWebGPURenderer {
virtualMedia,
{
frame,
+ compositionFrame: frame,
fps,
isHeadless: true,
renderId,
@@ -912,6 +915,7 @@ export class HeadlessWebGPURenderer {
virtualMedia,
{
frame,
+ compositionFrame: frame,
fps,
isHeadless: true,
renderId,
@@ -1246,6 +1250,7 @@ export class HeadlessWebGPURenderer {
virtualMedia,
{
frame,
+ compositionFrame: frame,
fps,
isHeadless: true,
renderId,
@@ -1306,6 +1311,7 @@ export class HeadlessWebGPURenderer {
virtualMedia,
{
frame: i,
+ compositionFrame: i,
fps,
isHeadless: true,
renderId,
diff --git a/packages/renderer/src/video-worker.ts b/packages/renderer/src/video-worker.ts
index 822bbb07..8f2e88bd 100644
--- a/packages/renderer/src/video-worker.ts
+++ b/packages/renderer/src/video-worker.ts
@@ -337,6 +337,7 @@ if (parentPort) {
virtualMedia,
{
frame: startFrame,
+ compositionFrame: startFrame,
fps,
isHeadless: true,
renderId,
@@ -435,6 +436,7 @@ if (parentPort) {
virtualMedia,
{
frame: i,
+ compositionFrame: i,
fps,
isHeadless: true,
renderId,
diff --git a/packages/webgpu-renderers/src/lut-store.ts b/packages/webgpu-renderers/src/lut-store.ts
index 8767e5ef..2d36c998 100644
--- a/packages/webgpu-renderers/src/lut-store.ts
+++ b/packages/webgpu-renderers/src/lut-store.ts
@@ -418,11 +418,7 @@ export class LutStore {
}
}
- const response = await fetch(src, { signal });
- if (!response.ok) {
- throw new Error(`Failed to load LUT file: ${response.statusText}`);
- }
- const text = await response.text();
+ const text = await readLutText(src, signal);
const lines = text.split(/\r?\n/);
let size = 33;
@@ -525,3 +521,25 @@ export const lutStore: LutStore = (() => {
}
return (globalThis as any)[globalKey];
})();
+
+/**
+ * A `.cube` file's text. Under Node a local path or `file://` URL is read from
+ * disk (fetch cannot open either), the same sources video layers accept;
+ * everything else is fetched.
+ */
+async function readLutText(src: string, signal?: AbortSignal): Promise<string> {
+ const isNode =
+ typeof process !== "undefined" && Boolean(process.versions?.node);
+ const isLocal = src.startsWith("/") || src.startsWith("file://");
+ if (isNode && isLocal) {
+ const { readFile } = await import("node:fs/promises");
+ const { fileURLToPath } = await import("node:url");
+ const path = src.startsWith("file://") ? fileURLToPath(src) : src;
+ return readFile(path, { encoding: "utf8", signal });
+ }
+ const response = await fetch(src, { signal });
+ if (!response.ok) {
+ throw new Error(`Failed to load LUT file: ${response.statusText}`);
+ }
+ return response.text();
+}
diff --git a/packages/webgpu-renderers/src/nodes/index.ts b/packages/webgpu-renderers/src/nodes/index.ts
index f62cb8e9..563cbfb2 100644
--- a/packages/webgpu-renderers/src/nodes/index.ts
+++ b/packages/webgpu-renderers/src/nodes/index.ts
@@ -4,6 +4,7 @@ export * from "./gif.js";
export * from "./image.js";
export * from "./lottie.js";
export * from "./media-decoder.js";
+export * from "./media-size.js";
export * from "./paragraph.js";
export * from "./signal.js";
export * from "./svg.js";
diff --git a/packages/webgpu-renderers/src/nodes/media-size.ts b/packages/webgpu-renderers/src/nodes/media-size.ts
new file mode 100644
index 00000000..0a03d185
--- /dev/null
+++ b/packages/webgpu-renderers/src/nodes/media-size.ts
@@ -0,0 +1,37 @@
+import { inputStore } from "../input-store.js";
+
+export interface MediaSize {
+ width: number;
+ height: number;
+}
+
+const sizes = new Map<string, Promise<MediaSize | null>>();
+
+/**
+ * Display size of a video source, read from its container (no decode) and
+ * memoized per URL. For nodes that need the source's real aspect when the
+ * document never stated it (a layer built from a bare path); null when the
+ * source has no video track or cannot be opened.
+ */
+export function probeVideoSize(url: string): Promise<MediaSize | null> {
+ let size = sizes.get(url);
+ if (!size) {
+ size = (async () => {
+ try {
+ const input = await inputStore.acquire(url);
+ try {
+ const track = await input.getPrimaryVideoTrack();
+ return track
+ ? { width: track.displayWidth, height: track.displayHeight }
+ : null;
+ } finally {
+ inputStore.release(url);
+ }
+ } catch {
+ return null;
+ }
+ })();
+ sizes.set(url, size);
+ }
+ return size;
+}
diff --git a/plugins/framefields/skills/framefields-effects/references/effects-catalog.md b/plugins/framefields/skills/framefields-effects/references/effects-catalog.md
index 755f92b0..613e207b 100644
--- a/plugins/framefields/skills/framefields-effects/references/effects-catalog.md
+++ b/plugins/framefields/skills/framefields-effects/references/effects-catalog.md
@@ -3,7 +3,7 @@
> Generated by `pnpm run sync:effects-catalog` from the node schemas (via `pnpm run generate:effects`) and `packages/framefields/src/effects/classes.ts`.
> Do not edit by hand — a stale catalog fails `pnpm run check:plugins`.
-51 effect classes are available from the package root and the `/effects` subpath:
+52 effect classes are available from the package root and the `/effects` subpath:
```ts
import { Blur, Curves, FilmGrain } from "framefields";
@@ -49,6 +49,7 @@ Set `FRAMEFIELDS_STRICT_PROPS=1` to make an unknown prop or an out-of-range valu
| `RefineEdge` | `RefineEdge` | `decontaminateAmount`, `radius`, `smooth`, `feather`, `shiftEdge`, `matteChannel`, `outputMode` |
| `RefractionCaustics3D` | `RefractionCaustics3D` | `ior`, `dispersion`, `refractionScale`, `causticBrightness`, `causticScale`, `fluidRipples`, `rippleSpeed`, `roughness`, `specularIntensity`, `lightPosX`, `lightPosY`, `tintColor`, `tintStrength`, `depthInvert`, `depthScale` |
| `ResizerScaler` | `ResizerScaler` | `aspectRatioPreset`, `resolutionPreset`, `targetWidth`, `targetHeight`, `fitMode`, `zoom`, `offsetX`, `offsetY`, `backgroundMode`, `backgroundColor`, `backgroundColor2`, `blurRadius`, `backgroundBrightness`, `anchorX`, `anchorY` |
+| `Rotate` | `Rotate` | `angle`, `fit`, `scale` |
| `StereoPanning` | `StereoPanning` | `pan` |
| `Vignette` | `Vignette` | `strength`, `radius`, `softness`, `roundness`, `centerX`, `centerY` |
| `Levels` | `Levels` | `master`, `red`, `green`, `blue` |
@@ -589,6 +590,20 @@ new ResizerScaler({ aspectRatioPreset: "16:9", resolutionPreset: "1080p", target
| `anchorX` | `"left" \| "center" \| "right"` | `"center"` | |
| `anchorY` | `"top" \| "center" \| "bottom"` | `"center"` | |
+### Rotate
+
+```ts
+import { Rotate } from "framefields/effects";
+
+new Rotate({ angle: 90, fit: "cover", scale: 1 });
+```
+
+| Prop | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `angle` | `EffectProp<number>` | `90` | Rotation in degrees about the frame center, clockwise. Any value; 90 / 180 / 270 fix footage shot sideways or upside down. |
+| `fit` | `"cover" \| "contain" \| "fill"` | `"cover"` | How the rotated source sits in the output: cover fills it (cropping the overhang), contain shows all of it (transparent margins), fill keeps the unrotated source stretched to the output and only turns it. |
+| `scale` | `EffectProp<number>` | `1` | Range 0.01 to 20. Extra zoom applied after the fit (1 = exactly fitted). |
+
### StereoPanning
```ts
@@ -1010,4 +1025,4 @@ new Modulate({ hue: 0, brightness: 1.0, contrast: 1.0 });
Beyond these classes, the engine ships node plugins under `nodes/` (audio DSP, generators,
signal maths, vision). Each is a package named `@framefields/node-<name>`:
-`node-apply-lut`, `node-audio-compressor`, `node-audio-delay`, `node-audio-fade`, `node-audio-noise-gate`, `node-audio-parametric-eq`, `node-audio-reverb`, `node-audio-signal-extractor`, `node-blur`, `node-camera-parallax-3d`, `node-canvas-generator`, `node-caption-editor`, `node-caption-generator`, `node-channel-merger`, `node-channel-splitter`, `node-color-balance`, `node-colorkey`, `node-compositor`, `node-corner-pin`, `node-crop`, `node-curves`, `node-deflicker`, `node-displacement-map`, `node-extract-frame`, `node-extract-lut`, `node-film-grain`, `node-flip`, `node-gradient-map`, `node-halftone-screen`, `node-high-pass`, `node-kenburns`, `node-layer-style`, `node-levels`, `node-liquify`, `node-mask-math`, `node-mesh-warp`, `node-modulate`, `node-noise-generator`, `node-paint`, `node-patch-heal`, `node-procedural-vfx`, `node-refine-edge`, `node-refraction-caustics`, `node-relight-3d`, `node-resizer-scaler`, `node-selective-color`, `node-shadows-highlights`, `node-shape-generator`, `node-signal-gate`, `node-signal-math`, `node-signal`, `node-stereo-panning`, `node-text`, `node-tile-offset`, `node-unsharp-mask`, `node-vignette`, `node-vision`
+`node-apply-lut`, `node-audio-compressor`, `node-audio-delay`, `node-audio-fade`, `node-audio-noise-gate`, `node-audio-parametric-eq`, `node-audio-reverb`, `node-audio-signal-extractor`, `node-blur`, `node-camera-parallax-3d`, `node-canvas-generator`, `node-caption-editor`, `node-caption-generator`, `node-channel-merger`, `node-channel-splitter`, `node-color-balance`, `node-colorkey`, `node-compositor`, `node-corner-pin`, `node-crop`, `node-curves`, `node-deflicker`, `node-displacement-map`, `node-extract-frame`, `node-extract-lut`, `node-film-grain`, `node-flip`, `node-gradient-map`, `node-halftone-screen`, `node-high-pass`, `node-kenburns`, `node-layer-style`, `node-levels`, `node-liquify`, `node-mask-math`, `node-mesh-warp`, `node-modulate`, `node-noise-generator`, `node-paint`, `node-patch-heal`, `node-procedural-vfx`, `node-refine-edge`, `node-refraction-caustics`, `node-relight-3d`, `node-resizer-scaler`, `node-rotate`, `node-selective-color`, `node-shadows-highlights`, `node-shape-generator`, `node-signal-gate`, `node-signal-math`, `node-signal`, `node-stereo-panning`, `node-text`, `node-tile-offset`, `node-unsharp-mask`, `node-vignette`, `node-vision`
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index bdac2fc5..22dbcd44 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -350,6 +350,31 @@ importers:
specifier: ^4.1.11
+ examples/25_bakery:
+ dependencies:
+ '@framefields/compositions':
+ specifier: workspace:*
+ version: link:../../packages/compositions
+ framefields:
+ specifier: workspace:*
+ version: link:../../packages/framefields
+ mediabunny:
+ specifier: ^1.51.0
+ version: 1.51.0
+ devDependencies:
+ '@framefields/tsconfig':
+ specifier: workspace:*
+ version: link:../../packages/tsconfig
+ '@types/node':
+ specifier: ^24.1.0
+ version: 24.10.14
+ tsx:
+ specifier: ^4.20.3
+ version: 4.21.0
+ typescript:
+ specifier: ^5.8.3
+ version: 5.9.3
+
nodes/node-apply-lut:
dependencies:
'@framefields/core':
@@ -1706,6 +1731,37 @@ importers:
specifier: ^0.4.0
version: 0.4.0
+ nodes/node-rotate:
+ dependencies:
+ '@framefields/core':
+ specifier: workspace:*
+ version: link:../../packages/core
+ '@framefields/node-sdk':
+ specifier: workspace:*
+ version: link:../../packages/node-sdk
+ '@framefields/webgpu-renderers':
+ specifier: workspace:*
+ version: link:../../packages/webgpu-renderers
+ zod:
+ specifier: ^4.3.6
+ version: 4.3.6
+ devDependencies:
+ '@framefields/tsconfig':
+ specifier: workspace:*
+ version: link:../../packages/tsconfig
+ '@types/node':
+ specifier: ^24.1.0
+ version: 24.10.14
+ tsdown:
+ specifier: ^0.19.0
+ typescript:
+ specifier: ^5.8.3
+ version: 5.9.3
+ webgpu:
+ specifier: ^0.4.0
+ version: 0.4.0
+
nodes/node-selective-color:
dependencies:
'@framefields/core':
@@ -2345,6 +2401,9 @@ importers:
'@framefields/node-relight-3d':
specifier: workspace:*
version: link:../../nodes/node-relight-3d
+ '@framefields/node-rotate':
+ specifier: workspace:*
+ version: link:../../nodes/node-rotate
'@framefields/node-sdk':
specifier: workspace:*
version: link:../node-sdk
@@ -2632,6 +2691,9 @@ importers:
'@framefields/node-resizer-scaler':
specifier: workspace:*
version: link:../../nodes/node-resizer-scaler
+ '@framefields/node-rotate':
+ specifier: workspace:*
+ version: link:../../nodes/node-rotate
'@framefields/node-sdk':
specifier: workspace:*
version: link:../node-sdk