@carbonenginejs/runtime-trinity 0.6.0 → 0.8.0

package/dist/eve/attachment/turrets/EveTurretSet.js

@@ -1,6 +1,6 @@
 import { identity as _identity, applyDecs2311 as _applyDecs2311 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import { io, type, carbon, impl, schema } from '@carbonenginejs/runtime-utils/schema';
-import { EveEntity as _EveEntity } from '../../../generated/eve/EveEntity.js';
+import { EveEntity as _EveEntity } from '../../EveEntity.js';
 import { EveComponentType } from '../../EveComponentTypes.js';
 import { EveTurretTarget as _EveTurretTarget } from './EveTurretTarget.js';
 import { mat4 } from '@carbonenginejs/runtime-utils/mat4';
@@ -8,7 +8,6 @@ import { quat } from '@carbonenginejs/runtime-utils/quat';
 import { vec3 } from '@carbonenginejs/runtime-utils/vec3';
 import { vec4 } from '@carbonenginejs/runtime-utils/vec4';
 import { Tr2RenderReason } from '../../../generated/trinityCore/enums.js';
-import { Tr2PerObjectData } from '../../../trinityCore/Tr2PerObjectData.js';
 import { Tr2RenderBatch } from '../../../trinityCore/Tr2RenderBatch.js';
 
 let _initProto, _initClass, _init_impactBehaviour, _init_extra_impactBehaviour, _init_firingEffect, _init_extra_firingEffect, _init_ambientEffect, _init_extra_ambientEffect, _init_name, _init_extra_name, _init_firingEffectResPath, _init_extra_firingEffectResPath, _init_chooseRandomLocator, _init_extra_chooseRandomLocator, _init_boundingSphere, _init_extra_boundingSphere, _init_randomizeExplosionRotation, _init_extra_randomizeExplosionRotation, _init_lodLevel, _init_extra_lodLevel, _init_currentCyclingFiresPos, _init_extra_currentCyclingFiresPos, _init_useRandomFiringDelay, _init_extra_useRandomFiringDelay, _init_bottomClipHeight, _init_extra_bottomClipHeight, _init_geometryResource, _init_extra_geometryResource, _init_maxTrackingTime, _init_extra_maxTrackingTime, _init_visibleCount, _init_extra_visibleCount, _init_trackingInfluence, _init_extra_trackingInfluence, _init_swarmID, _init_extra_swarmID, _init_maxCyclingFirePos, _init_extra_maxCyclingFirePos, _init_playMovementSound, _init_extra_playMovementSound, _init_isOnline, _init_extra_isOnline, _init_target, _init_extra_target, _init_locatorName, _init_extra_locatorName, _init_sysBonePitchFactor, _init_extra_sysBonePitchFactor, _init_sysBonePitchMax, _init_extra_sysBonePitchMax, _init_sysBonePitchMin, _init_extra_sysBonePitchMin, _init_sysBonePitchOffset, _init_extra_sysBonePitchOffset, _init_sysBonePitch01Factor, _init_extra_sysBonePitch01Factor, _init_sysBonePitch01Offset, _init_extra_sysBonePitch01Offset, _init_sysBonePitch02Factor, _init_extra_sysBonePitch02Factor, _init_sysBonePitch02Offset, _init_extra_sysBonePitch02Offset, _init_sysBonePitch03Factor, _init_extra_sysBonePitch03Factor, _init_sysBonePitch03Offset, _init_extra_sysBonePitch03Offset, _init_updatePitchPose, _init_extra_updatePitchPose, _init_geometryResPath, _init_extra_geometryResPath, _init_impactSize, _init_extra_impactSize, _init_state, _init_extra_state, _init_sysBoneHeight, _init_extra_sysBoneHeight, _init_randomFiringDelay, _init_extra_randomFiringDelay, _init_turretEffect, _init_extra_turretEffect, _init_idleToTargetingMovementAudioEvent, _init_extra_idleToTargetingMovementAudioEvent, _init_targetingToIdleMovementAudioEvent, _init_extra_targetingToIdleMovementAudioEvent, _init_generatedDistributedAmbientEffect, _init_extra_generatedDistributedAmbientEffect, _init_cyclingFireGroupCount, _init_extra_cyclingFireGroupCount, _init_turretMovementObserver, _init_extra_turretMovementObserver, _init_slotNumber, _init_extra_slotNumber, _init_ambientEffectEditingMode, _init_extra_ambientEffectEditingMode, _init_displayEffects, _init_extra_displayEffects, _init_display, _init_extra_display, _init_useDynamicBounds, _init_extra_useDynamicBounds, _init_estimatedPixelDiameter, _init_extra_estimatedPixelDiameter, _init_lowLodFiringEffectScale, _init_extra_lowLodFiringEffectScale, _init_lowLodFiringEffectTranslation, _init_extra_lowLodFiringEffectTranslation, _init_lowLodFiringEffectRotation, _init_extra_lowLodFiringEffectRotation, _init_useLowLodFiringTransform, _init_extra_useLowLodFiringTransform, _init_laserMissBehaviour, _init_extra_laserMissBehaviour, _init_projectileMissBehaviour, _init_extra_projectileMissBehaviour;
@@ -206,6 +205,29 @@ new class extends _identity {
     projectileMissBehaviour = (_init_extra_laserMissBehaviour(this), _init_projectileMissBehaviour(this, false));
     #turrets = (_init_extra_projectileMissBehaviour(this), []);
     #parentTransform = mat4.create();
+
+    /** m_shipTransformPrev - last frame's parent transform, for motion vectors. */
+    #shipTransformPrev = mat4.create();
+
+    /**
+     * m_parentData - the hull values an attachment renders with, refreshed by the
+     * parent through IEveSpaceObject2::GetParentData.
+     */
+    #parentData = {};
+
+    /**
+     * m_skeletonBoneIndices - the shader's bone mapping, shared by every turret
+     * of the set. Skeleton realization is engine-owned, so this stays empty until
+     * one is supplied and the default count applies.
+     */
+    #skeletonBoneIndices = [];
+
+    /** Default bones per turret when no skeleton mapping is present (cpp:2334). */
+
+    /** Tr2ShLightingManager::PACKED_COEFFICIENT_COUNT. */
+
+    /** Carbon's placeholder pose for a visible-but-invalid turret (cpp:2335-2336). */
+
     #activeTurret = _EveTurretSet.INVALID_INDEX;
     #highDetailFrozen = false;
     #trackingInfluenceDelta = 0;
@@ -418,6 +440,11 @@ new class extends _identity {
       this.firingEffect?.StartControllers?.();
       this.#ambientEffect()?.StartControllers?.();
     }
+
+    /**
+     * Creates the target when absent, pushes the authored miss and impact
+     * behaviour into it, and initializes the firing and ambient effects.
+     */
     Initialize() {
       this.target ??= new _EveTurretTarget();
       this.target.SetBehaviour?.(this.laserMissBehaviour, this.projectileMissBehaviour, this.impactSize, this.impactBehaviour);
@@ -425,10 +452,19 @@ new class extends _identity {
       this.#ambientEffect()?.Initialize?.();
       return true;
     }
+
+    /** Attaches the firing effect and initializes it immediately. */
     SetFiringEffect(effect) {
       this.firingEffect = effect ?? null;
       this.firingEffect?.Initialize?.();
     }
+
+    /**
+     * Offers an object to the target for validation; on acceptance it sends the
+     * idle-to-targeting movement audio event when coming from idle or switching
+     * targets, and rescales the firing effect to the new target's radius. Returns
+     * whether the object was accepted.
+     */
     SetTargetObject(object) {
       this.target ??= new _EveTurretTarget();
       const previous = this.target.GetTargetable?.();
@@ -441,17 +477,34 @@ new class extends _identity {
       }
       return accepted;
     }
+
+    /** The object currently being targeted, or null. */
     GetTargetObject() {
       return this.target?.GetTargetable?.() ?? null;
     }
+
+    /**
+     * Rescales the firing effect from the target's radius, passing -1 when there
+     * is no target.
+     */
     SetTargetScale() {
       this.firingEffect?.SetScaleByRadius?.(this.target?.GetRadius?.() ?? -1);
     }
+
+    /**
+     * Replaces the turret records, truncated to the fixed 24-turret limit,
+     * normalizing each into the record shape and resetting visibleCount.
+     */
     SetTurrets(turrets = []) {
       this.#turrets = Array.from(turrets).slice(0, _EveTurretSet.MAX_TURRETS_PER_SET).map(turret => this.#normalizeTurret(turret));
       this.visibleCount = this.#turrets.length;
       return this.#turrets;
     }
+
+    /**
+     * Appends one normalized turret record and returns it, or null once the fixed
+     * 24-turret limit is reached.
+     */
     AddTurret(turret) {
       if (this.#turrets.length >= _EveTurretSet.MAX_TURRETS_PER_SET) return null;
       const value = this.#normalizeTurret(turret);
@@ -459,6 +512,11 @@ new class extends _identity {
       this.visibleCount = this.#turrets.length;
       return value;
     }
+
+    /**
+     * The live turret record list; the records are mutated in place by
+     * UpdateTurretTransforms, so this is not a snapshot.
+     */
     GetTurrets() {
       return this.#turrets;
     }
@@ -485,10 +543,21 @@ new class extends _identity {
       this.visibleCount = this.#turrets.length;
       return true;
     }
+
+    /**
+     * Stores the hull transform and immediately recomputes every turret's world
+     * matrix from it.
+     */
     SetParentTransform(transform) {
       mat4.copy(this.#parentTransform, transform);
       this.UpdateTurretTransforms(transform);
     }
+
+    /**
+     * Recomputes each turret's world matrix as the parent transform applied to its
+     * local matrix and marks the record valid; defaults to the stored parent
+     * transform.
+     */
     UpdateTurretTransforms(parentTransform = this.#parentTransform) {
       mat4.copy(this.#parentTransform, parentTransform);
       for (const turret of this.#turrets) {
@@ -496,14 +565,31 @@ new class extends _identity {
         turret.valid = true;
       }
     }
+
+    /**
+     * The index of the turret whose world up axis points most directly at its
+     * nearest damage locator, or 0 when no valid turret is found.
+     */
     GetClosestTurret() {
       return this.#getClosestTurretAndLocator().turret;
     }
+
+    /**
+     * Convenience update that runs the synchronous then asynchronous phase against
+     * the stored parent transform.
+     */
     Update(context) {
       this.UpdateSyncronous(context);
       this.UpdateAsyncronous(context, this.#parentTransform);
       return true;
     }
+
+    /**
+     * Runs the synchronous phase: while a looping effect fires it re-picks the
+     * turret and locator every two seconds, then updates the firing effect, feeds
+     * the target the current muzzle start position, and updates the ambient effect
+     * and movement observer from the first turret.
+     */
     UpdateSyncronous(context, parentTransform = this.#parentTransform) {
       const deltaTime = Number(context?.GetDeltaT?.() ?? context?.deltaTime ?? context?.deltaT ?? 0);
       if (parentTransform?.length === 16) mat4.copy(this.#parentTransform, parentTransform);
@@ -528,10 +614,26 @@ new class extends _identity {
       if (this.#turrets.length) this.turretMovementObserver?.Update?.(this.#turrets[0].worldMatrix);
       return true;
     }
+
+    /**
+     * Runs the asynchronous phase: recomputes the turret world matrices, ramps the
+     * tracking influence through its fade-in and fade-out delays, pushes the
+     * target position into each valid turret's tracking pose in that turret's
+     * local space, then hands the firing effect its end position and per-muzzle
+     * world transforms.
+     */
     UpdateAsyncronous(context, parentData = this.#parentTransform) {
       const deltaTime = Number(context?.GetDeltaT?.() ?? context?.deltaTime ?? context?.deltaT ?? 0);
       const parentTransform = parentData?.transform?.length === 16 ? parentData.transform : parentData;
-      if (parentTransform?.length === 16) this.UpdateTurretTransforms(parentTransform);
+      if (parentTransform?.length === 16) {
+        // The OUTGOING parent transform becomes m_shipTransformPrev before the
+        // new one is adopted, so the record can carry both.
+        mat4.copy(this.#shipTransformPrev, this.#parentTransform);
+        this.UpdateTurretTransforms(parentTransform);
+      }
+      if (parentData && parentData !== this.#parentTransform && !ArrayBuffer.isView(parentData) && !Array.isArray(parentData)) {
+        this.#parentData = parentData;
+      }
       if (this.#trackingInfluenceDelta !== 0) {
         this.trackingInfluence += this.#trackingInfluenceDelta * deltaTime;
         if (this.trackingInfluence > this.maxTrackingTime) {
@@ -581,12 +683,23 @@ new class extends _identity {
       });
       return true;
     }
+
+    /**
+     * Appends the firing and ambient effect renderables to out; gated on display,
+     * and each contribution additionally on displayEffects.
+     */
     GetRenderables(out = []) {
       if (!this.display) return out;
       if (this.displayEffects) this.firingEffect?.GetRenderables?.(out);
       if (this.#ambientEffect() && this.displayEffects) this.#ambientEffect().GetRenderables?.(out);
       return out;
     }
+
+    /**
+     * Forwards visibility to the firing and ambient effects; gated on display and,
+     * per effect, on displayEffects. The turret geometry itself is not culled
+     * here.
+     */
     UpdateVisibility(context) {
       if (!this.display) return false;
       if (this.displayEffects) this.firingEffect?.UpdateVisibility?.(context);
@@ -691,12 +804,61 @@ new class extends _identity {
      * is GPU ring-buffer work; the GPU-free record carries the live object
      * reference for the engine serializer (EveChildMesh precedent). */
     GetPerObjectData(accumulator = null) {
-      if (!this.geometryResource) {
+      if (!this.geometryResource || typeof accumulator?.Alloc !== "function") {
         return null;
       }
-      const data = typeof accumulator?.Allocate === "function" ? accumulator.Allocate(Tr2PerObjectData) : new Tr2PerObjectData();
-      data.object = this;
-      return data;
+      const vs = accumulator.Alloc("EveTurretSetVSData");
+      const ps = accumulator.Alloc("EveTurretSetPSData");
+      const parent = this.#parentData;
+
+      // Carbon cpp:2305-2309.
+      vs.SetAndTranspose("shipMatrix", parent.transform ?? this.#parentTransform);
+      vs.SetAndTranspose("prevShipMatrix", this.#shipTransformPrev);
+      vs.Set("baseCutoffData", [this.bottomClipHeight, 0, 0, 0]);
+      if (this.#turrets.length) {
+        // The shader's bone-index mapping is shared by every turret of the set;
+        // three bones is Carbon's default when no skeleton mapping is present.
+        const boneCount = this.#skeletonBoneIndices.length || _EveTurretSet.DEFAULT_BONES_PER_TURRET;
+
+        // Only VISIBLE turrets consume a slot, and the array is filled densely -
+        // the unwritten tail deliberately keeps whatever the arena held
+        // (cpp:2322-2341).
+        let turretIndex = 0;
+        for (const turret of this.#turrets) {
+          // Carbon's SingleTurret::visible is this port's `display`.
+          if (turret.display === false) {
+            continue;
+          }
+          if (turret.valid) {
+            vs.SetIndex("turretRotation", turretIndex, turret.localQuaternion);
+            vs.SetIndex("turretTranslation", turretIndex, turret.localPosition);
+          } else {
+            vs.SetIndex("turretTranslation", turretIndex, _EveTurretSet.#invalidTranslation);
+            vs.SetIndex("turretRotation", turretIndex, _EveTurretSet.#invalidRotation);
+          }
+          turretIndex++;
+        }
+
+        // currentBoneOffset/prevBoneOffset are GPU ring addresses with no CPU
+        // derivation (cpp:2387-2388); they stay at their zero default.
+        vs.Set("turretSetData", [boneCount, 0, 0, 0]);
+
+        // ps data (cpp:2394-2404)
+        ps.Set("shipData", parent.shipData ?? _EveTurretSet.#zero4);
+        const clipCenter = parent.clipSphereCenter ?? _EveTurretSet.#zero4;
+        ps.Set("clipData1", [clipCenter[0], clipCenter[1], clipCenter[2], parent.clipRadiusSq ?? 0]);
+        ps.Set("clipRadius2Sq", [parent.clipRadius2Sq ?? 0]);
+
+        // The hull's coefficients when it published any, zeroes otherwise.
+        for (let index = 0; index < _EveTurretSet.SH_COEFFICIENT_COUNT; index++) {
+          const source = parent.shLighting ? parent.shLighting.subarray(index * 4, index * 4 + 4) : _EveTurretSet.#zero4;
+          ps.SetIndex("shLightingCoefficients", index, source);
+        }
+      }
+      return {
+        vs,
+        ps
+      };
     }
 
     /** Carbon EveTurretSet::GetShadowPerObjectData (cpp:2520-2523): pure
@@ -704,6 +866,14 @@ new class extends _identity {
     GetShadowPerObjectData(accumulator = null) {
       return this.GetPerObjectData(accumulator);
     }
+
+    /**
+     * Establishes everything one shot needs: the firing turret and locator, the
+     * advanced cycling fire position, the random firing delay, the fire animation
+     * on the chosen turret, the target's impact timing derived from the effect's
+     * duration and peak time, and the ambient controller's turret state. Returns
+     * false when deactivated or untargeted.
+     */
     #setupFiringState() {
       if (this.state === _EveTurretSet.State.STATE_DEACTIVE || !this.target) return false;
       const pair = this.#getClosestTurretAndLocator();
@@ -732,6 +902,13 @@ new class extends _identity {
       }
       return true;
     }
+
+    /**
+     * Picks the turret whose world up axis best aligns with its nearest damage
+     * locator and, when chooseRandomLocator is set, re-picks the turret against a
+     * random valid locator instead; falls back to turret 0. Returns the shared
+     * pair record, valid only until the next call.
+     */
     #getClosestTurretAndLocator() {
       const pair = _EveTurretSet.#closestPair;
       pair.turret = _EveTurretSet.INVALID_INDEX;
@@ -780,11 +957,22 @@ new class extends _identity {
       if (pair.turret === _EveTurretSet.INVALID_INDEX) pair.turret = 0;
       return pair;
     }
+
+    /**
+     * Plays an animation on every turret and returns the longest duration
+     * reported.
+     */
     #playAll(animation, loop, delay) {
       let duration = 0;
       for (let index = 0; index < this.#turrets.length; index++) duration = Math.max(duration, this.#playTurret(index, animation, loop, delay));
       return duration;
     }
+
+    /**
+     * Plays an animation on one turret through the record's own hook or its
+     * controller, returning the reported duration, or 0 when the turret or the
+     * hook is absent.
+     */
     #playTurret(index, animation, loop, delay) {
       const turret = this.#turrets[index];
       if (!turret) return 0;
@@ -793,12 +981,30 @@ new class extends _identity {
         delay
       }) ?? 0);
     }
+
+    /**
+     * The ambient effect in force: the authored one while in ambient-effect
+     * editing mode, otherwise the generated distributed instance container when
+     * one exists.
+     */
     #ambientEffect() {
       return this.ambientEffectEditingMode ? this.ambientEffect : this.generatedDistributedAmbientEffect ?? this.ambientEffect;
     }
+
+    /**
+     * Pushes the current state onto the ambient effect's TurretState controller
+     * variable.
+     */
     #setAmbientState() {
       this.#ambientEffect()?.SetControllerVariable?.("TurretState", this.state);
     }
+
+    /**
+     * Coerces a caller-supplied turret into the record shape - local and world
+     * matrices, local quaternion and position, valid and display flags - reusing
+     * the object in place when it already carries a local matrix, and otherwise
+     * wrapping it as the record's source.
+     */
     #normalizeTurret(turret) {
       if (turret?.localMatrix?.length === 16) {
         turret.worldMatrix ??= mat4.create();
@@ -821,6 +1027,11 @@ new class extends _identity {
       };
     }
   }];
+  DEFAULT_BONES_PER_TURRET = 3;
+  SH_COEFFICIENT_COUNT = 7;
+  #invalidTranslation = vec4.fromValues(0, 0, 0, 1);
+  #invalidRotation = quat.create();
+  #zero4 = vec4.create();
   ImpactBehaviour = Object.freeze({
     DAMAGE_LOCATOR: 0,
     SHIELD_ELLIPSOID: 1,
@@ -832,6 +1043,24 @@ new class extends _identity {
     LOD_HIGHEST: 2,
     LOD_DISABLED: 3
   });
+  SystemBones = Object.freeze({
+    SYSBONE_INVALID: 0,
+    SYSBONE_ROTATION: 1,
+    SYSBONE_ROTATION01: 2,
+    SYSBONE_ROTATION02: 3,
+    SYSBONE_COUNTER_ROTATION: 4,
+    SYSBONE_PITCH: 5,
+    SYSBONE_PITCH1: 6,
+    SYSBONE_PITCH2: 7,
+    SYSBONE_SCALED_HEIGHT: 8,
+    SYSBONE_SCALED_PITCH01: 9,
+    SYSBONE_SCALED_PITCH02: 10,
+    SYSBONE_SCALED_PITCH03: 11,
+    SYSBONE_SCALED_PITCH04: 12,
+    SYSBONE_SCALED_PITCH05: 13,
+    SYSBONE_SCALED_PITCH06: 14,
+    SYSBONE_MAX: 15
+  });
   State = Object.freeze({
     STATE_INVALID: 0,
     STATE_DEACTIVE: 1,