@fps-games/vfx 0.1.1 → 0.3.3

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

@@ -1,397 +0,0 @@
-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;
-}