@adatechnology/game-vfx-three 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/renderer.ts
+import { markKitOrigin } from "@adatechnology/game-contracts";
 import { colorOfChunk, createVfx, hexToLinearRgb } from "@adatechnology/game-vfx";
 
 // src/shaders/glow.ts
@@ -531,6 +532,81 @@ function createMarkLayer(THREE, options) {
   };
 }
 
+// src/mesh-layer.ts
+var SPHERE_DEFAULT_WIDTH = 8;
+var SPHERE_DEFAULT_HEIGHT = 6;
+function geometryOf(THREE, particle) {
+  switch (particle.shape) {
+    case "cone":
+      return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+    case "cone_open":
+      return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+    case "sphere":
+      return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+    case "icosahedron":
+      return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+  }
+}
+function materialOf(THREE, particle) {
+  if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
+  return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
+}
+function createMeshLayerProbes(THREE) {
+  const geometry = new THREE.BoxGeometry(1e-3, 1e-3, 1e-3);
+  return [{ lit: true, additive: false }, { lit: false, additive: false }, { lit: false, additive: true }].map(
+    (kind) => new THREE.Mesh(geometry, materialOf(THREE, { ...kind, color: 8421504, opacity: 0.5 }))
+  );
+}
+function createMeshLayer(THREE, pool) {
+  const group = new THREE.Group();
+  group.name = "workshop-meshes";
+  const drawn = /* @__PURE__ */ new Map();
+  const frame = new THREE.Quaternion();
+  const euler = new THREE.Euler();
+  const turn = new THREE.Quaternion();
+  const offset = new THREE.Vector3();
+  function release(mesh) {
+    mesh.removeFromParent();
+    mesh.geometry.dispose();
+    mesh.material.dispose();
+  }
+  return {
+    group,
+    sync() {
+      const live = /* @__PURE__ */ new Set();
+      for (const particle of pool.particles) {
+        live.add(particle.id);
+        let mesh = drawn.get(particle.id);
+        if (!mesh) {
+          mesh = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
+          mesh.frustumCulled = false;
+          mesh.renderOrder = particle.additive ? 5 : 3;
+          drawn.set(particle.id, mesh);
+          group.add(mesh);
+        }
+        frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
+        offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
+        mesh.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
+        turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
+        mesh.quaternion.copy(frame).multiply(turn);
+        mesh.scale.setScalar(particle.scale);
+        mesh.material.opacity = particle.opacity;
+      }
+      for (const [id, mesh] of drawn) {
+        if (live.has(id)) continue;
+        release(mesh);
+        drawn.delete(id);
+      }
+      return pool.count;
+    },
+    dispose() {
+      for (const mesh of drawn.values()) release(mesh);
+      drawn.clear();
+      group.removeFromParent();
+    }
+  };
+}
+
 // src/screen-overlay.ts
 var clamp = (value, min, max) => value < min ? min : value > max ? max : value;
 function layer(container, name, blend) {
@@ -710,75 +786,6 @@ function createSpriteLayer(THREE, system, pointScale) {
   };
 }
 
-// src/mesh-layer.ts
-var SPHERE_DEFAULT_WIDTH = 8;
-var SPHERE_DEFAULT_HEIGHT = 6;
-function geometryOf(THREE, particle) {
-  switch (particle.shape) {
-    case "cone":
-      return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
-    case "cone_open":
-      return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
-    case "sphere":
-      return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
-    case "icosahedron":
-      return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
-  }
-}
-function materialOf(THREE, particle) {
-  if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
-  return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
-}
-function createMeshLayer(THREE, pool) {
-  const group = new THREE.Group();
-  group.name = "workshop-meshes";
-  const drawn = /* @__PURE__ */ new Map();
-  const frame = new THREE.Quaternion();
-  const euler = new THREE.Euler();
-  const turn = new THREE.Quaternion();
-  const offset = new THREE.Vector3();
-  function release(mesh) {
-    mesh.removeFromParent();
-    mesh.geometry.dispose();
-    mesh.material.dispose();
-  }
-  return {
-    group,
-    sync() {
-      const live = /* @__PURE__ */ new Set();
-      for (const particle of pool.particles) {
-        live.add(particle.id);
-        let mesh = drawn.get(particle.id);
-        if (!mesh) {
-          mesh = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
-          mesh.frustumCulled = false;
-          mesh.renderOrder = particle.additive ? 5 : 3;
-          drawn.set(particle.id, mesh);
-          group.add(mesh);
-        }
-        frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
-        offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
-        mesh.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
-        turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
-        mesh.quaternion.copy(frame).multiply(turn);
-        mesh.scale.setScalar(particle.scale);
-        mesh.material.opacity = particle.opacity;
-      }
-      for (const [id, mesh] of drawn) {
-        if (live.has(id)) continue;
-        release(mesh);
-        drawn.delete(id);
-      }
-      return pool.count;
-    },
-    dispose() {
-      for (const mesh of drawn.values()) release(mesh);
-      drawn.clear();
-      group.removeFromParent();
-    }
-  };
-}
-
 // src/shaders/workshop-sprite.ts
 var WORKSHOP_SPRITE_VERTEX = `attribute float size;attribute float alpha;attribute vec3 pcol;varying vec3 vC;varying float vA;uniform float uScale;
 void main(){vC=pcol;vA=alpha;vec4 mv=modelViewMatrix*vec4(position,1.);gl_PointSize=clamp(size*uScale/-mv.z,1.,512.);gl_Position=projectionMatrix*mv;}`;
@@ -1149,7 +1156,14 @@ function createVfxRenderer(THREE, options) {
   const requested = options.vfx;
   const world = isWorld(requested) ? requested : createVfx({ profile: options.quality ?? "medium", reducedMotion, ...requested });
   const pools = world.pools();
-  const root = new THREE.Group();
+  let anchors;
+  const releaseAnchors = () => {
+    if (!anchors) return;
+    anchors.meshes[0]?.geometry.dispose();
+    for (const mesh of anchors.meshes) mesh.material.dispose();
+    anchors = void 0;
+  };
+  const root = markKitOrigin(new THREE.Group(), { owner: "game-vfx-three", kind: "effect" });
   options.scene.add(root);
   const direction = new THREE.Vector3(...options.lightDirection ?? LAB_LIGHT_DIRECTION).normalize();
   const sky = hexToLinearRgb(SKY_COLOR);
@@ -1265,6 +1279,16 @@ function createVfxRenderer(THREE, options) {
       syncAll();
       overlay?.update(screenNow());
     },
+    warmUpProbes() {
+      releaseAnchors();
+      const meshes = createMeshLayerProbes(THREE);
+      for (const mesh of meshes) mesh.frustumCulled = false;
+      const group = new THREE.Group();
+      group.add(...meshes);
+      anchors = { meshes, group };
+      return { group, dispose: () => {
+      } };
+    },
     applyCamera() {
       const shake = screenNow().shake;
       if (reducedMotion || !(shake > SHAKE_FLOOR)) return () => {
@@ -1283,6 +1307,7 @@ function createVfxRenderer(THREE, options) {
     },
     screen: screenNow,
     dispose() {
+      releaseAnchors();
       stopMarks();
       overlay?.dispose();
       workshopLayers?.dispose();
@@ -1556,6 +1581,11 @@ function createVfxTestModule(options = {}) {
     controls,
     layers,
     metrics,
+    // opening the effects area puts the camera at the bench view (the initial distance does not move it: that would take the player's view on load)
+    area: () => ({
+      placements: [],
+      view: { eye: eyeFor(DEFAULT_DISTANCE), target: [0, 1.2, 0] }
+    }),
     attach(host) {
       const bench = host.bench;
       let own;
@@ -1575,6 +1605,7 @@ function createVfxTestModule(options = {}) {
       let phase = 0;
       let handle = null;
       let sinceRepeat = 0;
+      let live = false;
       read = () => {
         const def = explosions[effect];
         const recipe = recipes[effect];
@@ -1613,7 +1644,7 @@ function createVfxTestModule(options = {}) {
           }
         );
         bench?.sheet?.(sheetFor(id));
-        replay();
+        if (live) replay();
       }
       function look() {
         const eye = eyeFor(distance);
@@ -1630,7 +1661,7 @@ function createVfxTestModule(options = {}) {
           choose(change.value);
         else if (change.id === "variant" && typeof change.value === "string") {
           variant = change.value;
-          if (recipes[effect]?.params) replay();
+          if (live && recipes[effect]?.params) replay();
         } else if (change.id === "auto_repeat") auto = change.value === true;
         else if (change.id === "distance" && typeof change.value === "number") {
           distance = change.value;
@@ -1640,6 +1671,7 @@ function createVfxTestModule(options = {}) {
       };
       const offChange = bench?.onChange(apply);
       const offFrame = host.onFrame((dt) => {
+        live = true;
         phase += dt;
         sinceRepeat += dt;
         own?.update(dt);