@remotion/effects 4.0.538 → 4.0.540

package/dist/esm/index-18y0zcy2.mjs

@@ -0,0 +1,440 @@
+import {
+  setupWebGpuColors
+} from "./index-8jx11jyn.mjs";
+import {
+  WEBGPU_SINGLE_PASS_VERTEX,
+  cleanupWebGpuSinglePass,
+  applyWebGpuSinglePass
+} from "./index-tvfexb7s.mjs";
+
+// src/starburst.ts
+import { Internals } from "remotion";
+import { NoReactInternals } from "remotion/no-react";
+
+// src/starburst-webgpu-shader.ts
+var STARBURST_WEBGPU_SHADER = `
+${WEBGPU_SINGLE_PASS_VERTEX}
+@group(0) @binding(0) var sourceTexture: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(0) @binding(2) var<uniform> params: Params;
+@group(0) @binding(3) var palette: texture_2d<f32>;
+struct Params {
+ geometry: vec4f,
+ values: vec4f,
+}
+fn sampleSource(uv: vec2f) -> vec4f {
+ return textureSampleLevel(sourceTexture, sourceSampler, vec2f(uv.x, 1.0 - uv.y), 0);
+}
+fn glslModulo(value: f32, divisor: f32) -> f32 { return value - divisor * floor(value / divisor); }
+fn paletteColor(index: f32) -> vec4f { return textureLoad(palette, vec2i(i32(index), 0), 0); }
+
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+ let vUv = vec2f(input.uv.x, 1.0 - input.uv.y);
+
+ var center = vec2f(input.position.x, params.geometry.y - input.position.y) / params.geometry.xy - params.values.zw;
+ center.x *= params.geometry.x / params.geometry.y;
+ let angle = atan2(center.y, center.x) + params.values.x;
+ let normalizedAngle = (angle + 3.14159265359) / (2.0 * 3.14159265359);
+ let sector = normalizedAngle * params.geometry.z;
+ let rayIndex = glslModulo(floor(sector), params.geometry.z);
+ let colorIndex = glslModulo(rayIndex, params.geometry.w);
+ var col = paletteColor(colorIndex).rgb;
+ let fractSector = fract(sector);
+ let edgeSmooth = params.values.y * 0.5;
+ let nextColorIndex = glslModulo(rayIndex + 1.0, params.geometry.w);
+ let nextCol = paletteColor(nextColorIndex).rgb;
+ let blend = smoothstep(1.0 - edgeSmooth, 1.0, fractSector);
+ col = mix(col, nextCol, blend);
+ let blendStart = smoothstep(edgeSmooth, 0.0, fractSector);
+ let prevColorIndex = glslModulo(rayIndex - 1.0 + params.geometry.w, params.geometry.w);
+ let prevCol = paletteColor(prevColorIndex).rgb;
+ col = mix(col, prevCol, blendStart);
+ return vec4f(col, 1.0);
+
+}
+`;
+
+// src/starburst.ts
+var { createEffect, createWebGL2ContextError } = Internals;
+var colorToRgb = (color) => {
+  const packed = NoReactInternals.processColor(color);
+  return [packed >>> 16 & 255, packed >>> 8 & 255, packed & 255];
+};
+var DEFAULT_ORIGIN = [0.5, 0.5];
+var starburstEffectSchema2 = {
+  rays: {
+    type: "number",
+    min: 2,
+    max: 100,
+    step: 1,
+    default: undefined,
+    description: "Number of Rays",
+    hiddenFromList: false
+  },
+  colors: {
+    type: "array",
+    item: {
+      type: "color"
+    },
+    default: undefined,
+    minLength: 2,
+    newItemDefault: "#ff0000",
+    description: "Colors",
+    keyframable: false
+  },
+  rotation: {
+    type: "number",
+    min: 0,
+    max: 360,
+    step: 1,
+    default: 0,
+    description: "Rotation",
+    hiddenFromList: false
+  },
+  smoothness: {
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: 0,
+    description: "Edge Smoothness",
+    hiddenFromList: false
+  },
+  origin: {
+    type: "uv-coordinate",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    default: DEFAULT_ORIGIN,
+    description: "Origin"
+  }
+};
+var resolve = (p) => ({
+  rays: p.rays,
+  colors: p.colors,
+  rotation: p.rotation ?? 0,
+  smoothness: p.smoothness ?? 0,
+  origin: p.origin ?? DEFAULT_ORIGIN
+});
+var validateStarburstEffectParams = (params) => {
+  if (params === null || typeof params !== "object") {
+    throw new TypeError(`Starburst effect requires a parameters object, but got ${JSON.stringify(params)}`);
+  }
+  const { rays, colors } = params;
+  if (typeof rays !== "number" || !Number.isFinite(rays)) {
+    throw new TypeError(`"rays" must be a finite number, but got ${JSON.stringify(rays)}`);
+  }
+  if (rays < 2 || rays > 100) {
+    throw new RangeError(`"rays" must be between 2 and 100, but got ${rays}`);
+  }
+  if (!Array.isArray(colors) || colors.length < 2) {
+    throw new TypeError(`"colors" must be an array with at least 2 colors, but got ${JSON.stringify(colors)}`);
+  }
+  const r = resolve(params);
+  if (typeof r.rotation !== "number" || !Number.isFinite(r.rotation)) {
+    throw new TypeError(`"rotation" must be a finite number, but got ${JSON.stringify(params.rotation)}`);
+  }
+  if (typeof r.smoothness !== "number" || !Number.isFinite(r.smoothness)) {
+    throw new TypeError(`"smoothness" must be a finite number, but got ${JSON.stringify(params.smoothness)}`);
+  }
+  if (r.smoothness < 0 || r.smoothness > 1) {
+    throw new RangeError(`"smoothness" must be between 0 and 1, but got ${r.smoothness}`);
+  }
+  if (!Array.isArray(r.origin) || r.origin.length !== 2 || r.origin.some((coordinate) => {
+    return typeof coordinate !== "number" || !Number.isFinite(coordinate);
+  })) {
+    throw new TypeError('"origin" must be a [number, number] tuple');
+  }
+  if (r.origin.some((coordinate) => coordinate < 0 || coordinate > 1)) {
+    throw new RangeError(`"origin" must contain coordinates between 0 and 1, but got ${JSON.stringify(r.origin)}`);
+  }
+  for (const c of r.colors) {
+    colorToRgb(c);
+  }
+};
+var STARBURST_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 STARBURST_FS = `#version 300 es
+precision highp float;
+
+uniform sampler2D colorPalette;
+uniform float numRays;
+uniform float rotationOffset;
+uniform float smoothEdge;
+uniform vec2 resolution;
+uniform float numColors;
+uniform vec2 origin;
+
+in vec2 vUv;
+out vec4 fragColor;
+
+const float Pi = 3.14159265359;
+
+void main() {
+	vec2 uv = gl_FragCoord.xy / resolution;
+	vec2 center = uv - origin;
+	center.x *= resolution.x / resolution.y;
+
+	float angle = atan(center.y, center.x) + rotationOffset;
+	float normalizedAngle = (angle + Pi) / (2.0 * Pi);
+	float sector = normalizedAngle * numRays;
+	float rayIndex = mod(floor(sector), numRays);
+
+	float colorIndex = mod(rayIndex, numColors);
+	float texCoord = (colorIndex + 0.5) / numColors;
+	vec3 col = texture(colorPalette, vec2(texCoord, 0.5)).rgb;
+
+	float fractSector = fract(sector);
+	float edgeSmooth = smoothEdge * 0.5;
+	float nextColorIndex = mod(rayIndex + 1.0, numColors);
+	float nextTexCoord = (nextColorIndex + 0.5) / numColors;
+	vec3 nextCol = texture(colorPalette, vec2(nextTexCoord, 0.5)).rgb;
+
+	float blend = smoothstep(1.0 - edgeSmooth, 1.0, fractSector);
+	col = mix(col, nextCol, blend);
+	float blendStart = smoothstep(edgeSmooth, 0.0, fractSector);
+	float prevColorIndex = mod(rayIndex - 1.0 + numColors, numColors);
+	float prevTexCoord = (prevColorIndex + 0.5) / numColors;
+	vec3 prevCol = texture(colorPalette, vec2(prevTexCoord, 0.5)).rgb;
+	col = mix(col, prevCol, blendStart);
+
+	fragColor = vec4(col, 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(`Starburst 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(`Starburst program link failed: ${log ?? "(no log)"}`);
+  }
+  return program;
+};
+var starburst2 = createEffect({
+  type: "remotion/starburst",
+  label: "starburst()",
+  documentationLink: "https://www.remotion.dev/docs/effects/starburst",
+  calculateKey: (params) => {
+    const r = resolve(params);
+    return `starburst-${r.rays}-${r.colors.join("|")}-${r.rotation}-${r.smoothness}-${r.origin.join(":")}`;
+  },
+  implementations: {
+    webgpu: Internals.createEffectImplementation({
+      setup: (target) => setupWebGpuColors(target, "starburst"),
+      apply: ({ source, width, height, params, state, gpuDevice }) => {
+        if (!gpuDevice)
+          throw new Error("A WebGPU device is required for the starburst effect");
+        const r = resolve(params);
+        const colors = new Uint8Array(r.colors.flatMap((color) => [...colorToRgb(color), 255]));
+        const uniformData = new Float32Array([
+          width,
+          height,
+          r.rays,
+          r.colors.length,
+          r.rotation * Math.PI / 180,
+          r.smoothness,
+          r.origin[0],
+          1 - r.origin[1]
+        ]);
+        applyWebGpuSinglePass({
+          state,
+          source,
+          width,
+          height,
+          device: gpuDevice,
+          shader: STARBURST_WEBGPU_SHADER,
+          uniformData
+        }, {
+          sourceFilter: null,
+          auxiliaryTexture: {
+            data: colors,
+            width: r.colors.length,
+            height: 1,
+            format: "rgba8unorm"
+          }
+        });
+      },
+      cleanup: cleanupWebGpuSinglePass
+    }),
+    webgl2: Internals.createEffectImplementation({
+      setup: (target) => {
+        const gl = target.getContext("webgl2", {
+          premultipliedAlpha: true,
+          alpha: true,
+          preserveDrawingBuffer: true
+        });
+        if (!gl) {
+          throw createWebGL2ContextError("starburst effect");
+        }
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        const vs = compileShader(gl, gl.VERTEX_SHADER, STARBURST_VS);
+        const fs = compileShader(gl, gl.FRAGMENT_SHADER, STARBURST_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 paletteTexture = gl.createTexture();
+        if (!paletteTexture) {
+          throw new Error("Failed to create WebGL palette texture");
+        }
+        gl.bindTexture(gl.TEXTURE_2D, paletteTexture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+        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.bindTexture(gl.TEXTURE_2D, null);
+        return {
+          gl,
+          program,
+          vao,
+          vbo,
+          paletteTexture,
+          uColorPalette: gl.getUniformLocation(program, "colorPalette"),
+          uNumRays: gl.getUniformLocation(program, "numRays"),
+          uRotationOffset: gl.getUniformLocation(program, "rotationOffset"),
+          uSmoothEdge: gl.getUniformLocation(program, "smoothEdge"),
+          uResolution: gl.getUniformLocation(program, "resolution"),
+          uNumColors: gl.getUniformLocation(program, "numColors"),
+          uOrigin: gl.getUniformLocation(program, "origin"),
+          cachedPaletteKey: "",
+          palettePixelData: new Uint8Array(0)
+        };
+      },
+      apply: ({ width, height, params, state }) => {
+        const r = resolve(params);
+        const {
+          gl,
+          program,
+          vao,
+          paletteTexture,
+          uColorPalette,
+          uNumRays,
+          uRotationOffset,
+          uSmoothEdge,
+          uResolution,
+          uNumColors,
+          uOrigin
+        } = state;
+        const rotationRad = r.rotation * Math.PI / 180;
+        const paletteKey = r.colors.join("|");
+        const paletteDirty = state.cachedPaletteKey !== paletteKey;
+        if (paletteDirty) {
+          state.cachedPaletteKey = paletteKey;
+          const len = r.colors.length * 4;
+          if (state.palettePixelData.length !== len) {
+            state.palettePixelData = new Uint8Array(len);
+          }
+          const { palettePixelData } = state;
+          for (let i = 0;i < r.colors.length; i++) {
+            const rgb = colorToRgb(r.colors[i]);
+            palettePixelData[i * 4] = rgb[0];
+            palettePixelData[i * 4 + 1] = rgb[1];
+            palettePixelData[i * 4 + 2] = rgb[2];
+            palettePixelData[i * 4 + 3] = 255;
+          }
+        }
+        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, paletteTexture);
+        if (paletteDirty) {
+          gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, r.colors.length, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, state.palettePixelData);
+        }
+        if (uColorPalette)
+          gl.uniform1i(uColorPalette, 0);
+        if (uNumRays)
+          gl.uniform1f(uNumRays, r.rays);
+        if (uNumColors)
+          gl.uniform1f(uNumColors, r.colors.length);
+        if (uRotationOffset)
+          gl.uniform1f(uRotationOffset, rotationRad);
+        if (uSmoothEdge)
+          gl.uniform1f(uSmoothEdge, r.smoothness);
+        if (uOrigin)
+          gl.uniform2f(uOrigin, r.origin[0], 1 - r.origin[1]);
+        if (uResolution)
+          gl.uniform2f(uResolution, width, height);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        gl.bindVertexArray(null);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.useProgram(null);
+      },
+      cleanup: ({ gl, program, vao, vbo, paletteTexture }) => {
+        gl.deleteBuffer(vbo);
+        gl.deleteProgram(program);
+        gl.deleteVertexArray(vao);
+        gl.deleteTexture(paletteTexture);
+      }
+    })
+  },
+  schema: starburstEffectSchema2,
+  validateParams: validateStarburstEffectParams
+});
+
+export { starburstEffectSchema2, starburst2 };