@directivegames/genesys.js 3.1.24

package/dist/src/utils/ThreeJsExtensions.js

@@ -0,0 +1,817 @@
+/**
+ * ThreeJsExtensions augments THREE.Object3D with convenience methods tailored for Genesys.
+ *
+ * Detailed explanation:
+ * - Adds transform setters and getters that operate in both local and world space without manual matrix math.
+ * - Provides tree traversal helpers to fetch objects by type and generates debug data for SceneGraph utilities.
+ * - Marks objects as hidden or transient using userData flags so the engine can skip them when needed.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import this file once near engine startup so the prototype methods are patched before any scenes are built.
+ * - Use `setWorldTransform` or `getWorldTransform` when synchronizing with physics or other global systems.
+ * - Avoid heavy per-frame allocations; reuse vectors or quaternions where possible when calling these methods.
+ */
+import * as THREE from 'three';
+import { SceneComponent } from '../components/SceneComponent.js';
+import { ClassRegistry } from '../systems/ClassRegistry.js';
+import { WorldSerializer } from '../systems/WorldSerialization.js';
+import { ensure } from '../utils/Utils.js';
+const tempPosition = new THREE.Vector3();
+const tempRotation = new THREE.Euler();
+const tempScale = new THREE.Vector3();
+const tempQuaternion = new THREE.Quaternion();
+/**
+ * Gets the World instance associated with this scene.
+ * The World reference is stored in userData for easy access.
+ */
+THREE.Scene.prototype.getWorld = function () {
+    return this.userData.world;
+};
+/**
+ * Associates a World instance with this scene.
+ * Used by the engine to track which World owns each scene.
+ */
+THREE.Scene.prototype.setWorld = function (world) {
+    this.userData.world = world;
+    return this;
+};
+// Define getter/setter properties for absolute transform flags
+Object.defineProperty(THREE.Object3D.prototype, 'useAbsolutePosition', {
+    get: function () {
+        return this.userData.useAbsolutePosition === true;
+    },
+    set: function (value) {
+        this.userData.useAbsolutePosition = value;
+    },
+    enumerable: true,
+    configurable: true
+});
+Object.defineProperty(THREE.Object3D.prototype, 'useAbsoluteRotation', {
+    get: function () {
+        return this.userData.useAbsoluteRotation === true;
+    },
+    set: function (value) {
+        this.userData.useAbsoluteRotation = value;
+    },
+    enumerable: true,
+    configurable: true
+});
+Object.defineProperty(THREE.Object3D.prototype, 'useAbsoluteScale', {
+    get: function () {
+        return this.userData.useAbsoluteScale === true;
+    },
+    set: function (value) {
+        this.userData.useAbsoluteScale = value;
+    },
+    enumerable: true,
+    configurable: true
+});
+function printMaterial(indent, material) {
+    let result = `${indent}- ${material.type}: '${material.name ?? 'unnamed'}'\n`;
+    for (const [key, value] of Object.entries(material)) {
+        if (value instanceof THREE.Texture) {
+            result += `${indent}  - ${key} (${ClassRegistry.getClassOrConstructorName(value)}): '${value.name ?? 'unnamed'}'\n`;
+            result += `${indent}    - Dimensions: ${value.width}x${value.height}x${value.depth}\n`;
+            // result += `${indent}    - Format: ${value.format}\n`;
+            // result += `${indent}    - Type: ${value.type}\n`;
+        }
+    }
+    return result;
+}
+/**
+ * Traverses up the parent hierarchy to find the Actor that owns this object.
+ * Components and other scene objects use this to access their owning Actor.
+ */
+THREE.Object3D.prototype.getActor = function () {
+    return this.parent?.getActor() ?? null;
+};
+/**
+ * Serializes this object using the WorldSerializer for saving/loading.
+ * Handles conversion to JSON-compatible format with proper class registration.
+ */
+THREE.Object3D.prototype.asExportedObject = function (includeDefaults) {
+    return WorldSerializer.exportObject(this, includeDefaults);
+};
+/**
+ * Generates a human-readable string representation of the object hierarchy.
+ * Useful for debugging scene structure and understanding parent-child relationships.
+ * Includes geometry and material information for meshes.
+ */
+THREE.Object3D.prototype.printHierarchy = function (depth = 0, printTransform = false) {
+    const indent = '  '.repeat(depth);
+    let result = `${indent}${this.type}: '${this.name ?? 'unnamed'}'\n`;
+    if (printTransform) {
+        result += `${indent}  - Position: (${this.position.x.toFixed(2)}, ${this.position.y.toFixed(2)}, ${this.position.z.toFixed(2)})\n`;
+        result += `${indent}  - Rotation: (${this.rotation.x.toFixed(2)}, ${this.rotation.y.toFixed(2)}, ${this.rotation.z.toFixed(2)})\n`;
+        result += `${indent}  - Scale: (${this.scale.x.toFixed(2)}, ${this.scale.y.toFixed(2)}, ${this.scale.z.toFixed(2)})\n`;
+    }
+    if (this instanceof THREE.Mesh) {
+        result += `${indent}  - ${this.geometry.type}: '${this.geometry.name ?? 'unnamed'}'\n`;
+        result += `${indent}  - Vertices: ${this.geometry.attributes.position?.count ?? 0}\n`;
+        if (this.material) {
+            const materialIndent = indent + '  ';
+            if (Array.isArray(this.material)) {
+                this.material.forEach(m => result += printMaterial(materialIndent, m));
+            }
+            else {
+                result += printMaterial(materialIndent, this.material);
+            }
+        }
+    }
+    this.children.forEach(child => result += child.printHierarchy(depth + 1, printTransform));
+    return result;
+};
+/**
+ * Builds a dot-separated path string representing this object's location in the hierarchy.
+ * Example: "PlayerActor.RootComponent.MeshComponent"
+ * Used for debugging and logging to identify specific objects.
+ */
+THREE.Object3D.prototype.getPathName = function () {
+    const myName = this.name || ClassRegistry.getClassOrConstructorName(this);
+    if (this.parent) {
+        return `${this.parent.getPathName()}.${myName}`;
+    }
+    else {
+        return myName;
+    }
+};
+/**
+ * Creates a debug data structure for scene graph visualization tools.
+ * Recursively processes all children to build a complete tree representation.
+ * Includes transform data, visibility state, and UUIDs for debugging.
+ */
+THREE.Object3D.prototype.generateDebugNode = function () {
+    const myName = this.name || ClassRegistry.getClassOrConstructorName(this);
+    const children = [];
+    this.children.forEach((child) => {
+        children.push(child.generateDebugNode());
+    });
+    return {
+        title: myName,
+        children,
+        data: {
+            uuid: this.uuid,
+            position: this.position.toArray(),
+            rotation: this.rotation.toArray(),
+            scale: this.scale.toArray(),
+            visible: this.visible,
+        }
+    };
+};
+/**
+ * Searches for the first object of the specified type in this subtree.
+ * Uses depth-first search, checking this object first then its children.
+ * Commonly used to find specific component types within an actor.
+ */
+THREE.Object3D.prototype.getComponent = function (type = SceneComponent) {
+    if (this instanceof type) {
+        return this;
+    }
+    for (const child of this.children) {
+        const result = child.getComponent(type);
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+};
+/**
+ * Collects all objects of the specified type in this subtree.
+ * Recursively searches the entire hierarchy including this object.
+ * Returns an array that may be empty if no matches are found.
+ */
+THREE.Object3D.prototype.getComponents = function (type = SceneComponent) {
+    const results = [];
+    if (this instanceof type) {
+        results.push(this);
+    }
+    for (const child of this.children) {
+        results.push(...child.getComponents(type));
+    }
+    return results;
+};
+/**
+ * Convenience method to check if this object is hidden.
+ * Simply returns the inverse of the visible property.
+ */
+THREE.Object3D.prototype.isHidden = function () {
+    return !this.visible;
+};
+/**
+ * Sets the visibility of this object and optionally all its descendants.
+ * Useful for hiding entire branches of the scene graph at once.
+ */
+THREE.Object3D.prototype.setHidden = function (hidden, propagateToChildren = false) {
+    this.visible = !hidden;
+    if (propagateToChildren) {
+        this.children.forEach(child => {
+            child.setHidden(hidden, propagateToChildren);
+        });
+    }
+    return this;
+};
+/**
+ * Adds a position offset in local space.
+ * Directly modifies the position property without matrix calculations.
+ */
+THREE.Object3D.prototype.addLocalPosition = function (delta) {
+    this.position.x += delta.x;
+    this.position.y += delta.y;
+    this.position.z += delta.z;
+    return this;
+};
+/**
+ * Adds a rotation offset in local space.
+ * Converts Euler angles to quaternion and multiplies with current rotation.
+ */
+THREE.Object3D.prototype.addLocalRotation = function (delta) {
+    this.quaternion.multiply(new THREE.Quaternion().setFromEuler(delta));
+    return this;
+};
+/**
+ * Sets the local position relative to the parent.
+ * If useAbsolutePosition is true, interprets as world position.
+ */
+THREE.Object3D.prototype.setLocalPosition = function (pos) {
+    this.position.copy(pos);
+    return this;
+};
+/**
+ * Sets the local rotation using Euler angles.
+ * If useAbsoluteRotation is true, interprets as world rotation.
+ */
+THREE.Object3D.prototype.setLocalRotation = function (rot) {
+    this.quaternion.setFromEuler(rot);
+    return this;
+};
+/**
+ * Sets the local rotation using a quaternion.
+ * If useAbsoluteRotation is true, interprets as world rotation.
+ */
+THREE.Object3D.prototype.setLocalQuaternion = function (quaternion) {
+    this.quaternion.copy(quaternion);
+    return this;
+};
+/**
+ * Sets the local scale relative to the parent.
+ * If useAbsoluteScale is true, interprets as world scale.
+ */
+THREE.Object3D.prototype.setLocalScale = function (scale) {
+    this.scale.copy(scale);
+    return this;
+};
+/**
+ * Sets multiple transform properties at once in local space.
+ * Only modifies the properties that are provided in the transform object.
+ */
+THREE.Object3D.prototype.setLocalTransform = function (transform) {
+    if (transform.position) {
+        this.setLocalPosition(transform.position);
+    }
+    if (transform.rotation) {
+        this.setLocalRotation(transform.rotation);
+    }
+    if (transform.scale) {
+        this.setLocalScale(transform.scale);
+    }
+    return this;
+};
+/**
+ * Sets the position in world space, automatically converting to local space if parented.
+ * Handles the matrix math to transform from world to local coordinates.
+ */
+THREE.Object3D.prototype.setWorldPosition = function (pos) {
+    if (this.useAbsolutePosition) {
+        // When using absolute position, store world position directly
+        this.position.copy(pos);
+    }
+    else if (this.parent) {
+        // Convert the world position to local position
+        const localPos = pos.clone();
+        // Get the parent's world matrix inverse to convert to local space
+        const parentWorldMatrixInverse = new THREE.Matrix4();
+        parentWorldMatrixInverse.copy(this.parent.matrixWorld).invert();
+        // Apply the inverse matrix to get local position
+        localPos.applyMatrix4(parentWorldMatrixInverse);
+        // Set the local position
+        this.position.copy(localPos);
+    }
+    else {
+        this.setLocalPosition(pos);
+    }
+    return this;
+};
+/**
+ * Sets the rotation in world space using Euler angles.
+ * Internally converts to quaternion and delegates to setWorldQuaternion.
+ */
+THREE.Object3D.prototype.setWorldRotation = function (rot) {
+    this.setWorldQuaternion(new THREE.Quaternion().setFromEuler(rot));
+    return this;
+};
+/**
+ * Sets the rotation in world space using a quaternion.
+ * Calculates the required local rotation to achieve the desired world rotation.
+ */
+THREE.Object3D.prototype.setWorldQuaternion = function (quaternion) {
+    if (this.useAbsoluteRotation) {
+        // When using absolute rotation, store world rotation directly
+        this.quaternion.copy(quaternion);
+    }
+    else if (this.parent) {
+        // Get the parent's world quaternion
+        const parentWorldQuat = new THREE.Quaternion();
+        this.parent.getWorldQuaternion(parentWorldQuat);
+        // Invert parent's world quaternion
+        parentWorldQuat.invert();
+        // Calculate local quaternion by multiplying world quaternion by inverted parent quaternion
+        const localQuaternion = quaternion.clone().premultiply(parentWorldQuat);
+        // Set the local quaternion
+        this.quaternion.copy(localQuaternion);
+    }
+    else {
+        this.setLocalQuaternion(quaternion);
+    }
+    return this;
+};
+/**
+ * Sets the scale in world space, compensating for parent scaling.
+ * Calculates the local scale needed to achieve the desired world scale.
+ */
+THREE.Object3D.prototype.setWorldScale = function (scale) {
+    if (this.useAbsoluteScale) {
+        // When using absolute scale, store world scale directly
+        this.scale.copy(scale);
+    }
+    else if (this.parent) {
+        const parentWorldScale = new THREE.Vector3();
+        this.parent.getWorldScale(parentWorldScale);
+        this.scale.set(scale.x / parentWorldScale.x, scale.y / parentWorldScale.y, scale.z / parentWorldScale.z);
+    }
+    else {
+        this.setLocalScale(scale);
+    }
+    return this;
+};
+/**
+ * Sets multiple transform properties at once in world space.
+ * Delegates to individual world setters for each provided property.
+ */
+THREE.Object3D.prototype.setWorldTransform = function (transform) {
+    if (transform.position) {
+        this.setWorldPosition(transform.position);
+    }
+    if (transform.rotation) {
+        this.setWorldRotation(transform.rotation);
+    }
+    if (transform.scale) {
+        this.setWorldScale(transform.scale);
+    }
+    return this;
+};
+/**
+ * Adds a position offset in world space.
+ * Transforms the world delta to local space before applying.
+ */
+THREE.Object3D.prototype.addWorldPosition = function (delta) {
+    if (this.useAbsolutePosition) {
+        // When using absolute position, position is already in world space
+        this.position.add(delta);
+    }
+    else if (this.parent) {
+        this.updateMatrixWorld(true);
+        // Convert the delta from world space to local space
+        // We need to transform the direction only, not apply the full matrix
+        const worldDelta = delta.clone();
+        // Get parent's world rotation and scale to transform the delta
+        const parentWorldQuat = new THREE.Quaternion();
+        const parentWorldScale = new THREE.Vector3();
+        const parentWorldPos = new THREE.Vector3();
+        this.parent.matrixWorld.decompose(parentWorldPos, parentWorldQuat, parentWorldScale);
+        // Apply inverse scale
+        worldDelta.divide(parentWorldScale);
+        // Apply inverse rotation
+        parentWorldQuat.invert();
+        worldDelta.applyQuaternion(parentWorldQuat);
+        // Apply the local translation
+        this.position.add(worldDelta);
+    }
+    else {
+        this.addLocalPosition(delta);
+    }
+    return this;
+};
+/**
+ * Adds a rotation offset in world space.
+ * Applies the rotation in world coordinates then converts back to local.
+ */
+THREE.Object3D.prototype.addWorldRotation = function (delta) {
+    if (this.useAbsoluteRotation) {
+        // When using absolute rotation, quaternion is already in world space
+        const deltaQuat = new THREE.Quaternion().setFromEuler(delta);
+        this.quaternion.premultiply(deltaQuat);
+    }
+    else if (this.parent) {
+        this.updateMatrixWorld(true);
+        const currentWorldQuat = new THREE.Quaternion();
+        this.getWorldQuaternion(currentWorldQuat);
+        currentWorldQuat.premultiply(new THREE.Quaternion().setFromEuler(delta));
+        const parentWorldQuat = new THREE.Quaternion();
+        this.parent.getWorldQuaternion(parentWorldQuat);
+        parentWorldQuat.invert();
+        this.quaternion.copy(currentWorldQuat.premultiply(parentWorldQuat));
+    }
+    else {
+        this.addLocalRotation(delta);
+    }
+    return this;
+};
+/**
+ * Gets all world transform components as a single object.
+ * Convenient for getting position, rotation, and scale in one call.
+ */
+THREE.Object3D.prototype.getWorldTransform = function () {
+    return {
+        position: this.getWorldPosition(),
+        rotation: this.getWorldRotation(),
+        scale: this.getWorldScale(),
+    };
+};
+/**
+ * Gets the world position, extracting it from the world matrix.
+ * Updates world matrix if needed to ensure accuracy.
+ */
+THREE.Object3D.prototype.getWorldPosition = function (target) {
+    target ??= new THREE.Vector3();
+    // For absolute position, just return the position directly
+    if (this.useAbsolutePosition) {
+        return target.copy(this.position);
+    }
+    this.updateWorldMatrix(true, false);
+    return target.setFromMatrixPosition(this.matrixWorld);
+};
+/**
+ * Gets the world rotation as Euler angles.
+ * Internally gets world quaternion and converts to Euler.
+ */
+THREE.Object3D.prototype.getWorldRotation = function (target) {
+    target ??= new THREE.Euler();
+    // For absolute rotation, convert quaternion to Euler directly
+    if (this.useAbsoluteRotation) {
+        return target.setFromQuaternion(this.quaternion);
+    }
+    return target.setFromQuaternion(this.getWorldQuaternion());
+};
+/**
+ * Gets the world scale by decomposing the world matrix.
+ * Extracts scale component from the transformation matrix.
+ */
+THREE.Object3D.prototype.getWorldScale = function (target) {
+    target ??= new THREE.Vector3();
+    // For absolute scale, just return the scale directly
+    if (this.useAbsoluteScale) {
+        return target.copy(this.scale);
+    }
+    this.updateWorldMatrix(true, false);
+    this.matrixWorld.decompose(tempPosition, tempQuaternion, target);
+    return target;
+};
+/**
+ * Gets the world rotation as a quaternion by decomposing the world matrix.
+ * More precise than Euler angles for rotation calculations.
+ */
+THREE.Object3D.prototype.getWorldQuaternion = function (target) {
+    target ??= new THREE.Quaternion();
+    // For absolute rotation, just return the quaternion directly
+    if (this.useAbsoluteRotation) {
+        return target.copy(this.quaternion);
+    }
+    this.updateWorldMatrix(true, false);
+    this.matrixWorld.decompose(tempPosition, target, tempScale);
+    return target;
+};
+/**
+ * Checks if this object is marked as transient (temporary/non-persistent).
+ * Transient objects are excluded from world serialization.
+ */
+THREE.Object3D.prototype.isTransient = function () {
+    // Object3D is serialized as scene graph so if the parent is transient then the children won't be serialized
+    // effectively making them transient as well
+    return this.userData.isTransient ?? this.parent?.isTransient() ?? false;
+};
+/**
+ * Marks this object as transient or persistent.
+ * Transient flag is stored in userData to persist across operations.
+ */
+THREE.Object3D.prototype.setTransient = function (transient) {
+    this.userData.isTransient = transient;
+    return this;
+};
+/**
+ * Returns a description of this object for UI/debugging purposes.
+ * Base implementation returns empty object; components override for custom descriptions.
+ */
+THREE.Object3D.prototype.describe = function (options) {
+    return {};
+};
+/**
+ * Temporarily overrides materials for visual effects (e.g., highlighting).
+ * Base implementation just propagates to children; Mesh overrides to actually swap materials.
+ */
+THREE.Object3D.prototype.setOverrideMaterial = function (material, recursive) {
+    if (recursive) {
+        this.children.forEach(child => child.setOverrideMaterial(material, true));
+    }
+    return this;
+};
+/**
+ * Called when entering play mode, propagates to all children.
+ * Components override this to initialize gameplay logic.
+ */
+THREE.Object3D.prototype.beginPlay = function () {
+    this.children.forEach(child => child.beginPlay());
+};
+/**
+ * Called when exiting play mode, propagates to all children.
+ * Components override this to clean up gameplay resources.
+ */
+THREE.Object3D.prototype.endPlay = function () {
+    this.children.forEach(child => child.endPlay());
+};
+/**
+ * Update called before physics simulation each frame.
+ * Components override this for pre-physics updates like input handling.
+ */
+THREE.Object3D.prototype.tickPrePhysics = function (deltaTime) {
+    this.children.forEach(child => child.tickPrePhysics(deltaTime));
+};
+/**
+ * Update called after physics simulation each frame.
+ * Components override this for post-physics updates like visual synchronization.
+ */
+THREE.Object3D.prototype.tickPostPhysics = function (deltaTime) {
+    this.children.forEach(child => child.tickPostPhysics(deltaTime));
+};
+/**
+ * Updates physics configuration for this object and optionally its children.
+ * Components with physics override this to actually update their physics bodies.
+ */
+THREE.Object3D.prototype.replacePhysicsOptions = function (newOptions, propagateToChildren = false) {
+    if (propagateToChildren) {
+        this.children.forEach(child => child.replacePhysicsOptions(newOptions, true));
+    }
+    return this;
+};
+/**
+ * Overrides the physics options for this object and optionally its children.
+ * @param newOptions The new physics configuration
+ * @param propagateToChildren Whether to apply to all descendants
+ */
+THREE.Object3D.prototype.overridePhysicsOptions = function (newOptions, propagateToChildren = false) {
+    if (propagateToChildren) {
+        this.children.forEach(child => child.overridePhysicsOptions(newOptions, true));
+    }
+    return this;
+};
+// Override add method to handle lifecycle events
+/**
+ * Extended add method that automatically calls beginPlay on added objects
+ * if they're being added to an active (playing) actor.
+ */
+const originalAdd = THREE.Object3D.prototype.add;
+THREE.Object3D.prototype.add = function (...objects) {
+    const actor = this.getActor();
+    if (actor) {
+        if (!ensure(!actor.isPlayEnded())) {
+            return this;
+        }
+    }
+    originalAdd.call(this, ...objects);
+    if (actor?.isPlaying()) {
+        objects.forEach(obj => obj.beginPlay());
+    }
+    return this;
+};
+// Override remove method to handle lifecycle events
+/**
+ * Extended remove method that automatically calls endPlay on removed objects
+ * if they're being removed from an active (playing) actor.
+ */
+const originalRemove = THREE.Object3D.prototype.remove;
+THREE.Object3D.prototype.remove = function (...objects) {
+    const actor = this.getActor();
+    if (actor) {
+        if (!ensure(!actor.isPlayEnded())) {
+            return this;
+        }
+    }
+    originalRemove.call(this, ...objects);
+    if (actor?.isPlaying()) {
+        objects.forEach(obj => obj.endPlay());
+    }
+    return this;
+};
+/**
+ * Mesh-specific override material implementation.
+ * Saves the original material and swaps it with the override, or restores the original.
+ */
+THREE.Mesh.prototype.setOverrideMaterial = function (material, recursive) {
+    if (material) {
+        this.userData.__savedMaterial__ = this.material;
+        this.material = material;
+    }
+    else {
+        const savedMaterial = this.userData.__savedMaterial__;
+        if (savedMaterial) {
+            this.material = savedMaterial;
+        }
+    }
+    THREE.Object3D.prototype.setOverrideMaterial.call(this, material, recursive);
+    return this;
+};
+/**
+ * Serializes this material for saving/loading.
+ * Uses the WorldSerializer to handle material-specific properties.
+ */
+THREE.Material.prototype.asExportedObject = function (includeDefaults) {
+    return WorldSerializer.exportObject(this, includeDefaults);
+};
+/**
+ * Checks if two vectors are approximately equal within a tolerance.
+ * Useful for comparing positions/scales where floating point precision matters.
+ */
+THREE.Vector3.prototype.almostEquals = function (other, epsilon = 0.00001) {
+    epsilon ??= 0.00001;
+    return Math.abs(this.x - other.x) < epsilon &&
+        Math.abs(this.y - other.y) < epsilon &&
+        Math.abs(this.z - other.z) < epsilon;
+};
+/**
+ * Checks if two Euler rotations are approximately equal within a tolerance.
+ * Useful for comparing rotations where floating point precision matters.
+ * Note: Compares raw angles, doesn't account for equivalent rotations.
+ */
+THREE.Euler.prototype.almostEquals = function (other, epsilon = 0.00001) {
+    epsilon ??= 0.00001;
+    return Math.abs(this.x - other.x) < epsilon &&
+        Math.abs(this.y - other.y) < epsilon &&
+        Math.abs(this.z - other.z) < epsilon;
+};
+// Store the original updateMatrixWorld method
+const originalUpdateMatrixWorld = THREE.Object3D.prototype.updateMatrixWorld;
+const originalUpdateWorldMatrix = THREE.Object3D.prototype.updateWorldMatrix;
+/**
+ * Override updateWorldMatrix to handle absolute transform properties.
+ * This method is called by getWorldPosition/Rotation/Scale and needs to respect absolute transforms.
+
+======================== Default Implementation ========================
+
+updateWorldMatrix( updateParents, updateChildren ) {
+  const parent = this.parent;
+  if ( updateParents === true && parent !== null ) {
+    parent.updateWorldMatrix( true, false );
+  }
+
+  if ( this.matrixAutoUpdate ) this.updateMatrix();
+
+  if ( this.matrixWorldAutoUpdate === true ) {
+    if ( this.parent === null ) {
+      this.matrixWorld.copy( this.matrix );
+    } else {
+      this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
+    }
+  }
+
+  // make sure descendants are updated
+
+  if ( updateChildren === true ) {
+    const children = this.children;
+    for ( let i = 0, l = children.length; i < l; i ++ ) {
+      const child = children[ i ];
+      child.updateWorldMatrix( false, true );
+    }
+  }
+}
+*/
+THREE.Object3D.prototype.updateWorldMatrix = function (updateParents, updateChildren) {
+    const parent = this.parent;
+    if (updateParents && parent) {
+        parent.updateWorldMatrix(true, false);
+    }
+    if (this.matrixAutoUpdate) {
+        this.updateMatrix();
+    }
+    if (this.matrixWorldAutoUpdate) {
+        calculateMatrixWorld(this);
+    }
+    if (updateChildren) {
+        for (const child of this.children) {
+            child.updateWorldMatrix(false, true);
+        }
+    }
+};
+/**
+ * Override updateMatrixWorld to handle absolute transform properties.
+ * When useAbsolutePosition/Rotation/Scale are true, the object maintains
+ * its world transform regardless of parent transformations.
+
+======================== Default Implementation ========================
+
+updateMatrixWorld( force ) {
+  if ( this.matrixAutoUpdate ) this.updateMatrix();
+  if ( this.matrixWorldNeedsUpdate || force ) {
+    if ( this.matrixWorldAutoUpdate === true ) {
+      if ( this.parent === null ) {
+        this.matrixWorld.copy( this.matrix );
+      } else {
+        this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
+      }
+    }
+
+    this.matrixWorldNeedsUpdate = false;
+    force = true;
+  }
+
+  // make sure descendants are updated if required
+
+  const children = this.children;
+
+  for ( let i = 0, l = children.length; i < l; i ++ ) {
+    const child = children[ i ];
+    child.updateMatrixWorld( force );
+  }
+}
+*/
+THREE.Object3D.prototype.updateMatrixWorld = function (force) {
+    if (this.matrixAutoUpdate) {
+        this.updateMatrix();
+    }
+    if (this.matrixWorldNeedsUpdate || force) {
+        if (this.matrixWorldAutoUpdate) {
+            calculateMatrixWorld(this);
+        }
+        this.matrixWorldNeedsUpdate = false;
+        force = true;
+    }
+    for (const child of this.children) {
+        child.updateMatrixWorld(force);
+    }
+};
+function calculateMatrixWorld(object) {
+    if (!object.parent) {
+        object.matrixWorld.copy(object.matrix);
+    }
+    else {
+        if (object.useAbsolutePosition || object.useAbsoluteRotation || object.useAbsoluteScale) {
+            // Get parent's world transform for non-absolute components
+            const parentPos = new THREE.Vector3();
+            const parentQuat = new THREE.Quaternion();
+            const parentScale = new THREE.Vector3();
+            object.parent.matrixWorld.decompose(parentPos, parentQuat, parentScale);
+            // Determine final world position
+            let finalWorldPos;
+            if (object.useAbsolutePosition) {
+                // Use position as world position directly
+                finalWorldPos = object.position.clone();
+            }
+            else {
+                // Transform local position by parent's rotation and scale, then add parent's position
+                finalWorldPos = object.position.clone();
+                // Apply parent's rotation
+                finalWorldPos.applyQuaternion(parentQuat);
+                // Apply parent's scale
+                finalWorldPos.multiply(parentScale);
+                // Add parent's position
+                finalWorldPos.add(parentPos);
+            }
+            // Determine final world rotation
+            let finalWorldQuat;
+            if (object.useAbsoluteRotation) {
+                // Use quaternion as world rotation directly
+                finalWorldQuat = object.quaternion.clone();
+            }
+            else {
+                // Combine with parent rotation
+                finalWorldQuat = parentQuat.clone();
+                finalWorldQuat.multiply(object.quaternion);
+            }
+            // Determine final world scale
+            let finalWorldScale;
+            if (object.useAbsoluteScale) {
+                // Use scale as world scale directly
+                finalWorldScale = object.scale.clone();
+            }
+            else {
+                // Multiply with parent scale
+                finalWorldScale = object.scale.clone();
+                finalWorldScale.multiply(parentScale);
+            }
+            // Compose world matrix from the computed components
+            object.matrixWorld.compose(finalWorldPos, finalWorldQuat, finalWorldScale);
+        }
+        else {
+            object.matrixWorld.multiplyMatrices(object.parent.matrixWorld, object.matrix);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ThreeJsExtensions.js","sourceRoot":"","sources":["../../../src/utils/ThreeJsExtensions.ts"],"names":[],"mappings":"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"}