@remotion/effects 4.0.541 → 4.0.543

package/dist/esm/preview/index-4scpn12x.mjs

@@ -0,0 +1,224 @@
+import {
+  WEBGPU_SINGLE_PASS_VERTEX
+} from "./index-tvfexb7s.mjs";
+
+// src/webgpu-mesh-runtime.ts
+var setupWebGpuMesh = (target, label) => {
+  const context = target.getContext("webgpu");
+  if (!context)
+    throw new Error(`WebGPU is not available for the ${label} effect`);
+  return { context, label, resources: null };
+};
+var cleanupWebGpuMesh = (state) => {
+  state.resources?.uniforms.destroy();
+  state.resources?.multisample?.texture.destroy();
+  state.resources?.multisample?.resolved.destroy();
+  state.resources?.vertices?.buffer.destroy();
+  state.resources?.source?.texture.destroy();
+  state.resources = null;
+  state.context.unconfigure();
+};
+var applyWebGpuMesh = ({
+  state,
+  source,
+  width,
+  height,
+  vertices,
+  device,
+  shader,
+  uniformData,
+  topology,
+  blend,
+  vertexCount,
+  instanceCount
+}) => {
+  const uniformSize = Math.max(16, Math.ceil(uniformData.byteLength / 16) * 16);
+  if (state.resources && (state.resources.device !== device || state.resources.shader !== shader || state.resources.uniformSize !== uniformSize || state.resources.topology !== topology || state.resources.blend !== blend))
+    cleanupWebGpuMesh(state);
+  if (!state.resources) {
+    const format = navigator.gpu.getPreferredCanvasFormat();
+    state.context.configure({ device, format, alphaMode: "premultiplied" });
+    const module = device.createShaderModule({
+      code: shader,
+      label: state.label
+    });
+    const blendComponent = {
+      srcFactor: "one",
+      dstFactor: "one-minus-src-alpha",
+      operation: "add"
+    };
+    const pipeline = device.createRenderPipeline({
+      label: state.label,
+      layout: device.createPipelineLayout({
+        bindGroupLayouts: [
+          device.createBindGroupLayout({
+            entries: [
+              { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: {} },
+              { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} },
+              {
+                binding: 2,
+                visibility: GPUShaderStage.VERTEX,
+                buffer: { type: "uniform" }
+              },
+              {
+                binding: 3,
+                visibility: GPUShaderStage.VERTEX,
+                buffer: { type: "read-only-storage" }
+              }
+            ]
+          })
+        ]
+      }),
+      vertex: { module, entryPoint: "vertex" },
+      fragment: {
+        module,
+        entryPoint: "fragment",
+        targets: [
+          {
+            format,
+            ...blend ? { blend: { color: blendComponent, alpha: blendComponent } } : {}
+          }
+        ]
+      },
+      primitive: { topology },
+      multisample: { count: 4 }
+    });
+    const flipModule = device.createShaderModule({
+      code: `${WEBGPU_SINGLE_PASS_VERTEX}
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+ return textureSampleLevel(source,sourceSampler,vec2f(input.uv.x,1.0-input.uv.y),0);
+}`
+    });
+    const flipPipeline = device.createRenderPipeline({
+      layout: "auto",
+      vertex: { module: flipModule, entryPoint: "vertex" },
+      fragment: {
+        module: flipModule,
+        entryPoint: "fragment",
+        targets: [{ format }]
+      },
+      primitive: { topology: "triangle-list" }
+    });
+    state.resources = {
+      device,
+      shader,
+      uniformSize,
+      topology,
+      blend,
+      pipeline,
+      flipPipeline,
+      sampler: device.createSampler({ magFilter: "linear", minFilter: "linear" }),
+      uniforms: device.createBuffer({
+        size: uniformSize,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      }),
+      vertices: null,
+      multisample: null,
+      source: null
+    };
+  }
+  const r = state.resources;
+  const sourceWidth = "displayWidth" in source ? source.displayWidth : ("videoWidth" in source) ? source.videoWidth : ("naturalWidth" in source) ? source.naturalWidth : typeof source.width === "number" ? source.width : source.width.baseVal.value;
+  const sourceHeight = "displayHeight" in source ? source.displayHeight : ("videoHeight" in source) ? source.videoHeight : ("naturalHeight" in source) ? source.naturalHeight : typeof source.height === "number" ? source.height : source.height.baseVal.value;
+  if (r.source && (r.source.width !== sourceWidth || r.source.height !== sourceHeight)) {
+    r.source.texture.destroy();
+    r.source = null;
+  }
+  if (!r.source)
+    r.source = {
+      width: sourceWidth,
+      height: sourceHeight,
+      texture: device.createTexture({
+        size: [sourceWidth, sourceHeight],
+        format: "rgba8unorm",
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
+      })
+    };
+  device.queue.copyExternalImageToTexture({ source }, { texture: r.source.texture, premultipliedAlpha: true }, [sourceWidth, sourceHeight]);
+  const size = Math.max(4, vertices?.byteLength ?? 0);
+  if (!r.vertices || r.vertices.size < size) {
+    r.vertices?.buffer.destroy();
+    r.vertices = {
+      size,
+      buffer: device.createBuffer({
+        size,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+      })
+    };
+  }
+  if (vertices)
+    device.queue.writeBuffer(r.vertices.buffer, 0, vertices.buffer, vertices.byteOffset, vertices.byteLength);
+  device.queue.writeBuffer(r.uniforms, 0, uniformData);
+  const bindGroup = device.createBindGroup({
+    layout: r.pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: r.source.texture.createView() },
+      { binding: 1, resource: r.sampler },
+      { binding: 2, resource: { buffer: r.uniforms } },
+      { binding: 3, resource: { buffer: r.vertices.buffer } }
+    ]
+  });
+  if (r.multisample && (r.multisample.width !== width || r.multisample.height !== height)) {
+    r.multisample.texture.destroy();
+    r.multisample.resolved.destroy();
+    r.multisample = null;
+  }
+  if (!r.multisample)
+    r.multisample = {
+      width,
+      height,
+      resolved: device.createTexture({
+        size: [width, height],
+        format: navigator.gpu.getPreferredCanvasFormat(),
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+      }),
+      texture: device.createTexture({
+        size: [width, height],
+        format: navigator.gpu.getPreferredCanvasFormat(),
+        sampleCount: 4,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT
+      })
+    };
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginRenderPass({
+    colorAttachments: [
+      {
+        view: r.multisample.texture.createView(),
+        resolveTarget: r.multisample.resolved.createView(),
+        clearValue: { r: 0, g: 0, b: 0, a: 0 },
+        loadOp: "clear",
+        storeOp: "store"
+      }
+    ]
+  });
+  pass.setPipeline(r.pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.draw(vertexCount, instanceCount);
+  pass.end();
+  const flipGroup = device.createBindGroup({
+    layout: r.flipPipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: r.multisample.resolved.createView() },
+      { binding: 1, resource: r.sampler }
+    ]
+  });
+  const flipPass = encoder.beginRenderPass({
+    colorAttachments: [
+      {
+        view: state.context.getCurrentTexture().createView(),
+        clearValue: { r: 0, g: 0, b: 0, a: 0 },
+        loadOp: "clear",
+        storeOp: "store"
+      }
+    ]
+  });
+  flipPass.setPipeline(r.flipPipeline);
+  flipPass.setBindGroup(0, flipGroup);
+  flipPass.draw(3);
+  flipPass.end();
+  device.queue.submit([encoder.finish()]);
+};
+
+export { setupWebGpuMesh, cleanupWebGpuMesh, applyWebGpuMesh };

package/dist/esm/preview/index-4z6pt3ka.mjs

@@ -0,0 +1,104 @@
+// src/value-noise-shader.ts
+var VALUE_NOISE_SHADER = `
+float lattice(ivec3 point, uint seed) {
+  // Wrap lattice indices as well as coordinates so interpolation stays continuous
+  // across the period boundary, including negative coordinates.
+  uvec3 p = uvec3(point) & uvec3(65535u);
+  uint h = p.x * 0x27d4eb2du ^ p.y * 0x165667b1u ^ p.z * 0x9e3779b9u ^ seed * 0x85ebca6bu;
+  h ^= h >> 15;
+  h *= 0x2c1b3c6du;
+  h ^= h >> 12;
+  h *= 0x297a2d39u;
+  h ^= h >> 15;
+  return float(h & 65535u) / 65535.0;
+}
+
+float catmull(vec4 p, float t) {
+  return 0.5 * (2.0 * p.y + (p.z - p.x) * t
+    + (2.0 * p.x - 5.0 * p.y + 4.0 * p.z - p.w) * t * t
+    + (3.0 * p.y - p.x - 3.0 * p.z + p.w) * t * t * t);
+}
+
+vec3 bspline(float t) {
+  return vec3(0.5 * (1.0-t) * (1.0-t), 0.5 + t * (1.0-t), 0.5 * t * t);
+}
+
+float sliceNoise(ivec3 p, vec2 t, uint seed) {
+  if (uNoiseType == 0) return lattice(p, seed);
+  if (uNoiseType == 1) {
+    return mix(mix(lattice(p, seed), lattice(p + ivec3(1,0,0), seed), t.x),
+      mix(lattice(p + ivec3(0,1,0), seed), lattice(p + ivec3(1,1,0), seed), t.x), t.y);
+  }
+  if (uNoiseType == 2) {
+    vec3 wx = bspline(t.x);
+    vec3 wy = bspline(t.y);
+    float result = 0.0;
+    for (int y = 0; y < 3; y++) {
+      for (int x = 0; x < 3; x++) {
+        result += wx[x] * wy[y] * lattice(p + ivec3(x-1, y-1, 0), seed);
+      }
+    }
+    return result;
+  }
+  vec4 rows;
+  for (int y = 0; y < 4; y++) {
+    vec4 row;
+    for (int x = 0; x < 4; x++) {
+      row[x] = lattice(p + ivec3(x-1, y-1, 0), seed);
+    }
+    rows[y] = catmull(row, t.x);
+  }
+  return catmull(rows, t.y);
+}
+
+float valueNoise(vec3 point, uint seed) {
+  // A large period keeps conversion to integer coordinates defined at extreme scales.
+  vec3 p = mod(point + vec3(uNoiseType == 2 ? 0.5 : 0.0, uNoiseType == 2 ? 0.5 : 0.0, 0.0), 65536.0);
+  ivec3 cell = ivec3(floor(p));
+  vec3 t = fract(p);
+  float fz = t.z * t.z * t.z * (t.z * (t.z * 6.0 - 15.0) + 10.0);
+  float n = mix(sliceNoise(cell, t.xy, seed), sliceNoise(cell + ivec3(0,0,1), t.xy, seed), fz);
+  return uNoiseType == 2 ? 0.5 + (n - 0.5) * (181.0 / 231.0) / 0.55 : n;
+}
+`;
+
+// src/value-noise-webgpu-shader.ts
+var VALUE_NOISE_WEBGPU_SHADER = `
+fn lattice(point: vec3i, seed: u32) -> f32 {
+  let p = bitcast<vec3u>(point) & vec3u(65535u);
+  var h = (p.x*0x27d4eb2du) ^ (p.y*0x165667b1u) ^ (p.z*0x9e3779b9u) ^ (seed*0x85ebca6bu);
+  h ^= h >> 15u; h *= 0x2c1b3c6du; h ^= h >> 12u; h *= 0x297a2d39u; h ^= h >> 15u;
+  return f32(h & 65535u)/65535.0;
+}
+fn catmull(p: vec4f, t: f32) -> f32 {
+  return 0.5*(2.0*p.y+(p.z-p.x)*t+(2.0*p.x-5.0*p.y+4.0*p.z-p.w)*t*t+(3.0*p.y-p.x-3.0*p.z+p.w)*t*t*t);
+}
+fn bspline(t: f32) -> vec3f { return vec3f(0.5*(1.0-t)*(1.0-t),0.5+t*(1.0-t),0.5*t*t); }
+fn sliceNoise(p: vec3i,t: vec2f,seed: u32) -> f32 {
+  if(noiseType()==0) { return lattice(p,seed); }
+  if(noiseType()==1) { return mix(mix(lattice(p,seed),lattice(p+vec3i(1,0,0),seed),t.x),mix(lattice(p+vec3i(0,1,0),seed),lattice(p+vec3i(1,1,0),seed),t.x),t.y); }
+  if(noiseType()==2) {
+    let wx=bspline(t.x); let wy=bspline(t.y); var result=0.0;
+    for(var y=0;y<3;y++) { for(var x=0;x<3;x++) { result += wx[x]*wy[y]*lattice(p+vec3i(x-1,y-1,0),seed); } }
+    return result;
+  }
+  var rows: vec4f;
+  for(var y=0;y<4;y++) {
+    var row: vec4f;
+    for(var x=0;x<4;x++) { row[x]=lattice(p+vec3i(x-1,y-1,0),seed); }
+    rows[y]=catmull(row,t.x);
+  }
+  return catmull(rows,t.y);
+}
+fn valueNoise(point: vec3f,seed: u32) -> f32 {
+  let offset=select(0.0,0.5,noiseType()==2);
+  let shifted=point+vec3f(offset,offset,0.0);
+  let p=shifted-floor(shifted/65536.0)*65536.0;
+  let cell=vec3i(floor(p)); let t=fract(p);
+  let fz=t.z*t.z*t.z*(t.z*(t.z*6.0-15.0)+10.0);
+  let n=mix(sliceNoise(cell,t.xy,seed),sliceNoise(cell+vec3i(0,0,1),t.xy,seed),fz);
+  return select(n,0.5+(n-0.5)*(181.0/231.0)/0.55,noiseType()==2);
+}
+`;
+
+export { VALUE_NOISE_SHADER, VALUE_NOISE_WEBGPU_SHADER };

package/dist/esm/preview/index-618ky75w.mjs

@@ -0,0 +1,51 @@
+import {
+  WEBGPU_MULTIPASS_BINDINGS
+} from "./index-kkvzt8b7.mjs";
+
+// src/gaussian-blur-webgpu-shader.ts
+var GAUSSIAN_BLUR_WEBGPU_SHADER = `
+${WEBGPU_MULTIPASS_BINDINGS}
+struct Params { resolution: vec2f, direction: vec2f, values: vec4f, startEnd: vec4f, radial: vec4f, }
+fn radiusAt(uv: vec2f) -> f32 {
+ let mode = params.values.y;
+ if (mode == 0.0) {return params.values.x;}
+ if (mode == 1.0) {
+  let gradient = params.startEnd.zw - params.startEnd.xy;
+  let lengthSq = dot(gradient, gradient);
+  if (lengthSq <= 0.0000001) {return max(0.0, params.values.z);}
+  let progress = clamp(dot(uv - params.startEnd.xy, gradient) / lengthSq, 0.0, 1.0);
+  return max(0.0, mix(params.values.z, params.values.w, progress));
+ }
+ let radii = params.startEnd.zw * params.resolution * 0.5;
+ if (radii.x <= 0.0000001 || radii.y <= 0.0000001) {return max(0.0, params.values.z);}
+ let delta = (uv - params.startEnd.xy) * params.resolution;
+ let angle = radians(params.radial.x);
+ let c = cos(angle); let s = sin(angle);
+ let local = vec2f(c * delta.x + s * delta.y, -s * delta.x + c * delta.y);
+ let ellipseProgress = clamp(length(local / radii), 0.0, 1.0);
+ let distance = 1.0 - params.radial.y;
+ var progress = step(params.radial.y, ellipseProgress);
+ if (abs(distance) > 0.0000001) {progress = clamp((ellipseProgress - params.radial.y) / distance, 0.0, 1.0);}
+ return max(0.0, mix(params.values.z, params.values.w, progress));
+}
+@fragment fn fragment(input: VertexOutput) -> @location(0) vec4f {
+ let radius = radiusAt(input.uv);
+ if (radius <= 0.0) {return textureSampleLevel(source, sourceSampler, input.uv, 0);}
+ let halfKernel = i32(clamp(ceil(radius / 2.0), 4.0, 32.0));
+ let stride = radius / f32(halfKernel);
+ let sigma = select(max(radius / 3.0, 0.0001), radius / 3.0, params.values.y == 0.0);
+ let twoSigmaSq = 2.0 * sigma * sigma;
+ var sum = vec4f(0); var weightSum = 0.0;
+ for (var i = -32; i <= 32; i++) {
+  if (abs(i) > halfKernel) {continue;}
+  let offset = f32(i) * stride;
+  let weight = exp(-(offset * offset) / twoSigmaSq);
+  let uv = input.uv + params.direction / params.resolution * offset;
+  sum += textureSampleLevel(source, sourceSampler, uv, 0) * weight;
+  weightSum += weight;
+ }
+ return sum / weightSum;
+}
+`;
+
+export { GAUSSIAN_BLUR_WEBGPU_SHADER };