@adatechnology/game-vfx-three 0.1.3 → 0.2.1

package/dist/index.js

@@ -710,6 +710,75 @@ 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;}`;
@@ -788,6 +857,30 @@ function streakLayer(THREE, pool) {
     }
   };
 }
+function rainLayer(THREE, rain) {
+  const geometry = new THREE.BufferGeometry();
+  const position = new THREE.BufferAttribute(rain.positions, 3).setUsage(THREE.DynamicDrawUsage);
+  geometry.setAttribute("position", position);
+  geometry.setDrawRange(0, 0);
+  const material = new THREE.LineBasicMaterial({ color: 10466255, transparent: true, opacity: 0.35, depthWrite: false });
+  const lines = new THREE.LineSegments(geometry, material);
+  lines.frustumCulled = false;
+  lines.name = "workshop-rain";
+  return {
+    object: lines,
+    sync() {
+      const drawn = rain.on && rain.count > 0;
+      lines.visible = drawn;
+      geometry.setDrawRange(0, drawn ? rain.count * 2 : 0);
+      position.needsUpdate = true;
+      return drawn;
+    },
+    dispose() {
+      geometry.dispose();
+      material.dispose();
+    }
+  };
+}
 function debrisLayer(THREE, pool) {
   const geometry = new THREE.BoxGeometry(1, 1, 1);
   const material = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.45, metalness: 0.25, flatShading: true });
@@ -990,11 +1083,14 @@ function createWorkshopLayers(THREE, engine, pointScale, lightScale) {
     spriteLayer(THREE, engine.add, true, 1, pointScale),
     spriteLayer(THREE, engine.normal, false, 0.55, pointScale),
     streakLayer(THREE, engine.streaks),
+    rainLayer(THREE, engine.rain),
     debrisLayer(THREE, engine.debris),
     decalLayer(THREE, engine.decals),
     ringLayer(THREE, engine.rings)
   ];
   for (const layer2 of layers) group.add(layer2.object);
+  const meshes = createMeshLayer(THREE, engine.meshes);
+  group.add(meshes.group);
   const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
   const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
   for (const light of [...flashLights, ...fireLights]) group.add(light);
@@ -1003,6 +1099,7 @@ function createWorkshopLayers(THREE, engine, pointScale, lightScale) {
     sync() {
       let drawCalls = 0;
       for (const layer2 of layers) if (layer2.sync()) drawCalls++;
+      drawCalls += meshes.sync();
       engine.lights.lights.forEach((source, index) => {
         const light = flashLights[index];
         light.position.set(source.x, source.y, source.z);
@@ -1019,6 +1116,7 @@ function createWorkshopLayers(THREE, engine, pointScale, lightScale) {
     },
     dispose() {
       for (const layer2 of layers) layer2.dispose();
+      meshes.dispose();
       group.clear();
     }
   };
@@ -1137,8 +1235,10 @@ function createVfxRenderer(THREE, options) {
       return world.play(request.effect, request.point, {
         ...request.direction ? { direction: request.direction } : {},
         ...request.normal ? { normal: request.normal } : {},
+        ...request.orientation ? { orientation: request.orientation } : {},
         ...request.seed !== void 0 ? { seed: request.seed } : {},
-        ...request.param !== void 0 ? { param: request.param } : {}
+        ...request.param !== void 0 ? { param: request.param } : {},
+        ...request.values ? { values: request.values } : {}
       });
     },
     stop: (handle) => world.stop(handle),