@remotion/effects 4.0.540 → 4.0.542

package/dist/esm/preview/speckle.mjs

@@ -0,0 +1,356 @@
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval,
+  validateNonNegative
+} from "./index-wxhvgv2s.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  setupWebGpuSinglePass,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
+// src/speckle.ts
+import { Internals } from "remotion";
+
+// src/speckle-webgpu-shader.ts
+var SPECKLE_WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+
+struct Params { size: vec2f, density: f32, radius: f32, randomness: f32, }
+
+fn hash21(p: vec2f) -> f32 {
+  var p3 = fract(p.xyx * vec3f(443.8975, 397.2973, 491.1871));
+  p3 += vec3f(dot(p3, p3.yzx + vec3f(19.19)));
+  return fract((p3.x + p3.y) * p3.z);
+}
+
+fn hash22(p: vec2f) -> vec2f { return vec2f(hash21(p + vec2f(17.13)), hash21(p + vec2f(83.71))); }
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+  let color = textureSampleLevel(source, sourceSampler, input.uv, 0);
+  if (params.density <= 0.0 || params.radius <= 0.0) { return color; }
+  let fragPos = vec2f(input.uv.x, 1.0 - input.uv.y) * params.size;
+  let cellSize = max(params.radius * 2.5, 1.0);
+  let baseCell = floor(fragPos / cellSize);
+  var hole = 0.0;
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      let cell = baseCell + vec2f(f32(x), f32(y));
+      if (hash21(cell) <= params.density) {
+        let randomOffset = (hash22(cell + vec2f(11.7)) - vec2f(0.5)) * params.randomness;
+        let center = (cell + vec2f(0.5) + randomOffset) * cellSize;
+        let variation = mix(1.0, 0.35 + hash21(cell + vec2f(29.43)) * 0.65, params.randomness);
+        let radius = params.radius * 0.5 * variation;
+        let edge = min(1.0, max(radius * 0.5, 0.35));
+        hole = max(hole, 1.0 - smoothstep(radius - edge, radius + edge, length(fragPos - center)));
+      }
+    }
+  }
+  return color * (1.0 - clamp(hole, 0.0, 1.0));
+}
+
+`;
+
+// src/speckle.ts
+var { createEffect, createWebGL2ContextError } = Internals;
+var DEFAULT_DENSITY = 0.08;
+var DEFAULT_SIZE = 4;
+var DEFAULT_RANDOMNESS = 1;
+var speckleSchema = {
+  density: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_DENSITY,
+    description: "Density",
+    hiddenFromList: false
+  },
+  size: {
+    type: "number",
+    min: 0,
+    max: 50,
+    step: 0.1,
+    default: DEFAULT_SIZE,
+    description: "Size",
+    hiddenFromList: false
+  },
+  randomness: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_RANDOMNESS,
+    description: "Randomness",
+    hiddenFromList: false
+  }
+};
+var resolve = (p) => ({
+  density: p.density ?? DEFAULT_DENSITY,
+  size: p.size ?? DEFAULT_SIZE,
+  randomness: p.randomness ?? DEFAULT_RANDOMNESS
+});
+var validateSpeckleParams = (params) => {
+  assertEffectParamsObject(params, "Speckle");
+  assertOptionalFiniteNumber(params.density, "density");
+  assertOptionalFiniteNumber(params.size, "size");
+  assertOptionalFiniteNumber(params.randomness, "randomness");
+  const r = resolve(params);
+  validateUnitInterval(r.density, "density");
+  validateNonNegative(r.size, "size");
+  validateUnitInterval(r.randomness, "randomness");
+};
+var SPECKLE_VS = `#version 300 es
+in vec2 aPos;
+in vec2 aUv;
+out vec2 vUv;
+
+void main() {
+	vUv = aUv;
+	gl_Position = vec4(aPos, 0.0, 1.0);
+}
+`;
+var SPECKLE_FS = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+uniform sampler2D uSource;
+uniform vec2 uResolution;
+uniform float uDensity;
+uniform float uSize;
+uniform float uRandomness;
+
+float hash21(vec2 p) {
+	vec3 p3 = fract(vec3(p.xyx) * vec3(443.8975, 397.2973, 491.1871));
+	p3 += dot(p3, p3.yzx + 19.19);
+	return fract((p3.x + p3.y) * p3.z);
+}
+
+vec2 hash22(vec2 p) {
+	return vec2(hash21(p + 17.13), hash21(p + 83.71));
+}
+
+void main() {
+	vec4 color = texture(uSource, vUv);
+
+	if (uDensity <= 0.0 || uSize <= 0.0) {
+		fragColor = color;
+		return;
+	}
+
+	vec2 fragPos = vUv * uResolution;
+	float cellSize = max(uSize * 2.5, 1.0);
+	vec2 baseCell = floor(fragPos / cellSize);
+	float hole = 0.0;
+
+	for (int y = -1; y <= 1; y++) {
+		for (int x = -1; x <= 1; x++) {
+			vec2 cell = baseCell + vec2(float(x), float(y));
+			float chance = hash21(cell);
+
+			if (chance <= uDensity) {
+				vec2 randomOffset = (hash22(cell + 11.7) - 0.5) * uRandomness;
+				vec2 center = (cell + 0.5 + randomOffset) * cellSize;
+				float sizeVariation = mix(1.0, 0.35 + hash21(cell + 29.43) * 0.65, uRandomness);
+				float radius = uSize * 0.5 * sizeVariation;
+				float edge = min(1.0, max(radius * 0.5, 0.35));
+				float coverage = 1.0 - smoothstep(radius - edge, radius + edge, length(fragPos - center));
+				hole = max(hole, coverage);
+			}
+		}
+	}
+
+	fragColor = color * (1.0 - clamp(hole, 0.0, 1.0));
+}
+`;
+var compileShader = (gl, type, source) => {
+  const shader = gl.createShader(type);
+  if (!shader) {
+    throw new Error("Failed to create WebGL shader");
+  }
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    throw new Error(`Speckle shader compile failed: ${log ?? "(no log)"}`);
+  }
+  return shader;
+};
+var linkProgram = (gl, vs, fs) => {
+  const program = gl.createProgram();
+  if (!program) {
+    throw new Error("Failed to create WebGL program");
+  }
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`Speckle program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var speckle = createEffect({
+  type: "dev.remotion.effects.speckle",
+  label: "speckle()",
+  documentationLink: "https://www.remotion.dev/docs/effects/speckle",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `speckle-${r.density}-${r.size}-${r.randomness}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuSinglePass(target, "speckle"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice)
+          throw new Error("A WebGPU device is required for the speckle effect");
+        const r = resolve(params);
+        const uniformData = new Float32Array([
+          width,
+          height,
+          r.density,
+          r.size,
+          r.randomness,
+          0,
+          0,
+          0
+        ]);
+        applyWebGpuSinglePass({
+          state,
+          source,
+          width,
+          height,
+          device: gpuDevice,
+          shader: SPECKLE_WEBGPU_SHADER,
+          uniformData
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => {
+        const gl = target.getContext("webgl2", {
+          premultipliedAlpha: true,
+          alpha: true,
+          preserveDrawingBuffer: true
+        });
+        if (!gl) {
+          throw createWebGL2ContextError("speckle effect");
+        }
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        const vs = compileShader(gl, gl.VERTEX_SHADER, SPECKLE_VS);
+        const fs = compileShader(gl, gl.FRAGMENT_SHADER, SPECKLE_FS);
+        const program = linkProgram(gl, vs, fs);
+        gl.deleteShader(vs);
+        gl.deleteShader(fs);
+        const vao = gl.createVertexArray();
+        if (!vao) {
+          throw new Error("Failed to create WebGL vertex array");
+        }
+        gl.bindVertexArray(vao);
+        const data = new Float32Array([
+          -1,
+          -1,
+          0,
+          0,
+          1,
+          -1,
+          1,
+          0,
+          -1,
+          1,
+          0,
+          1,
+          1,
+          1,
+          1,
+          1
+        ]);
+        const vbo = gl.createBuffer();
+        if (!vbo) {
+          throw new Error("Failed to create WebGL buffer");
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+        const aPos = gl.getAttribLocation(program, "aPos");
+        const aUv = gl.getAttribLocation(program, "aUv");
+        gl.enableVertexAttribArray(aPos);
+        gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+        gl.enableVertexAttribArray(aUv);
+        gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+        gl.bindVertexArray(null);
+        const texture = gl.createTexture();
+        if (!texture) {
+          throw new Error("Failed to create WebGL texture");
+        }
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        return {
+          gl,
+          program,
+          vao,
+          vbo,
+          texture,
+          uSource: gl.getUniformLocation(program, "uSource"),
+          uResolution: gl.getUniformLocation(program, "uResolution"),
+          uDensity: gl.getUniformLocation(program, "uDensity"),
+          uSize: gl.getUniformLocation(program, "uSize"),
+          uRandomness: gl.getUniformLocation(program, "uRandomness")
+        };
+      },
+      apply: ({ source, width, height, params, state, flipSourceY }) => {
+        const r = resolve(params);
+        const { gl, program, vao, texture } = state;
+        gl.viewport(0, 0, width, height);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.clearColor(0, 0, 0, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipSourceY);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+        if (state.uSource)
+          gl.uniform1i(state.uSource, 0);
+        if (state.uResolution)
+          gl.uniform2f(state.uResolution, width, height);
+        if (state.uDensity)
+          gl.uniform1f(state.uDensity, r.density);
+        if (state.uSize)
+          gl.uniform1f(state.uSize, r.size);
+        if (state.uRandomness)
+          gl.uniform1f(state.uRandomness, r.randomness);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        gl.bindVertexArray(null);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.useProgram(null);
+      },
+      cleanup: ({ gl, program, vao, vbo, texture }) => {
+        gl.deleteBuffer(vbo);
+        gl.deleteProgram(program);
+        gl.deleteVertexArray(vao);
+        gl.deleteTexture(texture);
+      }
+    })
+  },
+  schema: speckleSchema,
+  validateParams: validateSpeckleParams
+});
+export {
+  speckle
+};

package/dist/esm/preview/sphere.mjs

@@ -0,0 +1,252 @@
+import {
+  setupWebGlProjection,
+  applyWebGlProjection,
+  cleanupWebGlProjection,
+  cleanupWebGpuProjection,
+  setupWebGpuProjection,
+  applyWebGpuProjection
+} from "./index-vp56k1gj.mjs";
+import {
+  assertOptionalFiniteNumber,
+  validateUnitInterval
+} from "./index-wxhvgv2s.mjs";
+import {
+  assertEffectParamsObject
+} from "./index-4fvp93ps.mjs";
+
+// src/sphere/index.ts
+import { Internals } from "remotion";
+
+// src/sphere/shader.ts
+var SPHERE_SHADER = `
+struct Params {
+  resolution: vec2f,
+  center: vec2f,
+  radius: f32,
+  padding: f32,
+  shading: f32,
+  faces: f32,
+  rotation: vec4f,
+}
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@vertex fn vertex(@builtin(vertex_index) index: u32) -> @builtin(position) vec4f {
+  let positions = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));
+  return vec4f(positions[index], 0, 1);
+}
+
+fn sampleFace(normal: vec3f, inverse: mat3x3f) -> vec4f {
+  let local = inverse * normal;
+  // Longitude wraps at the seam; latitude spans the complete image height.
+  let uv = vec2f(fract(atan2(local.x, local.z) / 6.28318530718 + 0.5), asin(clamp(local.y, -1.0, 1.0)) / 3.14159265359 + 0.5);
+  let color = textureSampleLevel(source, sourceSampler, uv, 0);
+  let shade = mix(1.0, abs(normal.z), params.shading);
+  return vec4f(color.rgb * shade, color.a);
+}
+
+@fragment fn fragment(@builtin(position) position: vec4f) -> @location(0) vec4f {
+  let p = (position.xy - params.center) / params.radius;
+  let distanceSquared = dot(p, p);
+  let coverage = 1.0 - smoothstep(1.0 - fwidth(distanceSquared), 1.0, distanceSquared);
+  if (distanceSquared >= 1.0) { return vec4f(0); }
+  let z = sqrt(1.0 - distanceSquared);
+  let s = sin(params.rotation.xyz);
+  let c = cos(params.rotation.xyz);
+  let rx = mat3x3f(vec3f(1, 0, 0), vec3f(0, c.x, s.x), vec3f(0, -s.x, c.x));
+  let ry = mat3x3f(vec3f(c.y, 0, -s.y), vec3f(0, 1, 0), vec3f(s.y, 0, c.y));
+  let rz = mat3x3f(vec3f(c.z, s.z, 0), vec3f(-s.z, c.z, 0), vec3f(0, 0, 1));
+  let inverse = transpose(rz * ry * rx);
+  let front = sampleFace(vec3f(p, z), inverse);
+  let back = sampleFace(vec3f(p, -z), inverse);
+  if (params.faces == 1) { return front * coverage; }
+  if (params.faces == 2) { return back * coverage; }
+  return (front + back * (1.0 - front.a)) * coverage;
+}
+`;
+
+// src/sphere/webgl-shader.ts
+var SPHERE_WEBGL_SHADER = `#version 300 es
+precision highp float;
+uniform sampler2D uSource;
+uniform vec4 uParams[3];
+out vec4 fragColor;
+vec4 sampleFace(vec3 normal, mat3 inverseRotation) {
+  vec3 local = inverseRotation * normal;
+  // Longitude wraps at the seam; latitude spans the complete image height.
+  vec2 uv = vec2(fract(atan(local.x, local.z) / 6.28318530718 + 0.5), asin(clamp(local.y, -1.0, 1.0)) / 3.14159265359 + 0.5);
+  vec4 color = textureLod(uSource, vec2(uv.x, 1.0 - uv.y), 0.0);
+  float shade = mix(1.0, abs(normal.z), uParams[1].z);
+  return vec4(color.rgb * shade, color.a);
+}
+
+vec4 project(vec2 position) {
+  vec2 p = (position - uParams[0].zw) / uParams[1].x;
+  float distanceSquared = dot(p, p);
+  float coverage = 1.0 - smoothstep(1.0 - fwidth(distanceSquared), 1.0, distanceSquared);
+  if (distanceSquared >= 1.0) { return vec4(0); }
+  float z = sqrt(1.0 - distanceSquared);
+  vec3 s = sin(uParams[2].xyz);
+  vec3 c = cos(uParams[2].xyz);
+  mat3 rx = mat3(vec3(1, 0, 0), vec3(0, c.x, s.x), vec3(0, -s.x, c.x));
+  mat3 ry = mat3(vec3(c.y, 0, -s.y), vec3(0, 1, 0), vec3(s.y, 0, c.y));
+  mat3 rz = mat3(vec3(c.z, s.z, 0), vec3(-s.z, c.z, 0), vec3(0, 0, 1));
+  mat3 inverseRotation = transpose(rz * ry * rx);
+  vec4 front = sampleFace(vec3(p, z), inverseRotation);
+  vec4 back = sampleFace(vec3(p, -z), inverseRotation);
+  if (uParams[1].w == 1.0) { return front * coverage; }
+  if (uParams[1].w == 2.0) { return back * coverage; }
+  return (front + back * (1.0 - front.a)) * coverage;
+}
+
+void main() { fragColor = project(vec2(gl_FragCoord.x, uParams[0].y - gl_FragCoord.y)); }
+`;
+
+// src/sphere/index.ts
+var DEFAULT_RADIUS = 250;
+var DEFAULT_ROTATION = 0;
+var DEFAULT_POSITION = [0.5, 0.5];
+var DEFAULT_RENDER = "both";
+var DEFAULT_SHADING = 0.35;
+var sphereSchema = {
+  radius: {
+    type: "number",
+    min: 1,
+    max: 1000,
+    step: 1,
+    default: DEFAULT_RADIUS,
+    description: "Radius",
+    hiddenFromList: false
+  },
+  rotationX: {
+    type: "rotation-degrees",
+    default: DEFAULT_ROTATION,
+    description: "X rotation"
+  },
+  rotationY: {
+    type: "rotation-degrees",
+    default: DEFAULT_ROTATION,
+    description: "Y rotation"
+  },
+  rotationZ: {
+    type: "rotation-degrees",
+    default: DEFAULT_ROTATION,
+    description: "Z rotation"
+  },
+  position: {
+    type: "uv-coordinate",
+    default: DEFAULT_POSITION,
+    description: "Position"
+  },
+  render: {
+    type: "enum",
+    variants: { both: {}, front: {}, back: {} },
+    default: DEFAULT_RENDER,
+    description: "Faces"
+  },
+  shading: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_SHADING,
+    description: "Shading",
+    hiddenFromList: false
+  }
+};
+var resolve = (params) => ({
+  radius: params.radius ?? DEFAULT_RADIUS,
+  rotationX: params.rotationX ?? DEFAULT_ROTATION,
+  rotationY: params.rotationY ?? DEFAULT_ROTATION,
+  rotationZ: params.rotationZ ?? DEFAULT_ROTATION,
+  position: params.position ?? DEFAULT_POSITION,
+  render: params.render ?? DEFAULT_RENDER,
+  shading: params.shading ?? DEFAULT_SHADING
+});
+var getUniformData = (params, width, height) => {
+  const r = resolve(params);
+  const radians = Math.PI / 180;
+  return new Float32Array([
+    width,
+    height,
+    r.position[0] * width,
+    r.position[1] * height,
+    r.radius,
+    0,
+    r.shading,
+    r.render === "front" ? 1 : r.render === "back" ? 2 : 0,
+    r.rotationX % 360 * radians,
+    r.rotationY % 360 * radians,
+    r.rotationZ % 360 * radians,
+    0
+  ]);
+};
+var sphere = Internals.createEffect({
+  type: "remotion/sphere",
+  label: "sphere()",
+  documentationLink: "https://www.remotion.dev/docs/effects/sphere",
+  schema: sphereSchema,
+  validateParams: (params) => {
+    assertEffectParamsObject(params, "Sphere");
+    for (const key of [
+      "radius",
+      "rotationX",
+      "rotationY",
+      "rotationZ",
+      "shading"
+    ]) {
+      assertOptionalFiniteNumber(params[key], key);
+    }
+    const r = resolve(params);
+    if (r.radius <= 0) {
+      throw new TypeError('"radius" must be greater than 0');
+    }
+    validateUnitInterval(r.shading, "shading");
+    if (params.position !== undefined && (!Array.isArray(params.position) || params.position.length !== 2 || !Number.isFinite(params.position[0]) || !Number.isFinite(params.position[1]))) {
+      throw new TypeError('"position" must contain two finite numbers');
+    }
+    if (params.render !== undefined && params.render !== "both" && params.render !== "front" && params.render !== "back") {
+      throw new TypeError('"render" must be "both", "front", or "back"');
+    }
+  },
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `sphere-${r.radius}-${r.rotationX}-${r.rotationY}-${r.rotationZ}-${r.position.join(",")}-${r.render}-${r.shading}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuProjection(target, "sphere"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice) {
+          throw new Error("A WebGPU device is required for the sphere effect");
+        }
+        applyWebGpuProjection({
+          source,
+          width,
+          height,
+          state,
+          device: gpuDevice,
+          shader: SPHERE_SHADER,
+          uniformData: getUniformData(params, width, height)
+        });
+      },
+      cleanup: cleanupWebGpuProjection
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => setupWebGlProjection(target, SPHERE_WEBGL_SHADER),
+      apply: ({ source, width, height, params, state, flipSourceY }) => applyWebGlProjection({
+        source,
+        width,
+        height,
+        state,
+        flipSourceY,
+        uniformData: getUniformData(params, width, height)
+      }),
+      cleanup: cleanupWebGlProjection
+    })
+  }
+});
+export {
+  sphere
+};

package/dist/esm/preview/starburst.mjs

@@ -0,0 +1,8 @@
+import {
+  starburstEffectSchema2,
+  starburst2
+} from "./index-18y0zcy2.mjs";
+export {
+  starburst2 as starburst,
+  starburstEffectSchema2 as starburstEffectSchema
+};