@fps-games/vfx 0.1.1

package/packages/effects/door_open_gold_flakes/assets/runtime/goldFlakes.v1.js

@@ -0,0 +1,397 @@
+export const runtimeId = "goldFlakes/v1";
+
+export const runtimeContract = {
+  runtimeId,
+  kind: "goldFlakes",
+  emitterFields: {
+    origin: "World-space center of the gold flake field.",
+    duration: "Total effect lifetime in seconds.",
+    flakeCount: "Number of rising gold flakes.",
+    areaRadius: "Horizontal distribution radius.",
+    riseHeight: "Vertical travel height during lifetime.",
+    flakeColor: "Gold flake color.",
+    lightRayCount: "Number of rising light sheets.",
+    glowColor: "Door opening light sheet color.",
+  },
+};
+
+function num(value, fallback = 0) {
+  const next = Number(value);
+  return Number.isFinite(next) ? next : fallback;
+}
+
+function readVec(BABYLON, value, fallback = new BABYLON.Vector3(0, 0, 0)) {
+  if (!value) return fallback.clone ? fallback.clone() : fallback;
+  return new BABYLON.Vector3(num(value.x, fallback.x), num(value.y, fallback.y), num(value.z, fallback.z));
+}
+
+function readColor3(BABYLON, value, fallback = new BABYLON.Color3(1, 0.78, 0.18)) {
+  if (typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value)) {
+    return new BABYLON.Color3(
+      parseInt(value.slice(1, 3), 16) / 255,
+      parseInt(value.slice(3, 5), 16) / 255,
+      parseInt(value.slice(5, 7), 16) / 255
+    );
+  }
+  if (!value) return fallback;
+  return new BABYLON.Color3(num(value.r, fallback.r), num(value.g, fallback.g), num(value.b, fallback.b));
+}
+
+function colorByte(value) {
+  return Math.max(0, Math.min(255, Math.round(num(value, 1) * 255)));
+}
+
+function scaleColor(BABYLON, color, intensity) {
+  const next = color.clone ? color.clone() : new BABYLON.Color3(color.r, color.g, color.b);
+  return next.scale(Math.max(0, num(intensity, 1)));
+}
+
+function sequence01(index, axis) {
+  const strides = [0.618033988749895, 0.414213562373095, 0.732050807568877, 0.324717957244746];
+  return (0.5 + index * strides[axis % strides.length] + axis * 0.173205080756888) % 1;
+}
+
+function createFlakeTexture(BABYLON, scene) {
+  const width = 48;
+  const height = 96;
+  const texture = new BABYLON.DynamicTexture("vfx_door_gold_flake_texture", { width, height }, scene, false);
+  texture.hasAlpha = true;
+  const ctx = texture.getContext();
+  const image = ctx.createImageData(width, height);
+  const data = image.data;
+
+  for (let y = 0; y < height; y += 1) {
+    const v = y / Math.max(1, height - 1);
+    for (let x = 0; x < width; x += 1) {
+      const u = x / Math.max(1, width - 1);
+      const edgeX = Math.min(u, 1 - u) * 2;
+      const edgeY = Math.min(v, 1 - v) * 2;
+      const alpha = Math.pow(Math.max(0, Math.min(edgeX * 1.4, edgeY * 1.7, 1)), 0.7);
+      const center = 0.72 + Math.max(0, 1 - Math.abs(u - 0.5) * 2) * 0.28;
+      const offset = (y * width + x) * 4;
+      data[offset] = Math.round(255 * center);
+      data[offset + 1] = Math.round(255 * center);
+      data[offset + 2] = Math.round(255 * center);
+      data[offset + 3] = Math.round(alpha * 255);
+    }
+  }
+
+  ctx.putImageData(image, 0, 0);
+  texture.update(false);
+  return texture;
+}
+
+function createLightRayTexture(BABYLON, scene, color) {
+  const width = 96;
+  const height = 256;
+  const texture = new BABYLON.DynamicTexture("vfx_door_light_ray_texture", { width, height }, scene, false);
+  texture.hasAlpha = true;
+  const ctx = texture.getContext();
+  const image = ctx.createImageData(width, height);
+  const data = image.data;
+
+  for (let y = 0; y < height; y += 1) {
+    const v = y / Math.max(1, height - 1);
+    for (let x = 0; x < width; x += 1) {
+      const u = x / Math.max(1, width - 1);
+      const center = Math.max(0, 1 - Math.abs(u - 0.5) * 2);
+      const vertical = Math.sin(Math.PI * Math.min(1, Math.max(0, v)));
+      const base = Math.pow(center, 2.4) * Math.pow(vertical, 0.58);
+      const edgeFade = Math.min(1, Math.max(0, (1 - v) * 1.45));
+      const alpha = Math.min(1, base * edgeFade);
+      const offset = (y * width + x) * 4;
+      data[offset] = colorByte(color.r);
+      data[offset + 1] = colorByte(color.g);
+      data[offset + 2] = colorByte(color.b);
+      data[offset + 3] = Math.round(alpha * 255);
+    }
+  }
+
+  ctx.putImageData(image, 0, 0);
+  texture.update(false);
+  return texture;
+}
+
+function createRadialGlowTexture(BABYLON, scene, color) {
+  const size = 192;
+  const texture = new BABYLON.DynamicTexture("vfx_door_radial_glow_texture", { width: size, height: size }, scene, false);
+  texture.hasAlpha = true;
+  const ctx = texture.getContext();
+  const image = ctx.createImageData(size, size);
+  const data = image.data;
+
+  for (let y = 0; y < size; y += 1) {
+    const v = y / Math.max(1, size - 1);
+    for (let x = 0; x < size; x += 1) {
+      const u = x / Math.max(1, size - 1);
+      const dx = (u - 0.5) * 2;
+      const dy = (v - 0.5) * 2;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      const alpha = Math.pow(Math.max(0, 1 - distance), 2.15);
+      const offset = (y * size + x) * 4;
+      data[offset] = colorByte(color.r);
+      data[offset + 1] = colorByte(color.g);
+      data[offset + 2] = colorByte(color.b);
+      data[offset + 3] = Math.round(alpha * 255);
+    }
+  }
+
+  ctx.putImageData(image, 0, 0);
+  texture.update(false);
+  return texture;
+}
+
+function applyRenderOrder(mesh, alphaIndex = 110) {
+  mesh.renderingGroupId = 2;
+  mesh.alphaIndex = alphaIndex;
+}
+
+function makeMaterial(BABYLON, scene, name, color, alpha, hdrIntensity, texture) {
+  const material = new BABYLON.StandardMaterial(name, scene);
+  material.diffuseColor = color;
+  material.emissiveColor = scaleColor(BABYLON, color, hdrIntensity);
+  material.diffuseTexture = texture;
+  material.emissiveTexture = texture;
+  material.opacityTexture = texture;
+  material.alpha = alpha;
+  material.backFaceCulling = false;
+  material.disableLighting = true;
+  material.disableDepthWrite = true;
+  material.disableDepthTest = true;
+  material.forceDepthWrite = false;
+  material.useAlphaFromDiffuseTexture = true;
+  material.transparencyMode = BABYLON.Material.MATERIAL_ALPHABLEND;
+  if (BABYLON.Engine?.ALPHA_ADD !== undefined) {
+    material.alphaMode = BABYLON.Engine.ALPHA_ADD;
+  }
+  return material;
+}
+
+function createFlake(BABYLON, scene, root, material, index, config) {
+  const flake = BABYLON.MeshBuilder.CreatePlane(
+    `vfx_door_gold_flake_${index}`,
+    {
+      width: num(config.width, 0.055),
+      height: num(config.height, 0.18),
+    },
+    scene
+  );
+  flake.parent = root;
+  flake.material = material;
+  flake.billboardMode = BABYLON.Mesh.BILLBOARDMODE_ALL;
+  applyRenderOrder(flake, 120);
+
+  const areaRadius = Math.max(0.01, num(config.areaRadius, 0.7));
+  const angle = sequence01(index, 0) * Math.PI * 2;
+  const radius = Math.sqrt(sequence01(index, 1)) * areaRadius;
+  flake.metadata = {
+    x: Math.cos(angle) * radius,
+    z: Math.sin(angle) * radius,
+    delay: sequence01(index, 2) * num(config.staggerTime, 0.34),
+    phase: sequence01(index, 3) * Math.PI * 2,
+  };
+  return flake;
+}
+
+function createLightRay(BABYLON, scene, root, material, index, config) {
+  const ray = BABYLON.MeshBuilder.CreatePlane(
+    `vfx_door_light_ray_${index}`,
+    {
+      width: num(config.width, 0.22),
+      height: num(config.height, 1.45),
+    },
+    scene
+  );
+  ray.parent = root;
+  ray.material = material;
+  ray.billboardMode = BABYLON.Mesh.BILLBOARDMODE_Y;
+  ray.alwaysSelectAsActiveMesh = true;
+  applyRenderOrder(ray, 112);
+
+  const count = Math.max(1, Math.round(num(config.count, 5)));
+  const spread = Math.max(0.01, num(config.spread, 0.74));
+  const t = count <= 1 ? 0.5 : index / (count - 1);
+  ray.metadata = {
+    x: (t - 0.5) * spread,
+    y: num(config.y, 0.52),
+    delay: sequence01(index, 1) * num(config.staggerTime, 0.16),
+    phase: sequence01(index, 2) * Math.PI * 2,
+    heightScale: 0.82 + sequence01(index, 3) * 0.34,
+  };
+  return ray;
+}
+
+function createCenterGlow(BABYLON, scene, root, material, config) {
+  const glow = BABYLON.MeshBuilder.CreatePlane(
+    "vfx_door_center_glow",
+    {
+      width: num(config.width, 1.35),
+      height: num(config.height, 1.05),
+    },
+    scene
+  );
+  glow.parent = root;
+  glow.material = material;
+  glow.billboardMode = BABYLON.Mesh.BILLBOARDMODE_ALL;
+  glow.alwaysSelectAsActiveMesh = true;
+  glow.position.y = num(config.y, 0.42);
+  applyRenderOrder(glow, 108);
+  return glow;
+}
+
+export async function createGoldFlakesRuntime({ BABYLON, scene, emitter, shouldStart = false }) {
+  if (!BABYLON) throw new Error("createGoldFlakesRuntime requires BABYLON.");
+  if (!scene) throw new Error("createGoldFlakesRuntime requires scene.");
+  if (!emitter) throw new Error("createGoldFlakesRuntime requires emitter.");
+
+  const origin = readVec(BABYLON, emitter.origin, BABYLON.Vector3.Zero());
+  const duration = Math.max(0.1, num(emitter.duration, 1.2));
+  const effectScale = Math.max(0.05, num(emitter.effectScale, 1));
+  const flakeCount = Math.max(1, Math.round(num(emitter.flakeCount, 28)));
+  const areaRadius = Math.max(0.01, num(emitter.areaRadius, 0.7) * effectScale);
+  const riseHeight = Math.max(0.01, num(emitter.riseHeight, 1.35) * effectScale);
+  const flakeAlpha = Math.max(0, num(emitter.flakeAlpha, 0.9));
+  const hdrIntensity = Math.max(0, num(emitter.hdrIntensity, 1.8));
+  const flakeColor = readColor3(BABYLON, emitter.flakeColor, new BABYLON.Color3(1, 0.78, 0.18));
+  const lightRayCount = Math.max(0, Math.round(num(emitter.lightRayCount, 5)));
+  const lightRayAlpha = Math.max(0, num(emitter.lightRayAlpha, 0.92));
+  const lightRayScaleX = Math.max(0.01, num(emitter.lightRayScaleX, 1));
+  const lightRayScaleY = Math.max(0.01, num(emitter.lightRayScaleY, 1));
+  const lightRayScaleZ = Math.max(0.01, num(emitter.lightRayScaleZ, 1));
+  const glowAlpha = Math.max(0, num(emitter.glowAlpha, 0.72));
+  const glowIntensity = Math.max(0, num(emitter.glowIntensity, 4.2));
+  const glowColor = readColor3(BABYLON, emitter.glowColor, new BABYLON.Color3(1, 0.9, 0.42));
+
+  const root = new BABYLON.TransformNode(`vfx_door_gold_flakes_${Date.now()}`, scene);
+  root.position.copyFrom(origin);
+  root.position.y += Math.max(0.01, num(emitter.groundOffsetY, 0.06) * effectScale);
+  root.scaling.set(
+    Math.max(0.01, num(emitter.scaleX, 1)),
+    Math.max(0.01, num(emitter.scaleY, 1)),
+    Math.max(0.01, num(emitter.scaleZ, 1))
+  );
+
+  const texture = createFlakeTexture(BABYLON, scene);
+  const rayTexture = createLightRayTexture(BABYLON, scene, glowColor);
+  const radialTexture = createRadialGlowTexture(BABYLON, scene, glowColor);
+  const material = makeMaterial(BABYLON, scene, "vfx_door_gold_flake_mat", flakeColor, 1, hdrIntensity, texture);
+  const rayMaterial = makeMaterial(BABYLON, scene, "vfx_door_light_ray_mat", glowColor, 1, glowIntensity, rayTexture);
+  const glowMaterial = makeMaterial(BABYLON, scene, "vfx_door_center_glow_mat", glowColor, 1, glowIntensity, radialTexture);
+  const flakes = Array.from({ length: flakeCount }, (_, index) => createFlake(BABYLON, scene, root, material, index, {
+    areaRadius,
+    staggerTime: emitter.staggerTime,
+    width: num(emitter.flakeWidth, 0.055) * effectScale,
+    height: num(emitter.flakeHeight, 0.18) * effectScale,
+  }));
+  const lightRays = Array.from({ length: lightRayCount }, (_, index) => createLightRay(BABYLON, scene, root, rayMaterial, index, {
+    count: lightRayCount,
+    spread: num(emitter.lightRaySpread, 0.82) * effectScale,
+    staggerTime: emitter.lightRayStaggerTime,
+    width: num(emitter.lightRayWidth, 0.22) * effectScale,
+    height: num(emitter.lightRayHeight, 1.45) * effectScale,
+    y: num(emitter.lightRayOffsetY, 0.62) * effectScale,
+  }));
+  const centerGlow = createCenterGlow(BABYLON, scene, root, glowMaterial, {
+    width: num(emitter.glowWidth, 1.28) * effectScale,
+    height: num(emitter.glowHeight, 0.92) * effectScale,
+    y: num(emitter.glowOffsetY, 0.42) * effectScale,
+  });
+
+  let startedAt = 0;
+  let observer = null;
+  let running = false;
+  let disposed = false;
+
+  const update = () => {
+    const elapsed = (performance.now() - startedAt) / 1000;
+    const globalT = Math.min(1, elapsed / duration);
+
+    for (const flake of flakes) {
+      const meta = flake.metadata || {};
+      const delay = num(meta.delay, 0);
+      const local = Math.min(1, Math.max(0, (elapsed - delay) / Math.max(0.01, duration - delay)));
+      const fadeIn = Math.min(1, local / 0.12);
+      const fadeOut = Math.min(1, (1 - local) / 0.28);
+      const alpha = flakeAlpha * Math.max(0, Math.min(fadeIn, fadeOut));
+      flake.position.x = num(meta.x, 0);
+      flake.position.z = num(meta.z, 0);
+      flake.position.y = local * riseHeight;
+      flake.visibility = alpha;
+      flake.scaling.setAll(0.86 + Math.sin(local * Math.PI) * 0.18);
+    }
+
+    for (const ray of lightRays) {
+      const meta = ray.metadata || {};
+      const delay = num(meta.delay, 0);
+      const local = Math.min(1, Math.max(0, (elapsed - delay) / Math.max(0.01, duration - delay)));
+      const fadeIn = Math.min(1, local / 0.18);
+      const fadeOut = Math.min(1, (1 - local) / 0.34);
+      const pulse = 0.82 + Math.sin(local * Math.PI * 2 + num(meta.phase, 0)) * 0.18;
+      ray.position.x = num(meta.x, 0);
+      ray.position.y = num(meta.y, 0.62) + local * riseHeight * 0.15;
+      ray.position.z = 0;
+      ray.visibility = lightRayAlpha * Math.max(0, Math.min(fadeIn, fadeOut)) * pulse;
+      const pulseScale = 0.84 + Math.sin(local * Math.PI) * 0.22;
+      ray.scaling.set(
+        pulseScale * lightRayScaleX,
+        num(meta.heightScale, 1) * lightRayScaleY,
+        lightRayScaleZ
+      );
+    }
+
+    centerGlow.visibility = glowAlpha * Math.sin(globalT * Math.PI);
+    centerGlow.scaling.setAll(0.86 + Math.sin(globalT * Math.PI) * 0.24);
+    material.alpha = flakeAlpha * Math.sin(globalT * Math.PI);
+    rayMaterial.alpha = 1;
+    glowMaterial.alpha = 1;
+
+    if (elapsed >= duration) {
+      stop();
+    }
+  };
+
+  function start() {
+    if (running || disposed) return;
+    running = true;
+    startedAt = performance.now();
+    root.setEnabled(true);
+    observer = scene.onBeforeRenderObservable.add(update);
+  }
+
+  function stop() {
+    if (!running) return;
+    running = false;
+    if (observer) {
+      scene.onBeforeRenderObservable.remove(observer);
+      observer = null;
+    }
+    dispose();
+  }
+
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    for (const flake of flakes) flake.dispose(false, true);
+    for (const ray of lightRays) ray.dispose(false, true);
+    centerGlow.dispose(false, true);
+    root.dispose();
+    material.dispose();
+    rayMaterial.dispose();
+    glowMaterial.dispose();
+    texture.dispose();
+    rayTexture.dispose();
+    radialTexture.dispose();
+  }
+
+  root.setEnabled(false);
+  const preview = {
+    start,
+    stop,
+    dispose,
+    isStarted: () => running,
+    duration,
+  };
+
+  if (shouldStart) start();
+  return preview;
+}