@agent-native/core-corpus 0.214.0 → 0.216.0

package/corpus/templates/design/shared/native-effect-folded-mesh.ts

@@ -0,0 +1,489 @@
+import { catalogColor, catalogFloat } from "./native-effect-catalog-kit";
+import { nativeEffectPaintWgsl } from "./native-effect-paint";
+import { nativeGlobalBindingsForUniformFloats } from "./native-effect-wgsl";
+import {
+  planNativePropertyLayout,
+  planNativeRecordLayout,
+  type EffectDefinition,
+} from "./native-effects";
+
+const fill = {
+  type: "paint" as const,
+  label: "Fill",
+  maxCount: 8,
+  default: {
+    kind: "linear" as const,
+    angle: 90,
+    interpolation: "in oklab" as const,
+    stops: [
+      { position: 0, color: catalogColor(0.52, 0.65, 1) },
+      { position: 0.24, color: catalogColor(0.94, 0.42, 0.91) },
+      { position: 0.36, color: catalogColor(1, 0.38, 0.48) },
+      { position: 0.49, color: catalogColor(1, 0.88, 0.25) },
+      { position: 0.68, color: catalogColor(1, 0.48, 0.14) },
+      { position: 1, color: catalogColor(0.96, 0.33, 0.54) },
+    ],
+  },
+};
+
+function groupedFloat(group: string, ...args: Parameters<typeof catalogFloat>) {
+  return { ...catalogFloat(...args), group };
+}
+
+function percentFloat(...args: Parameters<typeof catalogFloat>) {
+  return { ...catalogFloat(...args), unit: "%", displayScale: 100, step: 0.01 };
+}
+
+const lightFields = {
+  positionX: percentFloat("Position X", 0, -3, 3),
+  positionY: percentFloat("Position Y", 0, -3, 3),
+  positionZ: percentFloat("Position Z", 1, -3, 3),
+  directionX: percentFloat("Direction X", 0, -1, 1),
+  directionY: percentFloat("Direction Y", 0, -1, 1),
+  directionZ: percentFloat("Direction Z", -1, -1, 1),
+  color: {
+    type: "color" as const,
+    label: "Color",
+    default: catalogColor(1, 1, 1),
+  },
+  intensity: percentFloat("Intensity", 1, 0, 4),
+  amount: percentFloat("Amount", 0.5, 0, 1),
+  exponent: {
+    ...percentFloat("Focus", 8, 0, 32),
+    displayScale: 100 / 32,
+    step: 0.32,
+  },
+};
+
+const noiseBandFields = {
+  startX: percentFloat("Left", 0, 0, 1),
+  endX: percentFloat("Right", 1, 0, 1),
+  startY: percentFloat("Top", 0, 0, 1),
+  endY: percentFloat("Bottom", 1, 0, 1),
+  feather: percentFloat("Feather", 0.1, 0, 1),
+  strength: percentFloat("Strength", 0.2, 0, 2),
+  frequency: {
+    ...catalogFloat("Frequency", 600, 0, 1600, 1),
+    unit: "×",
+    displayScale: 1,
+  },
+  colorAttenuation: percentFloat("Color attenuation", 0.9, 0, 1),
+  parabolaPower: {
+    ...percentFloat("Focus", 3, 0, 8),
+    displayScale: 100 / 8,
+    step: 0.04,
+  },
+};
+
+const properties = {
+  fill,
+  timeOffset: groupedFloat("Motion", "Time offset", 0, -30, 30),
+  contrast: groupedFloat("Color", "Contrast", 1, 0, 2),
+  saturation: groupedFloat("Color", "Saturation", 1, 0, 2),
+  hueShift: groupedFloat("Color", "Hue shift", 0, -2 * Math.PI, 2 * Math.PI),
+  displacementAmount: groupedFloat("Shape", "Displacement amount", 0.62, 0, 1),
+  displacementFrequencyX: groupedFloat(
+    "Shape",
+    "Displacement frequency X",
+    12.7,
+    0,
+    20,
+    0.1,
+  ),
+  displacementFrequencyY: groupedFloat(
+    "Shape",
+    "Displacement frequency Y",
+    1.1,
+    0,
+    20,
+    0.1,
+  ),
+  positionX: groupedFloat("Transform", "Position X", 0, -2, 2),
+  positionY: groupedFloat("Transform", "Position Y", 0, -2, 2),
+  positionZ: groupedFloat("Transform", "Position Z", 0, -2, 2),
+  rotationX: groupedFloat(
+    "Transform",
+    "Rotation X",
+    0,
+    -2 * Math.PI,
+    2 * Math.PI,
+  ),
+  rotationY: groupedFloat(
+    "Transform",
+    "Rotation Y",
+    0,
+    -2 * Math.PI,
+    2 * Math.PI,
+  ),
+  rotationZ: groupedFloat(
+    "Transform",
+    "Rotation Z",
+    0,
+    -2 * Math.PI,
+    2 * Math.PI,
+  ),
+  scaleX: groupedFloat("Transform", "Scale X", 1, 0.25, 3),
+  scaleY: groupedFloat("Transform", "Scale Y", 1, 0.25, 3),
+  scaleZ: groupedFloat("Transform", "Scale Z", 1, 0.25, 3),
+  twistX: groupedFloat("Shape", "Twist X", 0.62, -2 * Math.PI, 2 * Math.PI),
+  twistY: groupedFloat("Shape", "Twist Y", 2, -2 * Math.PI, 2 * Math.PI),
+  twistZ: groupedFloat("Shape", "Twist Z", 0, -2 * Math.PI, 2 * Math.PI),
+  foldConcentrationX: groupedFloat("Shape", "Fold tightness X", 0.5, 0, 1),
+  foldConcentrationY: groupedFloat("Shape", "Fold tightness Y", 0.12, 0, 1),
+  foldConcentrationZ: groupedFloat("Shape", "Fold tightness Z", 0.5, 0, 1),
+  glowAmount: groupedFloat("Surface", "Glow amount", 0.45, 0, 2),
+  glowSpread: groupedFloat("Surface", "Glow spread", 0.45, 0, 1),
+  glowFocus: groupedFloat("Surface", "Glow focus", 0.5, 0, 1),
+  lineDensity: groupedFloat("Surface", "Line density", 300, 0, 600, 1),
+  lineThickness: groupedFloat("Surface", "Line thickness", 0.5, 0, 1),
+  compressionResponse: groupedFloat("Surface", "Compression response", 1, 0, 2),
+  lights: {
+    type: "record-array" as const,
+    label: "Lights",
+    itemLabel: "Light",
+    group: "Surface",
+    minCount: 0,
+    maxCount: 4,
+    fields: lightFields,
+    default: [],
+  },
+  noiseBands: {
+    type: "record-array" as const,
+    label: "Noise bands",
+    itemLabel: "Noise band",
+    group: "Surface",
+    minCount: 0,
+    maxCount: 4,
+    fields: noiseBandFields,
+    parameterConstraints: [
+      {
+        kind: "ordered-floats" as const,
+        lesser: "startX",
+        greater: "endX",
+        minGap: 0.001,
+      },
+      {
+        kind: "ordered-floats" as const,
+        lesser: "startY",
+        greater: "endY",
+        minGap: 0.001,
+      },
+    ],
+    default: [],
+  },
+};
+
+const propertyLayout = planNativePropertyLayout({
+  properties,
+  uniformPacking: "compact",
+  uniformFloats: 256,
+});
+const lightLayout = planNativeRecordLayout(lightFields);
+const bandLayout = planNativeRecordLayout(noiseBandFields);
+if (propertyLayout.offsets.fill !== 0)
+  throw new Error("Folded Mesh paint must start at uniform zero");
+
+function nativeParam(name: keyof typeof properties): string {
+  const offset = propertyLayout.offsets[name];
+  if (offset === undefined)
+    throw new Error(`Folded Mesh property ${name} is unbound`);
+  return `globals.params[${Math.floor(offset / 4)}].${"xyzw"[offset % 4]}`;
+}
+
+function recordParam(
+  property: "lights" | "noiseBands",
+  field: string,
+  index = "index",
+): string {
+  const layout = property === "lights" ? lightLayout : bandLayout;
+  const offset = layout.offsets[field];
+  const base = propertyLayout.offsets[property];
+  if (offset === undefined || base === undefined || layout.stride % 4 !== 0)
+    throw new Error(`Folded Mesh record field ${property}.${field} is unbound`);
+  const absolute = base + 4 + offset;
+  return `globals.params[${Math.floor(absolute / 4)}u + ${index} * ${layout.stride / 4}u].${"xyzw"[absolute % 4]}`;
+}
+
+function recordColor(property: "lights", field: "color"): string {
+  const offset = lightLayout.offsets[field];
+  const base = propertyLayout.offsets[property];
+  if (
+    offset === undefined ||
+    base === undefined ||
+    (base + 4 + offset) % 4 !== 0
+  )
+    throw new Error(`Folded Mesh record color ${property}.${field} is unbound`);
+  return `globals.params[${(base + 4 + offset) / 4}u + index * ${lightLayout.stride / 4}u]`;
+}
+
+export const FOLDED_MESH_EFFECT: EffectDefinition = {
+  id: "an-native-folded-mesh",
+  name: "Folded Mesh",
+  version: 3,
+  kind: "generator",
+  placements: ["fill"],
+  uniformPacking: "compact",
+  uniformFloats: 256,
+  properties,
+  outputs: { color: { kind: "texture-2d", resource: "color" } },
+  resources: [
+    {
+      name: "color",
+      kind: "texture-2d",
+      format: "rgba16float",
+      usage: ["render", "sampled"],
+      size: "viewport",
+    },
+  ],
+  output: "color",
+  passes: [
+    {
+      id: "folded-surface",
+      kind: "render",
+      reads: [],
+      output: "color",
+      mesh: { columns: 128, rows: 96 },
+      wgsl: `${nativeGlobalBindingsForUniformFloats(256)}
+${nativeEffectPaintWgsl(propertyLayout.offsets.fill / 4, "foldedFill")}
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+  @location(1) normal: vec3f,
+  @location(2) seam: f32,
+  @location(3) @interpolate(flat) hueRotation: vec2f,
+  @location(4) worldPosition: vec3f,
+};
+fn rotateX(value: vec3f, sine: f32, cosine: f32) -> vec3f {
+  return vec3f(value.x, value.y * cosine - value.z * sine, value.y * sine + value.z * cosine);
+}
+fn rotateY(value: vec3f, sine: f32, cosine: f32) -> vec3f {
+  return vec3f(value.x * cosine + value.z * sine, value.y, -value.x * sine + value.z * cosine);
+}
+fn rotateZ(value: vec3f, sine: f32, cosine: f32) -> vec3f {
+  return vec3f(value.x * cosine - value.y * sine, value.x * sine + value.y * cosine, value.z);
+}
+@vertex fn vs(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  let uv = vec2f(f32(vertexIndex % 129u), f32(vertexIndex / 129u)) / vec2f(128.0, 96.0);
+  let aspect = globals.viewport.x / max(globals.viewport.y, 1.0);
+  let size = 0.68;
+  let twistX = ${nativeParam("twistX")};
+  let twistY = ${nativeParam("twistY")};
+  let twistZ = ${nativeParam("twistZ")};
+  let depth = ${nativeParam("displacementAmount")};
+  let frequencyX = ${nativeParam("displacementFrequencyX")};
+  let frequencyY = ${nativeParam("displacementFrequencyY")};
+  let foldX = ${nativeParam("foldConcentrationX")};
+  let foldY = ${nativeParam("foldConcentrationY")};
+  let foldZ = ${nativeParam("foldConcentrationZ")};
+  let time = globals.clock.x + ${nativeParam("timeOffset")};
+  let deformationStrength = clamp(max(length(vec3f(twistX, twistY, twistZ)) / 2.094, depth / 0.62), 0.0, 1.0);
+  let s = uv.y;
+  let t = uv.x * 2.0 - 1.0;
+  let foldRadius = 0.05 + 0.16 * (1.0 - foldX);
+  let foldEnvelope = exp(-t * t / foldRadius);
+  let foldEnvelopeT = -2.0 * t * foldEnvelope / foldRadius;
+  let foldStrength = 0.85 + 0.66 * foldZ;
+  let foldedT = t - deformationStrength * foldStrength * t * foldEnvelope;
+  let foldedTT = 1.0 - deformationStrength * foldStrength * (foldEnvelope + t * foldEnvelopeT);
+  let pleatPhase = 6.2831853 * (frequencyX * uv.x + frequencyY * s) + time * 0.3;
+  let broadPhase = 5.0 * t + 2.0 * s + time * 0.2;
+  let pleatWeight = 0.025;
+  let ridgeHeight = 0.08 + 0.12 * foldZ;
+  let relief = depth * size * (ridgeHeight * foldEnvelope + pleatWeight * sin(pleatPhase) + 0.04 * sin(broadPhase));
+  let reliefT = depth * size * (ridgeHeight * foldEnvelopeT + 3.14159265 * frequencyX * pleatWeight * cos(pleatPhase) + 0.2 * cos(broadPhase));
+  let reliefS = depth * size * (6.2831853 * frequencyY * pleatWeight * cos(pleatPhase) + 0.08 * cos(broadPhase));
+  let across = 1.55 * aspect * size;
+  let tailPosition = clamp((s - 0.58) / 0.42, 0.0, 1.0);
+  let tail = tailPosition * tailPosition * (3.0 - 2.0 * tailPosition);
+  let tailS = select(0.0, 6.0 * tailPosition * (1.0 - tailPosition) / 0.42, s > 0.58 && s < 1.0);
+  let longitudinal = (1.75 - 3.3 * s - 1.35 * tail) * size;
+  let base = vec3f(across * foldedT, longitudinal, relief);
+  let baseT = vec3f(across * foldedTT, 0.0, reliefT);
+  let baseS = vec3f(0.0, (-3.3 - 1.35 * tailS) * size, reliefS);
+  let turnWidth = 1.0 - 0.75 * foldY;
+  let turnStart = 0.5 - 0.5 * turnWidth;
+  let turnEnd = 0.5 + 0.5 * turnWidth;
+  let turnPosition = clamp((s - turnStart) / turnWidth, 0.0, 1.0);
+  let turnProfile = turnPosition * turnPosition * (3.0 - 2.0 * turnPosition);
+  let turnProfileS = select(0.0, 6.0 * turnPosition * (1.0 - turnPosition) / turnWidth, s > turnStart && s < turnEnd);
+  let hingeRadius = 0.09 + 0.32 * (1.0 - foldX);
+  let hingeEnvelope = exp(-t * t / hingeRadius);
+  let hingeEnvelopeT = -2.0 * t * hingeEnvelope / hingeRadius;
+  let hingePhase = 3.14159265 * s + time * 0.14;
+  let hingeStrength = (0.5 + 0.9 * foldZ) * twistY / 2.0;
+  let hinge = hingeStrength * t * hingeEnvelope * sin(hingePhase);
+  let hingeT = hingeStrength * (hingeEnvelope + t * hingeEnvelopeT) * sin(hingePhase);
+  let hingeS = hingeStrength * t * hingeEnvelope * 3.14159265 * cos(hingePhase);
+  let turn = twistY * turnProfile + hinge;
+  let turnT = hingeT;
+  let turnS = twistY * turnProfileS + hingeS;
+  let sinTurn = sin(turn);
+  let cosTurn = cos(turn);
+  let turned = vec3f(base.x * cosTurn + base.z * sinTurn, base.y, -base.x * sinTurn + base.z * cosTurn);
+  let turnedT = vec3f(baseT.x * cosTurn + baseT.z * sinTurn, baseT.y, -baseT.x * sinTurn + baseT.z * cosTurn)
+    + turnT * vec3f(turned.z, 0.0, -turned.x);
+  let turnedS = vec3f(baseS.x * cosTurn + baseS.z * sinTurn, baseS.y, -baseS.x * sinTurn + baseS.z * cosTurn)
+    + turnS * vec3f(turned.z, 0.0, -turned.x);
+  let curlEnvelope = exp(-t * t / 0.4);
+  let curlEnvelopeT = -2.0 * t * curlEnvelope / 0.4;
+  let curlPhase = 3.14159265 * s + time * 0.12;
+  let bend = twistX * (0.8 * t * curlEnvelope * sin(curlPhase) + 0.22 * sin(2.0 * s + time * 0.15));
+  let bendT = twistX * 0.8 * (curlEnvelope + t * curlEnvelopeT) * sin(curlPhase);
+  let bendS = twistX * (0.8 * t * curlEnvelope * 3.14159265 * cos(curlPhase) + 0.44 * cos(2.0 * s + time * 0.15));
+  let sinBend = sin(bend);
+  let cosBend = cos(bend);
+  let curled = vec3f(turned.x, turned.y * cosBend - turned.z * sinBend, turned.y * sinBend + turned.z * cosBend);
+  let curledT = vec3f(turnedT.x, turnedT.y * cosBend - turnedT.z * sinBend, turnedT.y * sinBend + turnedT.z * cosBend)
+    + bendT * vec3f(0.0, -curled.z, curled.y);
+  let curledS = vec3f(turnedS.x, turnedS.y * cosBend - turnedS.z * sinBend, turnedS.y * sinBend + turnedS.z * cosBend)
+    + bendS * vec3f(0.0, -curled.z, curled.y);
+  let roll = twistZ * turnProfile;
+  let rolled = rotateZ(curled, sin(roll), cos(roll));
+  let rolledT = rotateZ(curledT, sin(roll), cos(roll));
+  let rolledS = rotateZ(curledS, sin(roll), cos(roll))
+    + twistZ * turnProfileS * vec3f(-rolled.y, rolled.x, 0.0);
+  let sweepPhase = 2.0 * s + time * 0.16;
+  let sweep = deformationStrength * (0.1 + 1.6 * s - 0.7 * s * s + 0.04 * sin(sweepPhase));
+  let sweepS = deformationStrength * (1.6 - 1.4 * s + 0.08 * cos(sweepPhase));
+  let axisScale = vec3f(${nativeParam("scaleX")}, ${nativeParam("scaleY")}, ${nativeParam("scaleZ")});
+  let scaled = (rolled + vec3f(sweep * aspect * size, 0.0, 0.0)) * axisScale;
+  let scaledT = rolledT * axisScale;
+  let scaledS = (rolledS + vec3f(sweepS * aspect * size, 0.0, 0.0)) * axisScale;
+  let rx = ${nativeParam("rotationX")};
+  let ry = ${nativeParam("rotationY")};
+  let rz = ${nativeParam("rotationZ")};
+  let world = rotateZ(rotateY(rotateX(scaled, sin(rx), cos(rx)), sin(ry), cos(ry)), sin(rz), cos(rz))
+    + vec3f(2.0 * aspect * ${nativeParam("positionX")}, -2.0 * ${nativeParam("positionY")}, 2.0 * ${nativeParam("positionZ")});
+  let tangentT = rotateZ(rotateY(rotateX(scaledT, sin(rx), cos(rx)), sin(ry), cos(ry)), sin(rz), cos(rz));
+  let tangentS = rotateZ(rotateY(rotateX(scaledS, sin(rx), cos(rx)), sin(ry), cos(ry)), sin(rz), cos(rz));
+  let surface = cross(tangentT, tangentS);
+  let camera = 10.0 + 9.0 * max(aspect, 1.0);
+  let viewDepth = camera - world.z;
+  let nearPlane = 0.1;
+  let farPlane = camera * 2.5;
+  var output: VertexOutput;
+  output.position = vec4f(
+    world.x * camera / aspect,
+    world.y * camera,
+    farPlane / (farPlane - nearPlane) * viewDepth - farPlane * nearPlane / (farPlane - nearPlane),
+    viewDepth
+  );
+  output.uv = uv;
+  output.normal = surface / max(length(surface), 1e-12);
+  output.seam = t;
+  output.worldPosition = world;
+  let hue = ${nativeParam("hueShift")};
+  output.hueRotation = vec2f(cos(hue), sin(hue));
+  return output;
+}
+fn bandHash(cell: vec2u) -> f32 {
+  var value = cell.x * 1664525u + cell.y * 1013904223u + 374761393u;
+  value = (value ^ (value >> 16u)) * 2246822519u;
+  value = (value ^ (value >> 13u)) * 3266489917u;
+  return f32((value ^ (value >> 16u)) & 65535u) / 65535.0;
+}
+@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+  let paint = foldedFill(input.uv, globals.viewport.xy);
+  let oriented = select(input.normal, -input.normal, input.normal.z < 0.0);
+  let normal = oriented / max(length(oriented), 1e-12);
+  let light = normalize(vec3f(-0.36, 0.55, 0.75));
+  let diffuse = max(dot(normal, light), 0.0);
+  let reflection = pow(diffuse, 20.0);
+  let sourceColor = paint.rgb / max(paint.a, 1e-5);
+  let hueAxis = vec3f(0.577350269);
+  let shiftedColor = sourceColor * input.hueRotation.x
+    + cross(hueAxis, sourceColor) * input.hueRotation.y
+    + hueAxis * dot(hueAxis, sourceColor) * (1.0 - input.hueRotation.x);
+  let luma = dot(shiftedColor, vec3f(0.2126, 0.7152, 0.0722));
+  let saturated = mix(vec3f(luma), shiftedColor, ${nativeParam("saturation")});
+  let color = clamp((saturated - vec3f(0.5)) * ${nativeParam("contrast")} + vec3f(0.5), vec3f(0.0), vec3f(1.0));
+  var lightContribution = vec3f(0.0);
+  let lightCount = u32(${nativeParam("lights")});
+  for (var index = 0u; index < lightCount; index += 1u) {
+    let lightPosition = vec3f(
+      2.0 * globals.viewport.x / max(globals.viewport.y, 1.0) * ${recordParam("lights", "positionX")},
+      -2.0 * ${recordParam("lights", "positionY")},
+      2.0 * ${recordParam("lights", "positionZ")}
+    );
+    let lightDirection = vec3f(
+      ${recordParam("lights", "directionX")},
+      -${recordParam("lights", "directionY")},
+      ${recordParam("lights", "directionZ")}
+    );
+    let toLight = lightPosition - input.worldPosition;
+    let distanceSquared = max(dot(toLight, toLight), 1e-8);
+    let towardLight = toLight * inverseSqrt(distanceSquared);
+    let directionLength = length(lightDirection);
+    let spotDirection = lightDirection / max(directionLength, 1e-6);
+    let focus = select(
+      1.0,
+      pow(max(dot(-towardLight, spotDirection), 1e-5), ${recordParam("lights", "exponent")}),
+      directionLength > 1e-6
+    );
+    let incidence = max(dot(normal, towardLight), 0.0);
+    let falloff = 1.0 / (1.0 + 0.12 * distanceSquared);
+    let tint = ${recordColor("lights", "color")};
+    lightContribution += tint.rgb * tint.a * ${recordParam("lights", "intensity")}
+      * ${recordParam("lights", "amount")} * incidence * focus * falloff * 0.42;
+  }
+  let lineDensity = ${nativeParam("lineDensity")};
+  let fiberPhase = 6.2831853 * lineDensity * input.uv.x + input.uv.y * 34.0
+    + 7.0 * sin(input.uv.x * 29.0 + input.uv.y * 8.0 + (globals.clock.x + ${nativeParam("timeOffset")}) * 0.12);
+  let fiberAA = 1.0 - smoothstep(1.2, 3.2, fwidth(fiberPhase));
+  let fiberEnvelope = smoothstep(0.02, 0.24, input.uv.x)
+    * (1.0 - smoothstep(0.76, 0.98, input.uv.x));
+  let lineThickness = ${nativeParam("lineThickness")};
+  let lineThreshold = 0.92 - 0.84 * lineThickness;
+  let fiber = smoothstep(lineThreshold, 1.0, 0.5 + 0.5 * sin(fiberPhase))
+    * (0.88 + 0.12 * sin(input.uv.y * 19.0 + input.uv.x * 13.0))
+    * fiberAA * fiberEnvelope * min(lineDensity, 1.0) * smoothstep(0.0, 0.04, lineThickness);
+  var bandContribution = 0.0;
+  let bandCount = u32(${nativeParam("noiseBands")});
+  for (var index = 0u; index < bandCount; index += 1u) {
+    let left = ${recordParam("noiseBands", "startX")};
+    let right = ${recordParam("noiseBands", "endX")};
+    let top = ${recordParam("noiseBands", "startY")};
+    let bottom = ${recordParam("noiseBands", "endY")};
+    let strength = ${recordParam("noiseBands", "strength")};
+    let requestedFrequency = ${recordParam("noiseBands", "frequency")};
+    if (left >= right || top >= bottom || strength <= 0.0 || requestedFrequency <= 0.0) { continue; }
+    let feather = max(${recordParam("noiseBands", "feather")}, 1e-4);
+    let bandMask = smoothstep(left - feather, left, input.uv.x)
+      * (1.0 - smoothstep(right, right + feather, input.uv.x))
+      * smoothstep(top - feather, top, input.uv.y)
+      * (1.0 - smoothstep(bottom, bottom + feather, input.uv.y));
+    let frequency = min(
+      requestedFrequency,
+      0.7 / max(fwidth(input.uv.x), 1e-6)
+    );
+    let cell = vec2u(floor(input.uv * vec2f(frequency, max(frequency * 0.018, 1.0))));
+    let variation = bandHash(cell) - 0.5;
+    let across = max(4.0 * input.uv.x * (1.0 - input.uv.x), 1e-5);
+    let envelope = pow(across, ${recordParam("noiseBands", "parabolaPower")});
+    let colorResponse = mix(
+      1.0,
+      1.0 - color.b,
+      ${recordParam("noiseBands", "colorAttenuation")}
+    );
+    bandContribution += bandMask * strength
+      * envelope * colorResponse * (0.16 + 0.18 * variation);
+  }
+  let seamWidth = 0.004 + 0.048 * ${nativeParam("glowSpread")};
+  let seam = pow(exp(-input.seam * input.seam / seamWidth), 0.3 + 1.4 * ${nativeParam("glowFocus")});
+  let compression = length(vec2f(dpdx(input.uv.x), dpdy(input.uv.x))) * globals.viewport.x;
+  let turnGlow = smoothstep(1.3, 4.5, compression) * ${nativeParam("compressionResponse")};
+  let illumination = 0.91 + 0.16 * diffuse + 0.12 * fiber;
+  let glow = ${nativeParam("glowAmount")} / 0.45;
+  let rgb = paint.a * color * illumination
+    + paint.a * glow * (vec3f(0.12) * reflection + vec3f(0.08) * seam + vec3f(0.06) * turnGlow)
+    + paint.a * color * (lightContribution + vec3f(bandContribution));
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(paint.a)), paint.a);
+}
+`,
+    },
+  ],
+  provenance: {
+    origin: "design-original",
+    note: "Original vertex-deformed folded surface with packed native paint.",
+  },
+};

package/corpus/templates/design/shared/native-effect-gallery-additions.ts

@@ -501,7 +501,7 @@ fn octaveSimplex(point: vec2f, requested: f32) -> f32 {
 `,
 });
 
-const pulsingBorder = catalogShader({
+export const PULSING_BORDER_V1_EFFECT = catalogShader({
   id: "pulsing-border",
   name: "Pulsing Border",
   kind: "processor",
@@ -644,7 +644,7 @@ export const NATIVE_EFFECT_GALLERY_ADDITIONS: readonly EffectDefinition[] = [
   neuroNoise,
   perlinNoise,
   simplexNoise,
-  pulsingBorder,
+  PULSING_BORDER_V1_EFFECT,
   colorPanels,
   smokeRing,
   godRays,

package/corpus/templates/design/shared/native-effect-paint.ts

@@ -26,6 +26,7 @@ export interface EffectPaintProperty {
   label: string;
   default: EffectPaint;
   maxCount: number;
+  allowedKinds?: EffectPaint["kind"][];
   group?: string;
   rebuild?: boolean;
 }
@@ -82,6 +83,7 @@ function color(value: unknown): value is EffectColor {
 export function isEffectPaint(
   value: unknown,
   maxCount = MAX_EFFECT_PAINT_STOPS,
+  allowedKinds?: readonly EffectPaint["kind"][],
 ): value is EffectPaint {
   if (
     !Number.isInteger(maxCount) ||
@@ -90,6 +92,12 @@ export function isEffectPaint(
     !object(value)
   )
     return false;
+  if (
+    allowedKinds !== undefined &&
+    (!Array.isArray(allowedKinds) ||
+      !allowedKinds.includes(value.kind as EffectPaint["kind"]))
+  )
+    return false;
   if (value.kind === "solid")
     return keys(value, ["kind", "color"]) && color(value.color);
   return (

package/corpus/templates/design/shared/native-effect-parameter-constraints.ts

@@ -23,6 +23,7 @@ const MAX_CONSTRAINTS = 8;
 type ConstraintProperty = {
   type?: unknown;
   default?: unknown;
+  defaultFrom?: unknown;
   min?: unknown;
   max?: unknown;
 };
@@ -262,9 +263,15 @@ export function validateResolvedParameterConstraints(
   for (const constraint of constraints) {
     const keys = constraintPropertyKeys(constraint);
     for (const key of keys) {
+      const property = properties[key];
+      const fallback = property?.defaultFrom;
       values[key] = own(params as Record<string, unknown>, key)
         ? params[key]
-        : properties[key]?.default;
+        : typeof fallback === "string" && properties[fallback]
+          ? own(params as Record<string, unknown>, fallback)
+            ? params[fallback]
+            : properties[fallback].default
+          : property?.default;
     }
   }
   return constraints.flatMap((constraint, index) => {

package/corpus/templates/design/shared/native-effect-presets.ts

@@ -13,7 +13,13 @@ import {
   DOCUMENT_PIXEL_V2_EFFECTS,
   HISTORICAL_DOCUMENT_PIXEL_EFFECTS,
 } from "./native-effect-document-pixels-v2";
-import { NATIVE_EFFECT_GALLERY_ADDITIONS } from "./native-effect-gallery-additions";
+import { FOLDED_MESH_EFFECT } from "./native-effect-folded-mesh";
+import { FOLDED_MESH_V1_EFFECT } from "./native-effect-folded-mesh-v1";
+import { FOLDED_MESH_V2_EFFECT } from "./native-effect-folded-mesh-v2";
+import {
+  NATIVE_EFFECT_GALLERY_ADDITIONS,
+  PULSING_BORDER_V1_EFFECT,
+} from "./native-effect-gallery-additions";
 import { LIQUID_GLASS_EFFECT as LIQUID_GLASS_V1_EFFECT } from "./native-effect-liquid-glass-v1";
 import { LIQUID_GLASS_EFFECT as LIQUID_GLASS_V2_EFFECT } from "./native-effect-liquid-glass-v2";
 import { LIQUID_GLASS_EFFECT } from "./native-effect-liquid-glass-v3";
@@ -33,6 +39,9 @@ import {
   SOURCE_GLINTS_EFFECT,
   SOURCE_GLINTS_PRESETS,
 } from "./native-effect-owned-cc-source-glints";
+import { PULSING_BORDER_EFFECT } from "./native-effect-pulsing-border";
+import { PULSING_BORDER_V3_EFFECT } from "./native-effect-pulsing-border-v3";
+import { PULSING_BORDER_V4_EFFECT } from "./native-effect-pulsing-border-v4";
 import {
   IMAGE_DITHERING_EFFECT,
   NEBULA_EFFECT,
@@ -390,6 +399,7 @@ if (galleryCandidates.length !== galleryCandidateIds.size)
   throw new Error("Native shader gallery selection is incomplete.");
 
 export const NATIVE_EFFECT_DEFINITION_CATALOG: readonly EffectDefinition[] = [
+  FOLDED_MESH_EFFECT,
   ...tierOneCatalogDefinitions,
   ...galleryCandidates,
   ...NATIVE_EFFECT_V3_DEFINITIONS,
@@ -400,12 +410,14 @@ export const NATIVE_EFFECT_DEFINITION_CATALOG: readonly EffectDefinition[] = [
   LIQUID_METAL_EFFECT,
   FLUTED_GLASS_EFFECT,
   LIQUID_GLASS_EFFECT,
+  PULSING_BORDER_EFFECT,
   IMAGE_DITHERING_EFFECT,
   WAVES_EFFECT,
   NEBULA_EFFECT,
   ...DOCUMENT_PIXEL_V2_EFFECTS,
   ...NATIVE_EFFECT_GALLERY_ADDITIONS.filter(
     (definition) =>
+      definition.id !== PULSING_BORDER_EFFECT.id &&
       !HISTORICAL_DOCUMENT_PIXEL_EFFECTS.some(
         (legacy) => legacy.id === definition.id,
       ),
@@ -415,6 +427,8 @@ export const NATIVE_EFFECT_LATEST_DEFINITIONS: readonly EffectDefinition[] =
   NATIVE_EFFECT_DEFINITION_CATALOG;
 
 export const NATIVE_EFFECT_BUILTIN_VERSIONS: readonly EffectDefinition[] = [
+  FOLDED_MESH_V1_EFFECT,
+  FOLDED_MESH_V2_EFFECT,
   ...HISTORICAL_DOCUMENT_PIXEL_EFFECTS,
   LIQUID_METAL_V1_EFFECT,
   LIQUID_METAL_V2_EFFECT,
@@ -429,6 +443,9 @@ export const NATIVE_EFFECT_BUILTIN_VERSIONS: readonly EffectDefinition[] = [
   LIQUID_METAL_V11_EFFECT,
   LIQUID_GLASS_V1_EFFECT,
   LIQUID_GLASS_V2_EFFECT,
+  PULSING_BORDER_V1_EFFECT,
+  PULSING_BORDER_V3_EFFECT,
+  PULSING_BORDER_V4_EFFECT,
   ...NATIVE_EFFECT_DEFINITION_CATALOG,
 ];