@newkrok/three-particles 2.15.0 → 2.15.2

package/dist/index.d.ts

@@ -1801,6 +1801,12 @@ type ParticleSystemInstance = {
     trailAlphaAttr?: THREE.BufferAttribute;
     /** Trail geometry color attribute */
     trailColorAttr?: THREE.BufferAttribute;
+    /** Trail geometry next-position attribute (cached to avoid repeated getAttribute) */
+    trailNextAttr?: THREE.BufferAttribute;
+    /** Trail geometry half-width attribute (cached) */
+    trailHalfWidthAttr?: THREE.BufferAttribute;
+    /** Trail geometry UV attribute (cached) */
+    trailUVAttr?: THREE.BufferAttribute;
     /** Trail width curve function */
     trailWidthCurveFn?: CurveFunction;
     /** Trail opacity curve function */

package/dist/index.js

@@ -1171,6 +1171,10 @@ var _particleSystemId = 0;
 var createdParticleSystems = [];
 var _subEmitterPosition = new THREE4.Vector3();
 var _lastWorldPositionSnapshot = new THREE4.Vector3();
+var _localForceFieldPos = new THREE4.Vector3();
+var _localForceFieldDir = new THREE4.Vector3();
+var _inverseQuat = new THREE4.Quaternion();
+var _localForceFields = [];
 new THREE4.Vector3();
 new THREE4.Vector3();
 new THREE4.Vector3();
@@ -2148,6 +2152,9 @@ var createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, externalNow
   let trailPositionAttr;
   let trailAlphaAttr;
   let trailColorAttr;
+  let trailNextAttr;
+  let trailHalfWidthAttr;
+  let trailUVAttr;
   let trailIndexAttr;
   let trailWidthCurveFn;
   let trailOpacityCurveFn;
@@ -2187,15 +2194,15 @@ var createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, externalNow
     }
     trailPositionAttr = new THREE4.BufferAttribute(trailPositions, 3);
     trailPositionAttr.setUsage(THREE4.DynamicDrawUsage);
-    const trailNextAttr = new THREE4.BufferAttribute(trailNextPositions, 3);
+    trailNextAttr = new THREE4.BufferAttribute(trailNextPositions, 3);
     trailNextAttr.setUsage(THREE4.DynamicDrawUsage);
     trailAlphaAttr = new THREE4.BufferAttribute(trailAlphas, 1);
     trailAlphaAttr.setUsage(THREE4.DynamicDrawUsage);
     trailColorAttr = new THREE4.BufferAttribute(trailColors, 4);
     trailColorAttr.setUsage(THREE4.DynamicDrawUsage);
-    const trailHalfWidthAttr = new THREE4.BufferAttribute(trailHalfWidths, 1);
+    trailHalfWidthAttr = new THREE4.BufferAttribute(trailHalfWidths, 1);
     trailHalfWidthAttr.setUsage(THREE4.DynamicDrawUsage);
-    const trailUVAttr = new THREE4.BufferAttribute(trailUVs, 2);
+    trailUVAttr = new THREE4.BufferAttribute(trailUVs, 2);
     trailUVAttr.setUsage(THREE4.DynamicDrawUsage);
     trailIndexAttr = new THREE4.BufferAttribute(trailIndices, 1);
     trailGeometry.setAttribute("position", trailPositionAttr);
@@ -2377,6 +2384,9 @@ var createParticleSystem = (config = DEFAULT_PARTICLE_SYSTEM_CONFIG, externalNow
       trailPositionAttr,
       trailAlphaAttr,
       trailColorAttr,
+      trailNextAttr,
+      trailHalfWidthAttr,
+      trailUVAttr,
       trailWidthCurveFn,
       trailOpacityCurveFn,
       trailColorOverTrailFns,
@@ -2527,6 +2537,37 @@ var updateParticleSystemInstance = (props, { now, delta, elapsed }) => {
     );
     particleSystem.worldToLocal(gravityVelocity);
   }
+  if (hasForceFields) {
+    _inverseQuat.copy(worldQuaternion).invert();
+    _localForceFields.length = normalizedForceFields.length;
+    for (let i = 0; i < normalizedForceFields.length; i++) {
+      const src = normalizedForceFields[i];
+      let dst = _localForceFields[i];
+      if (!dst) {
+        dst = {
+          isActive: true,
+          type: "POINT" /* POINT */,
+          position: new THREE4.Vector3(),
+          direction: new THREE4.Vector3(),
+          strength: 0,
+          range: 0,
+          falloff: "LINEAR" /* LINEAR */
+        };
+        _localForceFields[i] = dst;
+      }
+      dst.isActive = src.isActive;
+      dst.type = src.type;
+      dst.strength = src.strength;
+      dst.range = src.range;
+      dst.falloff = src.falloff;
+      _localForceFieldPos.copy(src.position);
+      particleSystem.worldToLocal(_localForceFieldPos);
+      dst.position.copy(_localForceFieldPos);
+      _localForceFieldDir.copy(src.direction);
+      _localForceFieldDir.applyQuaternion(_inverseQuat);
+      dst.direction.copy(_localForceFieldDir);
+    }
+  }
   const creationTimes = generalData.creationTimes;
   const isActiveArr = ma.isActive.array;
   const startLifetimeArr = ma.startLifetime.array;
@@ -2554,7 +2595,7 @@ var updateParticleSystemInstance = (props, { now, delta, elapsed }) => {
         if (hasForceFields) {
           applyForceFields({
             particleSystemId: generalData.particleSystemId,
-            forceFields: normalizedForceFields,
+            forceFields: _localForceFields,
             velocity,
             positionArr,
             positionIndex: index * 3,
@@ -2774,13 +2815,16 @@ var updateTrailGeometry = (props, now) => {
     trailPositionAttr,
     trailAlphaAttr,
     trailColorAttr,
+    trailNextAttr: trailNextAttrCached,
+    trailHalfWidthAttr: trailHalfWidthAttrCached,
+    trailUVAttr: trailUVAttrCached,
     trailWidthCurveFn,
     trailOpacityCurveFn,
     trailColorOverTrailFns,
     trailConfig,
     mappedAttributes: ma
   } = props;
-  if (!trailPositionAttr || !trailAlphaAttr || !trailColorAttr || !trailWidthCurveFn || !trailOpacityCurveFn || !trailConfig || !generalData.positionHistory || !generalData.positionHistoryIndex || !generalData.positionHistoryCount)
+  if (!trailPositionAttr || !trailAlphaAttr || !trailColorAttr || !trailNextAttrCached || !trailHalfWidthAttrCached || !trailUVAttrCached || !trailWidthCurveFn || !trailOpacityCurveFn || !trailConfig || !generalData.positionHistory || !generalData.positionHistoryIndex || !generalData.positionHistoryCount)
     return;
   const trailLength = trailConfig.length;
   const positionHistory = generalData.positionHistory;
@@ -2806,10 +2850,9 @@ var updateTrailGeometry = (props, now) => {
   const trailPosArr = trailPositionAttr.array;
   const trailAlphaArr = trailAlphaAttr.array;
   const trailColorArr = trailColorAttr.array;
-  const trailMesh = props.trailMesh;
-  const trailNextArr = trailMesh.geometry.getAttribute("trailNext").array;
-  const trailUVArr = trailMesh.geometry.getAttribute("trailUV").array;
-  const trailHalfWidthArr = trailMesh.geometry.getAttribute("trailHalfWidth").array;
+  const trailNextArr = trailNextAttrCached.array;
+  const trailUVArr = trailUVAttrCached.array;
+  const trailHalfWidthArr = trailHalfWidthAttrCached.array;
   const verticesPerParticle = trailLength * 2;
   const creationTimesLength = generalData.creationTimes.length;
   let hasUpdates = false;
@@ -3038,6 +3081,13 @@ var updateTrailGeometry = (props, now) => {
           nx = finalPts[(s + 1) * 3];
           ny = finalPts[(s + 1) * 3 + 1];
           nz = finalPts[(s + 1) * 3 + 2];
+        } else if (finalCount >= 2) {
+          const prevX = finalPts[(s - 1) * 3];
+          const prevY = finalPts[(s - 1) * 3 + 1];
+          const prevZ = finalPts[(s - 1) * 3 + 2];
+          nx = hx + (hx - prevX);
+          ny = hy + (hy - prevY);
+          nz = hz + (hz - prevZ);
         } else {
           nx = hx;
           ny = hy + 1e-3;
@@ -3046,14 +3096,24 @@ var updateTrailGeometry = (props, now) => {
         const t = finalCount > 1 ? s / (finalCount - 1) : 0;
         let timeFade = 1;
         if (maxTime > 0 && sampleTimes && effectiveCount > 0) {
-          const rawS = useSmoothing ? Math.min(
-            Math.floor(s / Math.max(finalCount - 1, 1) * (rawCount - 1)),
-            rawCount - 1
-          ) : Math.min(s, rawCount - 1);
-          const sampleSlot = (historyIndex[index] - 1 - rawS + trailLength * 2) % trailLength;
           const sampleBase = index * trailLength;
-          const age = now - sampleTimes[sampleBase + sampleSlot];
-          timeFade = 1 - Math.min(age / maxTimeMs, 1);
+          if (useSmoothing && rawCount >= 2) {
+            const rawF = s / Math.max(finalCount - 1, 1) * (rawCount - 1);
+            const rawLo = Math.min(Math.floor(rawF), rawCount - 1);
+            const rawHi = Math.min(rawLo + 1, rawCount - 1);
+            const frac = rawF - rawLo;
+            const slotLo = (historyIndex[index] - 1 - rawLo + trailLength * 2) % trailLength;
+            const slotHi = (historyIndex[index] - 1 - rawHi + trailLength * 2) % trailLength;
+            const ageLo = now - sampleTimes[sampleBase + slotLo];
+            const ageHi = now - sampleTimes[sampleBase + slotHi];
+            const age = ageLo + (ageHi - ageLo) * frac;
+            timeFade = 1 - Math.min(age / maxTimeMs, 1);
+          } else {
+            const rawS = Math.min(s, rawCount - 1);
+            const sampleSlot = (historyIndex[index] - 1 - rawS + trailLength * 2) % trailLength;
+            const age = now - sampleTimes[sampleBase + sampleSlot];
+            timeFade = 1 - Math.min(age / maxTimeMs, 1);
+          }
         }
         const widthScale = trailWidthCurveFn(t);
         const opacityScale = trailOpacityCurveFn(t);
@@ -3286,16 +3346,34 @@ var updateTrailGeometry = (props, now) => {
         nx = _rawPoints[(s + 1) * 3];
         ny = _rawPoints[(s + 1) * 3 + 1];
         nz = _rawPoints[(s + 1) * 3 + 2];
+      } else if (filledCount >= 2) {
+        const prevX = _rawPoints[(s - 1) * 3];
+        const prevY = _rawPoints[(s - 1) * 3 + 1];
+        const prevZ = _rawPoints[(s - 1) * 3 + 2];
+        nx = ptx + (ptx - prevX);
+        ny = pty + (pty - prevY);
+        nz = ptz + (ptz - prevZ);
       } else {
         nx = ptx;
         ny = pty + 1e-3;
         nz = ptz;
       }
       const t = filledCount > 1 ? s / (filledCount - 1) : 0;
+      let ribbonTimeFade = 1;
+      if (maxTime > 0 && controlCount >= 2) {
+        const ctrlF = t * (controlCount - 1);
+        const ctrlLo = Math.min(Math.floor(ctrlF), controlCount - 1);
+        const ctrlHi = Math.min(ctrlLo + 1, controlCount - 1);
+        const frac = ctrlF - ctrlLo;
+        const ageLo = now - generalData.creationTimes[_ribbonIndices[ctrlLo]];
+        const ageHi = now - generalData.creationTimes[_ribbonIndices[ctrlHi]];
+        const age = ageLo + (ageHi - ageLo) * frac;
+        ribbonTimeFade = 1 - Math.min(age / maxTimeMs, 1);
+      }
       const widthScale = trailWidthCurveFn(t);
       const opacityScale = trailOpacityCurveFn(t);
       const halfWidth = trailConfig.width * widthScale * 0.5;
-      const alpha = leaderCa * opacityScale;
+      const alpha = leaderCa * opacityScale * ribbonTimeFade;
       const fr = trailColorOverTrailFns ? leaderCr * trailColorOverTrailFns.r(t) : leaderCr;
       const fg = trailColorOverTrailFns ? leaderCg * trailColorOverTrailFns.g(t) : leaderCg;
       const fb = trailColorOverTrailFns ? leaderCb * trailColorOverTrailFns.b(t) : leaderCb;
@@ -3325,6 +3403,55 @@ var updateTrailGeometry = (props, now) => {
         trailColorArr
       );
     }
+    if (useTwistPrevention && prevNormal && filledCount >= 2) {
+      const nIdx = leader * 3;
+      const tx = _rawPoints[3] - _rawPoints[0];
+      const ty = _rawPoints[4] - _rawPoints[1];
+      const tz = _rawPoints[5] - _rawPoints[2];
+      const tLen = Math.sqrt(tx * tx + ty * ty + tz * tz);
+      if (tLen > 1e-4) {
+        const ntx = tx / tLen;
+        const nty = ty / tLen;
+        const ntz = tz / tLen;
+        let upx = 0, upy = 1, upz = 0;
+        const dot = ntx * upx + nty * upy + ntz * upz;
+        if (Math.abs(dot) > 0.999) {
+          upx = 1;
+          upy = 0;
+          upz = 0;
+        }
+        let cnx = nty * upz - ntz * upy;
+        let cny = ntz * upx - ntx * upz;
+        let cnz = ntx * upy - nty * upx;
+        const cnLen = Math.sqrt(cnx * cnx + cny * cny + cnz * cnz);
+        if (cnLen > 1e-4) {
+          cnx /= cnLen;
+          cny /= cnLen;
+          cnz /= cnLen;
+        }
+        const prevNx = prevNormal[nIdx];
+        const prevNy = prevNormal[nIdx + 1];
+        const prevNz = prevNormal[nIdx + 2];
+        const hasPrev = prevNx !== 0 || prevNy !== 0 || prevNz !== 0;
+        if (hasPrev) {
+          const normalDot = cnx * prevNx + cny * prevNy + cnz * prevNz;
+          if (normalDot < 0) {
+            for (let s = 0; s < Math.min(filledCount, trailLength); s++) {
+              const aIdx = leaderVertBase + s * 2;
+              const hw = trailHalfWidthArr[aIdx];
+              trailHalfWidthArr[aIdx] = -hw;
+              trailHalfWidthArr[aIdx + 1] = -hw;
+            }
+            cnx = -cnx;
+            cny = -cny;
+            cnz = -cnz;
+          }
+        }
+        prevNormal[nIdx] = cnx;
+        prevNormal[nIdx + 1] = cny;
+        prevNormal[nIdx + 2] = cnz;
+      }
+    }
     for (let ri = 1; ri < _ribbonCount; ri++) {
       const pIdx = _ribbonIndices[ri];
       const pVertBase = pIdx * verticesPerParticle;
@@ -3355,18 +3482,9 @@ var updateTrailGeometry = (props, now) => {
     trailPositionAttr.needsUpdate = true;
     trailAlphaAttr.needsUpdate = true;
     trailColorAttr.needsUpdate = true;
-    const nextAttr = trailMesh.geometry.getAttribute(
-      "trailNext"
-    );
-    const hwAttr = trailMesh.geometry.getAttribute(
-      "trailHalfWidth"
-    );
-    nextAttr.needsUpdate = true;
-    hwAttr.needsUpdate = true;
-    const uvAttr = trailMesh.geometry.getAttribute(
-      "trailUV"
-    );
-    uvAttr.needsUpdate = true;
+    trailNextAttrCached.needsUpdate = true;
+    trailHalfWidthAttrCached.needsUpdate = true;
+    trailUVAttrCached.needsUpdate = true;
   }
 };
 var updateParticleSystems = (cycleData) => {