@fps-games/vfx 0.1.1

package/packages/effects/lumber_vehicle_upgrade_aura/assets/runtime/upgradeAura.v1.js

@@ -0,0 +1,353 @@
+export const runtimeId = "upgradeAura/v1";
+
+export const runtimeContract = {
+  runtimeId,
+  kind: "upgradeAura",
+  emitterFields: {
+    origin: "World-space center of the upgrade aura.",
+    duration: "Total effect lifetime in seconds.",
+    spiralTurns: "Number of turns in the continuous rising spiral.",
+    ringRiseHeight: "World-space travel height of the whole spiral during its lifetime.",
+    spiralHeight: "Static local height of the spiral shape.",
+    sparkleCount: "Number of body sparkles emitted during the effect.",
+    ringColor: "Primary spiral color.",
+    bodyGlowColor: "Vertical body glow color.",
+    hdrIntensity: "Shared HDR emissive intensity for the upgrade light.",
+  },
+};
+
+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.84, 0.22)) {
+  if (!value) return fallback;
+  return new BABYLON.Color3(num(value.r, fallback.r), num(value.g, fallback.g), num(value.b, fallback.b));
+}
+
+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 makeGlowMaterial(BABYLON, scene, name, color, alpha, hdrIntensity = 1) {
+  const material = new BABYLON.StandardMaterial(name, scene);
+  material.diffuseColor = color;
+  material.emissiveColor = scaleColor(BABYLON, color, hdrIntensity);
+  material.alpha = alpha;
+  material.backFaceCulling = false;
+  material.disableLighting = true;
+  material.disableDepthWrite = true;
+  material.useAlphaFromDiffuseTexture = false;
+  material.transparencyMode = BABYLON.Material.MATERIAL_ALPHABLEND;
+  if (BABYLON.Engine?.ALPHA_ADD !== undefined) {
+    material.alphaMode = BABYLON.Engine.ALPHA_ADD;
+  }
+  return material;
+}
+
+function createSoftTexture(BABYLON, scene, name, width, height, mode = "vertical") {
+  const texture = new BABYLON.DynamicTexture(name, { 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 dx = Math.abs(u - 0.5) * 2;
+      const dy = Math.abs(v - 0.5) * 2;
+      const horizontal = Math.max(0, 1 - dx);
+      const vertical = mode === "radial" ? Math.max(0, 1 - dy) : Math.sin(v * Math.PI);
+      const radial = mode === "radial"
+        ? Math.max(0, 1 - Math.sqrt(dx * dx + dy * dy))
+        : horizontal * vertical;
+      const alpha = Math.pow(radial, mode === "radial" ? 2.2 : 1.8);
+      const offset = (y * width + x) * 4;
+      data[offset] = 255;
+      data[offset + 1] = 255;
+      data[offset + 2] = 255;
+      data[offset + 3] = Math.round(alpha * 255);
+    }
+  }
+
+  ctx.putImageData(image, 0, 0);
+  texture.update(false);
+  return texture;
+}
+
+function makeTexturedGlowMaterial(BABYLON, scene, name, color, alpha, hdrIntensity, texture) {
+  const material = makeGlowMaterial(BABYLON, scene, name, color, alpha, hdrIntensity);
+  material.diffuseTexture = texture;
+  material.emissiveTexture = texture;
+  material.opacityTexture = texture;
+  material.useAlphaFromDiffuseTexture = true;
+  return material;
+}
+
+function createSpiralPath(BABYLON, config, phase = 0) {
+  const turns = Math.max(1, num(config.spiralTurns, 3.4));
+  const height = Math.max(0.05, num(config.spiralHeight, 1.12));
+  const radius = Math.max(0.05, num(config.ringRadius, 0.72));
+  const steps = Math.max(72, Math.round(turns * 56));
+  const path = [];
+
+  for (let index = 0; index <= steps; index += 1) {
+    const t = index / steps;
+    const angle = phase + t * turns * Math.PI * 2;
+    const waist = 0.94 + Math.sin(t * Math.PI) * 0.1;
+    path.push(new BABYLON.Vector3(
+      Math.cos(angle) * radius * waist,
+      0.05 + t * height,
+      Math.sin(angle) * radius * waist
+    ));
+  }
+
+  return path;
+}
+
+function createSpiral(BABYLON, scene, root, material, name, config, phase = 0, radiusScale = 1) {
+  const spiral = BABYLON.MeshBuilder.CreateTube(
+    name,
+    {
+      path: createSpiralPath(BABYLON, config, phase),
+      radius: num(config.ringThickness, 0.035) * radiusScale,
+      tessellation: 14,
+      cap: BABYLON.Mesh.CAP_ALL,
+    },
+    scene
+  );
+  spiral.parent = root;
+  spiral.material = material;
+  return spiral;
+}
+
+function createSpark(BABYLON, scene, root, material, index, config) {
+  const spark = BABYLON.MeshBuilder.CreatePlane(
+    `vfx_upgrade_body_spark_${index}`,
+    {
+      width: num(config.sparkWidth, 0.045),
+      height: num(config.sparkHeight, 0.22),
+    },
+    scene
+  );
+  spark.parent = root;
+  spark.material = material;
+  spark.billboardMode = BABYLON.Mesh.BILLBOARDMODE_ALL;
+  return spark;
+}
+
+function createBodyGlowPlane(BABYLON, scene, root, material, index, config) {
+  const plane = BABYLON.MeshBuilder.CreatePlane(
+    `vfx_upgrade_body_soft_glow_${index}`,
+    {
+      width: num(config.width, 0.72),
+      height: num(config.height, 1.75),
+    },
+    scene
+  );
+  plane.parent = root;
+  plane.material = material;
+  plane.position.y = num(config.height, 1.75) * 0.5;
+  plane.rotation.y = index * Math.PI / Math.max(1, num(config.count, 3));
+  return plane;
+}
+
+export async function createUpgradeAuraRuntime({ BABYLON, scene, emitter, shouldStart = false }) {
+  if (!BABYLON) throw new Error("createUpgradeAuraRuntime requires BABYLON.");
+  if (!scene) throw new Error("createUpgradeAuraRuntime requires scene.");
+  if (!emitter) throw new Error("createUpgradeAuraRuntime requires emitter.");
+
+  const origin = readVec(BABYLON, emitter.origin, BABYLON.Vector3.Zero());
+  const duration = Math.max(0.1, num(emitter.duration, 1.35));
+  const effectScale = Math.max(0.05, num(emitter.effectScale, 1));
+  const spiralTurns = Math.max(1, num(emitter.spiralTurns ?? emitter.ringCount, 3.4));
+  const sparkleCount = Math.max(0, Math.round(num(emitter.sparkleCount, 22)));
+  const spiralTravelHeight = Math.max(0.02, num(emitter.ringRiseHeight, 1.45) * effectScale);
+  const spiralHeight = Math.max(0.05, num(emitter.spiralHeight, 1.12) * effectScale);
+  const bodyRiseHeight = Math.max(0.05, num(emitter.bodyRiseHeight, 1.75) * effectScale);
+  const sparkleLife = Math.max(0.12, num(emitter.sparkleLife, 0.62));
+  const ringColor = readColor3(BABYLON, emitter.ringColor, new BABYLON.Color3(1, 0.78, 0.14));
+  const bodyGlowColor = readColor3(BABYLON, emitter.bodyGlowColor, new BABYLON.Color3(1, 0.95, 0.5));
+  const hdrIntensity = Math.max(0, num(emitter.hdrIntensity, 3.0));
+
+  const root = new BABYLON.TransformNode(`vfx_upgrade_aura_${Date.now()}`, scene);
+  root.position.copyFrom(origin);
+
+  const bodyGlowTexture = createSoftTexture(BABYLON, scene, "vfx_upgrade_body_soft_texture", 96, 256, "vertical");
+  const sparkTexture = createSoftTexture(BABYLON, scene, "vfx_upgrade_spark_soft_texture", 96, 96, "radial");
+  const ringMaterial = makeGlowMaterial(BABYLON, scene, "vfx_upgrade_ring_mat", ringColor, num(emitter.ringAlpha, 0.78), hdrIntensity);
+  const spiralCoreMaterial = makeGlowMaterial(BABYLON, scene, "vfx_upgrade_spiral_core_mat", bodyGlowColor, num(emitter.ringAlpha, 0.78), hdrIntensity);
+  const spiralHaloMaterial = makeGlowMaterial(BABYLON, scene, "vfx_upgrade_spiral_halo_mat", ringColor, num(emitter.spiralGlowAlpha, 0.08), Math.max(1, hdrIntensity * 0.7));
+  const bodySoftMaterial = makeTexturedGlowMaterial(BABYLON, scene, "vfx_upgrade_body_soft_mat", bodyGlowColor, num(emitter.bodyGlowAlpha, 0.62), hdrIntensity, bodyGlowTexture);
+  const sparkMaterial = makeTexturedGlowMaterial(BABYLON, scene, "vfx_upgrade_spark_mat", bodyGlowColor, num(emitter.sparkAlpha, 0.92), hdrIntensity, sparkTexture);
+
+  const bodyPlanes = Array.from({ length: 3 }, (_, index) => createBodyGlowPlane(BABYLON, scene, root, bodySoftMaterial, index, {
+    width: 0.78 * effectScale,
+    height: bodyRiseHeight,
+    count: 3,
+  }));
+
+  const spiralConfig = {
+    spiralTurns,
+    ringRadius: num(emitter.ringRadius, 0.78) * effectScale,
+    ringThickness: num(emitter.ringThickness, 0.035) * effectScale,
+    spiralHeight,
+  };
+  const spiralHalo = createSpiral(
+    BABYLON,
+    scene,
+    root,
+    spiralHaloMaterial,
+    "vfx_upgrade_continuous_spiral_halo",
+    spiralConfig,
+    0,
+    2.2
+  );
+  const spiral = createSpiral(BABYLON, scene, root, ringMaterial, "vfx_upgrade_continuous_spiral", spiralConfig);
+  const spiralCore = createSpiral(
+    BABYLON,
+    scene,
+    root,
+    spiralCoreMaterial,
+    "vfx_upgrade_continuous_spiral_core",
+    spiralConfig,
+    0.07,
+    0.48
+  );
+
+  const sparks = Array.from({ length: sparkleCount }, (_, index) => {
+    const spark = createSpark(BABYLON, scene, root, sparkMaterial, index, {
+      sparkWidth: num(emitter.sparkWidth, 0.045) * effectScale,
+      sparkHeight: num(emitter.sparkHeight, 0.22) * effectScale,
+    });
+    spark.metadata = {
+      angle: sequence01(index, 0) * Math.PI * 2,
+      radius: (0.12 + sequence01(index, 1) * 0.36) * effectScale,
+      delay: sequence01(index, 2) * duration * 0.64,
+      spin: (sequence01(index, 3) < 0.5 ? -1 : 1) * (0.6 + sequence01(index, 4) * 1.1),
+    };
+    return spark;
+  });
+
+  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);
+    const pulse = Math.sin(globalT * Math.PI);
+
+    ringMaterial.alpha = num(emitter.ringAlpha, 0.78) * pulse;
+    spiralCoreMaterial.alpha = num(emitter.ringAlpha, 0.78) * 0.42 * pulse;
+    spiralHaloMaterial.alpha = num(emitter.spiralGlowAlpha, 0.08) * pulse;
+    bodySoftMaterial.alpha = num(emitter.bodyGlowAlpha, 0.62) * pulse;
+    spiral.position.y = -0.1 + globalT * spiralTravelHeight;
+    spiralCore.position.y = spiral.position.y;
+    spiralHalo.position.y = spiral.position.y;
+    spiral.rotation.y = elapsed * 2.15;
+    spiralCore.rotation.y = spiral.rotation.y;
+    spiralHalo.rotation.y = spiral.rotation.y;
+    const spiralScale = 0.96 + pulse * 0.1;
+    spiral.scaling.setAll(spiralScale);
+    spiralCore.scaling.setAll(spiralScale);
+    spiralHalo.scaling.setAll(spiralScale);
+    for (let index = 0; index < bodyPlanes.length; index += 1) {
+      bodyPlanes[index].rotation.y = index * Math.PI / bodyPlanes.length + elapsed * 0.52;
+      bodyPlanes[index].scaling.set(0.9 + pulse * 0.18, 1, 1);
+    }
+
+    for (const spark of sparks) {
+      const meta = spark.metadata || {};
+      const localElapsed = elapsed - num(meta.delay, 0);
+      const local = ((localElapsed % sparkleLife) + sparkleLife) % sparkleLife / sparkleLife;
+      const angle = num(meta.angle, 0) + elapsed * num(meta.spin, 1);
+      const radius = num(meta.radius, 0.28);
+      spark.position.x = Math.cos(angle) * radius;
+      spark.position.z = Math.sin(angle) * radius;
+      spark.position.y = 0.1 + local * bodyRiseHeight;
+      spark.rotation.z = angle;
+      spark.visibility = Math.max(0, Math.sin(local * Math.PI));
+      spark.scaling.setAll(0.7 + 0.55 * Math.sin(local * Math.PI));
+    }
+
+    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 spark of sparks) spark.dispose(false, true);
+    for (const plane of bodyPlanes) plane.dispose(false, true);
+    spiralHalo.dispose(false, true);
+    spiral.dispose(false, true);
+    spiralCore.dispose(false, true);
+    root.dispose();
+    ringMaterial.dispose();
+    spiralCoreMaterial.dispose();
+    spiralHaloMaterial.dispose();
+    bodySoftMaterial.dispose();
+    sparkMaterial.dispose();
+    bodyGlowTexture.dispose();
+    sparkTexture.dispose();
+  }
+
+  function setPosition(position) {
+    if (disposed || !position) return;
+    root.position.copyFrom(position);
+  }
+
+  function setScaling(scaling) {
+    if (disposed || !scaling) return;
+    root.scaling.copyFrom(scaling);
+  }
+
+  root.setEnabled(false);
+  const preview = {
+    start,
+    stop,
+    dispose,
+    isStarted: () => running,
+    setPosition,
+    setScaling,
+    duration,
+  };
+
+  if (shouldStart) start();
+  return preview;
+}

package/packages/effects/lumber_vehicle_upgrade_aura/index.ts

@@ -0,0 +1,11 @@
+import manifest from './lumber_vehicle_upgrade_aura.json';
+import runtimeUrl from './assets/runtime/upgradeAura.v1.js?url';
+import { createManifestRuntimeEffectPackage } from '../../manifestRuntimePackage';
+
+export const lumberVehicleUpgradeAuraEffectPackage = createManifestRuntimeEffectPackage({
+  id: 'lumber_vehicle_upgrade_aura',
+  manifest,
+  assetUrls: {
+    'assets/runtime/upgradeAura.v1.js': runtimeUrl,
+  },
+});