@woosh/meep-engine 2.33.57 → 2.33.61

package/engine/graphics/ecs/trail2d/makeGradientTrail.js

@@ -0,0 +1,68 @@
+import Trail2D, { Trail2DFlags } from "./Trail2D.js";
+import {
+    RIBBON_ATTRIBUTE_ADDRESS_AGE,
+    RIBBON_ATTRIBUTE_ADDRESS_COLOR,
+    RIBBON_ATTRIBUTE_ADDRESS_THICKNESS,
+    RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET
+} from "../../trail/x/ribbon_attributes_spec.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} color
+ * @param {number[]} thickness
+ * @param {number} [duration]
+ * @param {number} [scale]
+ * @param {number[]} position
+ * @param {number[]} ages
+ * @param {string} texture
+ * @returns {Trail2D}
+ */
+export function makeGradientTrail({
+                                      color,
+                                      thickness,
+                                      position,
+                                      duration = 1,
+                                      scale = 1,
+                                      ages,
+                                      texture
+                                  }) {
+
+    const trail2D = new Trail2D();
+    trail2D.maxAge = duration;
+    trail2D.width = 1;
+    trail2D.textureURL = texture;
+
+    const point_count = thickness.length;
+
+    trail2D.build(point_count);
+
+    const ribbon = trail2D.ribbon;
+
+    for (let i = 0; i < point_count; i++) {
+
+        const f = i / (point_count - 1);
+        const i3 = i * 3;
+
+        ribbon.setPointAlpha(i, 0);
+        ribbon.setPointPosition(i, position[i3], position[i3 + 1], position[i3 + 2]);
+
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_AGE, ages[i] * duration);
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET, f);
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_THICKNESS, thickness[i]);
+
+        const c_0 = color[i];
+
+        assert.isNumber(c_0, `color[i]`);
+
+        ribbon.setPointAttribute_Vector3(i, RIBBON_ATTRIBUTE_ADDRESS_COLOR, c_0 >> 16, c_0 >> 8, c_0);
+    }
+
+    // don't spawn more trail segments
+    trail2D.clearFlag(Trail2DFlags.Spawning);
+    trail2D.setFlag(Trail2DFlags.Built);
+
+    ribbon.computeBoundingBox(trail2D.bvhLeaf);
+
+    return trail2D;
+}

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -2,6 +2,7 @@ import { Cache } from "../../../../../core/cache/Cache.js";
 import { buildUnsorted } from "../../bvh/buffered/BinaryBVHFromBufferGeometry.js";
 import { ClippingPlaneContainmentComputingVisitor } from "./ClippingPlaneContainmentComputingVisitor.js";
 import { RaycastNearestHitComputingVisitor } from "./RaycastNearestHitComputingVisitor.js";
+import { assert } from "../../../../../core/assert.js";
 
 export class GeometrySpatialQueryAccelerator {
     constructor(cache_size = 100 * 1024 * 1024) {
@@ -38,6 +39,8 @@ export class GeometrySpatialQueryAccelerator {
      * @returns {number} -1,0,1. -1 means fully outside, 0 means partially inside, 1 means fully inside
      */
     queryContainmentViaClippingPlanes(geometry, planes) {
+        assert.notNull(geometry, 'geometry');
+        assert.defined(geometry, 'geometry');
 
         const bvh = this.__acquireBVH(geometry);
 
@@ -53,14 +56,25 @@ export class GeometrySpatialQueryAccelerator {
     }
 
     /**
-     * Get the nearest ray intersection
+     *
      * @param {SurfacePoint3} destination
      * @param {THREE.BufferGeometry} geometry
-     * @param {Vector3} ray_origin
-     * @param {Vector3} ray_direction
-     * @returns {boolean} true if hit detected, false otherwise
+     * @param {number} ray_origin_x
+     * @param {number} ray_origin_y
+     * @param {number} ray_origin_z
+     * @param {number} ray_direction_x
+     * @param {number} ray_direction_y
+     * @param {number} ray_direction_z
+     * @return {boolean}
      */
-    queryRaycastNearest(destination, geometry, ray_origin, ray_direction) {
+    queryRaycastNearest_primitive(
+        destination,
+        geometry,
+        ray_origin_x, ray_origin_y, ray_origin_z,
+        ray_direction_x, ray_direction_y, ray_direction_z
+    ) {
+        assert.notNull(geometry, 'geometry');
+        assert.defined(geometry, 'geometry');
 
         const bvh = this.__acquireBVH(geometry);
 
@@ -69,12 +83,12 @@ export class GeometrySpatialQueryAccelerator {
         this.__visitor_raycast.setGeometry(geometry);
         this.__visitor_raycast.setRoot(bvh);
         this.__visitor_raycast.setRay(
-            ray_origin.x,
-            ray_origin.y,
-            ray_origin.z,
-            ray_direction.x,
-            ray_direction.y,
-            ray_direction.z
+            ray_origin_x,
+            ray_origin_y,
+            ray_origin_z,
+            ray_direction_x,
+            ray_direction_y,
+            ray_direction_z
         );
 
         bvh.traversePreOrderStack(this.__visitor_raycast, 0);
@@ -87,6 +101,27 @@ export class GeometrySpatialQueryAccelerator {
         } else {
             return false;
         }
+    }
+
+    /**
+     * Get the nearest ray intersection
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {Vector3} ray_origin
+     * @param {Vector3} ray_direction
+     * @returns {boolean} true if hit detected, false otherwise
+     */
+    queryRaycastNearest(destination, geometry, ray_origin, ray_direction) {
+
+        return this.queryRaycastNearest_primitive(
+            destination, geometry,
+            ray_origin.x,
+            ray_origin.y,
+            ray_origin.z,
+            ray_direction.x,
+            ray_direction.y,
+            ray_direction.z
+        );
 
     }
 
@@ -96,6 +131,9 @@ export class GeometrySpatialQueryAccelerator {
      * @returns {IndexedBinaryBVH}
      */
     __acquireBVH(geometry) {
+        assert.notNull(geometry, 'geometry');
+        assert.defined(geometry, 'geometry');
+
         const existing = this.cache.get(geometry);
 
         if (existing !== null) {
@@ -122,3 +160,9 @@ export class GeometrySpatialQueryAccelerator {
     }
 
 }
+
+/**
+ * @readonly
+ * @type {GeometrySpatialQueryAccelerator}
+ */
+GeometrySpatialQueryAccelerator.INSTANCE = new GeometrySpatialQueryAccelerator();

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -3,12 +3,18 @@ import { computeGeometryHash } from "../../asset/loaders/geometry/geometry/compu
 import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
+import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
 
 /**
  *
  * @type {HashMap<THREE.BufferGeometry, MicronGeometry>}
  */
-const micron_cache = new HashMap({
+const default_micron_cache = new AsyncMapWrapper(new HashMap({
+    keyHashFunction: computeGeometryHash,
+    keyEqualityFunction: computeGeometryEquality
+}));
+
+const pending_cache = new HashMap({
     keyHashFunction: computeGeometryHash,
     keyEqualityFunction: computeGeometryEquality
 });
@@ -17,9 +23,10 @@ const micron_cache = new HashMap({
 /**
  *
  * @param {THREE.Object3D} object
+ * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} micron_cache
  * @returns {THREE.Object3D}
  */
-export async function convert_three_object_to_micron(object) {
+export async function convert_three_object_to_micron(object, micron_cache = default_micron_cache) {
 
     const promises = [];
 
@@ -29,19 +36,29 @@ export async function convert_three_object_to_micron(object) {
      * @returns {MicronGeometry}
      */
     async function obtain_geometry(g) {
-        const existing = micron_cache.get(g);
+        const existing = await micron_cache.get(g);
+
+        if (existing !== undefined && existing !== null) {
+            return existing;
+        }
+
+        const pending = pending_cache.get(g);
 
-        if (existing !== undefined) {
-            return await existing;
+        if (pending !== undefined) {
+            return await pending;
         }
 
         const micron_geometry_promise = buildMicronGeometryFromBufferGeometry(g);
 
-        micron_cache.set(g, micron_geometry_promise);
+        pending_cache.set(g, micron_geometry_promise);
 
         promises.push(micron_geometry_promise);
 
-        return await micron_geometry_promise;
+        const micron_geometry = await micron_geometry_promise;
+
+        await micron_cache.set(g, micron_geometry);
+
+        return micron_geometry;
     }
 
 

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -3,6 +3,57 @@ import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
 import { SOURCE_RENDER_LAYER_PROPERTY } from "../../render/visibility/VisibilityComputer.js";
+import { AssetTransformer } from "../../../asset/AssetTransformer.js";
+import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
+import { Cache } from "../../../../core/cache/Cache.js";
+import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { CachedAsyncMap } from "../../../../core/collection/map/CachedAsyncMap.js";
+import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteHashMap.js";
+import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
+import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+
+/**
+ *
+ * @type {string}
+ */
+const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
+
+
+class GLTFAssetTransformer extends AssetTransformer {
+    /**
+     *
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     */
+    constructor(cache) {
+        super();
+
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = cache;
+    }
+
+    async transform(source) {
+        const animationClips = source.animations;
+        if (animationClips !== undefined && animationClips.length > 0) {
+            // not suitable
+            return source;
+        }
+
+        const root = source.create();
+
+        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
+        micron_root.boundingSphere = root.boundingSphere;
+
+        source.override_mesh = micron_root;
+
+        return source;
+    }
+}
 
 export class MicronRenderPlugin extends EnginePlugin {
     constructor() {
@@ -37,6 +88,40 @@ export class MicronRenderPlugin extends EnginePlugin {
         });
 
         this.__view_observers = new Map();
+
+        /**
+         *
+         * @type {AsyncRemoteHashMap}
+         * @private
+         */
+        this.__persisted_geometry = new AsyncRemoteHashMap({
+            keyHashFunction: computeGeometryHash,
+            keyEqualityFunction: computeGeometryEquality,
+            keySerializationAdapter: new BufferGeometrySerializationAdapter(),
+            valueSerializationAdapter: new MicronGeometryBinarySerializationAdapter(),
+            storageKeyPrefix: STORAGE_KEY,
+
+        });
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = new CachedAsyncMap(
+            new AsyncMapWrapper(new Cache({
+                keyHashFunction: computeGeometryHash,
+                keyEqualityFunction: computeGeometryEquality
+            })),
+            this.__persisted_geometry
+        );
+
+        /**
+         *
+         * @type {AssetTransformer}
+         * @private
+         */
+        this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
+
     }
 
     /**
@@ -87,13 +172,22 @@ export class MicronRenderPlugin extends EnginePlugin {
         view.on.preRender.remove(observer);
     }
 
+    __ingest_cache() {
+        this.engine.storage.lo
+    }
+
     async startup() {
 
+        const engine = this.engine;
+
+        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
+        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+
         /**
          *
          * @type {GraphicsEngine}
          */
-        const ge = this.engine.graphics;
+        const ge = engine.graphics;
 
         ge.layers.add(this.__micron_render_layer);
 
@@ -101,13 +195,22 @@ export class MicronRenderPlugin extends EnginePlugin {
         ge.views.elements.on.removed.add(this.__handle_view_removed, this);
 
         // link all views
-        ge.views.elements.forEach(this.__handle_view_added,this);
+        ge.views.elements.forEach(this.__handle_view_added, this);
+
+        this.__persisted_geometry.attach_storage(engine.storage);
 
         await super.startup();
     }
 
     async shutdown() {
-        const ge = this.engine.graphics;
+        const engine = this.engine;
+
+        this.__persisted_geometry.detach_storage();
+
+        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
+        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        const ge = engine.graphics;
 
         ge.layers.remove(this.__micron_render_layer);
 
@@ -115,7 +218,7 @@ export class MicronRenderPlugin extends EnginePlugin {
         ge.views.elements.on.removed.remove(this.__handle_view_removed, this);
 
         // clear all observer
-        ge.views.elements.forEach(this.__handle_view_removed,this);
+        ge.views.elements.forEach(this.__handle_view_removed, this);
 
         await super.shutdown();
     }

package/engine/graphics/micron/plugin/serialization/BufferGeometrySerializationAdapter.js

@@ -0,0 +1,176 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { BufferAttribute, BufferGeometry } from "three";
+
+function typed_array_to_enum(array) {
+    if (array instanceof Uint8Array) {
+        return 0;
+    } else if (array instanceof Uint16Array) {
+        return 1;
+    } else if (array instanceof Uint32Array) {
+        return 2;
+    } else if (array instanceof Uint8Array) {
+        return 3;
+    } else if (array instanceof Uint16Array) {
+        return 4;
+    } else if (array instanceof Uint32Array) {
+        return 5;
+    } else if (array instanceof Float32Array) {
+        return 6;
+    } else if (array instanceof Float64Array) {
+        return 7;
+    } else {
+        throw new Error('Unsupported array type');
+    }
+}
+
+function marker_to_typed_array_constructor(marker) {
+    switch (marker) {
+        case 0:
+            return Uint8Array;
+        case 1:
+            return Uint16Array;
+        case 2:
+            return Uint32Array;
+        case 3:
+            return Int8Array;
+        case 4:
+            return Int16Array;
+        case 5:
+            return Int32Array;
+        case 6:
+            return Float32Array;
+        case 7:
+            return Float64Array;
+        default:
+            throw new Error('Unsupported marker');
+    }
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {Uint8Array|Float32Array|ArrayLike<number>} value
+ */
+function write_typed_array(buffer, value) {
+
+    buffer.writeUint8(typed_array_to_enum(value));
+    buffer.writeUintVar(value.byteLength);
+
+    const data = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    buffer.writeBytes(data, 0, value.byteLength);
+}
+
+function read_typed_array(buffer) {
+    const type_marker = buffer.readUint8();
+    const byte_length = buffer.readUintVar();
+
+    const array = new Uint8Array(byte_length);
+
+    buffer.readBytes(array, 0, byte_length);
+
+    // re-interpret bytes
+    const TypedArray = marker_to_typed_array_constructor(type_marker);
+
+    return new TypedArray(array.buffer, 0);
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {BufferAttribute} value
+ */
+function write_attribute(buffer, value) {
+    buffer.writeUTF8String(value.name);
+    buffer.writeUintVar(value.itemSize);
+    buffer.writeUint8(value.normalized ? 1 : 0);
+    buffer.writeUint32(value.usage);
+
+    write_typed_array(buffer, value.array);
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {BufferAttribute}
+ */
+function read_attribute(buffer) {
+    const name = buffer.readUTF8String();
+    const itemSize = buffer.readUintVar();
+    const normalized = buffer.readUint8() !== 0;
+    const usage = buffer.readUint32();
+
+    const array = read_typed_array(buffer);
+
+    const attribute = new BufferAttribute(array, itemSize, normalized);
+
+    attribute.usage = usage;
+    attribute.name = name;
+
+    return attribute;
+}
+
+export class BufferGeometrySerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = BufferGeometry;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {BufferGeometry} value
+     */
+    serialize(buffer, value) {
+        // write index if one exists
+        const index = value.getIndex();
+        if (index === null) {
+            buffer.writeUint8(0);
+        } else {
+            buffer.writeUint8(1);
+
+            write_attribute(buffer, index);
+        }
+
+        const attributes = value.attributes;
+        const attribute_keys = Object.keys(attributes);
+
+        const attribute_count = attribute_keys.length;
+        buffer.writeUintVar(attribute_count);
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_key = attribute_keys[i];
+
+            buffer.writeUTF8String(attribute_key);
+
+            const attribute = attributes[attribute_key];
+
+            write_attribute(buffer, attribute);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {BufferGeometry} value
+     */
+    deserialize(buffer, value) {
+        const index_flag = buffer.readUint8();
+
+        if (index_flag !== 0) {
+            value.setIndex(read_attribute(buffer));
+        } else {
+            value.setIndex(null);
+        }
+
+        const attribute_count = buffer.readUintVar();
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_key = buffer.readUTF8String();
+
+            const attribute = read_attribute(buffer);
+
+            value.setAttribute(attribute_key, attribute);
+        }
+    }
+}

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -82,6 +82,7 @@ export class MaterialContext {
 
         if (material[MATERIAL_FLAG] === undefined) {
             material.onBeforeCompile = composeCompile(this.material.onBeforeCompile, rewrite_material);
+            material.needsUpdate = true;
 
             material[MATERIAL_FLAG] = true;
             material[MATERIAL_VERTEX_DISPLACED] = true;

package/engine/graphics/particles/particular/engine/simulator/SimulationStepFixedPhysics.js

@@ -10,11 +10,26 @@ import {
 } from "../emitter/PARTICLE_ATTRIBUTES.js";
 import { update_parameters } from "./update_parameters.js";
 
-const velocity = [];
-const position = [];
+/**
+ * Common buffer for better memory layout
+ * @type {ArrayBuffer}
+ */
+const scratch_common_buffer = new ArrayBuffer(4 * 3 * 2);
+/**
+ *
+ * @type {Float32Array|number[]|vec3}
+ */
+const velocity = new Float32Array(scratch_common_buffer, 0, 3);
+
+/**
+ *
+ * @type {Float32Array|number[]|vec3}
+ */
+const position = new Float32Array(scratch_common_buffer, 3 * 4, 3);
 
 export class SimulationStepFixedPhysics extends AbstractSimulationStep {
     execute() {
+        let i = 0;
         const particles = this.particles;
         const timeDelta = this.timeDelta;
 
@@ -31,7 +46,7 @@ export class SimulationStepFixedPhysics extends AbstractSimulationStep {
          */
         const layers = emitter.layers.asArray();
 
-        for (let i = 0; i < liveParticleCount; i++) {
+        for (; i < liveParticleCount; i++) {
 
             const layer_position = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
 
@@ -70,6 +85,7 @@ export class SimulationStepFixedPhysics extends AbstractSimulationStep {
 
             particles.readAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, position);
 
+            // Verlet integration
             const p_x = position[0] + velocity[0] * timeDelta;
             const p_y = position[1] + velocity[1] * timeDelta;
             const p_z = position[2] + velocity[2] * timeDelta;

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.d.ts

@@ -19,6 +19,8 @@ export class ParticleVolume {
 
     from(args?: Args): void
 
+    fromJSON(json: any): void
+
     build(): void
 
     readonly attributes: Attributes

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -3,7 +3,6 @@ import { EngineConfiguration } from "../../../../../../EngineConfiguration.js";
 import GUIElementSystem from "../../../../../../ecs/gui/GUIElementSystem.js";
 import HeadsUpDisplaySystem from "../../../../../../ecs/gui/hud/HeadsUpDisplaySystem.js";
 import TagSystem from "../../../../../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../../../../../ecs/sockets/AttachmentSocketsSystem.js";
 import { AttachmentSystem } from "../../../../../../ecs/attachment/AttachmentSystem.js";
 import { SoundEmitterSystem } from "../../../../../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../../../../../sound/ecs/SoundControllerSystem.js";
@@ -99,7 +98,6 @@ function makeConfig(engine) {
 
     config.systems.push(
         new TagSystem(),
-        new AttachmentSocketsSystem(),
         new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),
@@ -132,6 +130,7 @@ function makeConfig(engine) {
 
     // Plugins
     config.addPlugin(MicronRenderPlugin);
+    config.addPlugin(AmbientOcclusionPostProcessEffect);
 
 
     // Knowledge
@@ -159,8 +158,6 @@ async function init(harness) {
     await engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
 
 
-    await engine.plugins.acquire(AmbientOcclusionPostProcessEffect);
-
     await harness.initialize();
 
     main(engine);

package/engine/graphics/render/buffer/buffers/prototypeNormalFrameBuffer.js

@@ -8,7 +8,6 @@ import PathFollowingSystem from "../../../../navigation/ecs/path_following/PathF
 import SteeringSystem from "../../../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../../../ecs/sockets/AttachmentSocketsSystem.js";
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
 import { SoundEmitterSystem } from "../../../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../../../sound/ecs/SoundControllerSystem.js";
@@ -93,7 +92,6 @@ function makeConfig(engine) {
         new SteeringSystem(),
         new MotionSystem(),
         new TagSystem(),
-        new AttachmentSocketsSystem(),
         new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),