@directivegames/genesys.js 3.1.24

package/dist/src/actors/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Actors module index - re-exports the built-in actor implementations.
+ *
+ * Detailed explanation:
+ * - Collects the most commonly used actors so imports stay concise.
+ * - Allows IDE auto-completion and AI agents to discover available classes easily.
+ * - New actor classes should be added here when they become part of the engine.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import from `src/actors` when referencing default engine actors.
+ * - Keep this file updated as you create new generic actor types.
+ */
+export * from './Actor.js';
+export * from './GLTFMeshActor.js';
+export * from './GlobalParticleManager.js';
+export * from './Pawn.js';
+export * from './PlayerController.js';
+export * from './PlayerStart.js';
+export * from './Projectile.js';
+export * from './ThirdPersonCharacterPawn.js';

package/dist/src/actors/index.js

@@ -0,0 +1,21 @@
+/**
+ * Actors module index - re-exports the built-in actor implementations.
+ *
+ * Detailed explanation:
+ * - Collects the most commonly used actors so imports stay concise.
+ * - Allows IDE auto-completion and AI agents to discover available classes easily.
+ * - New actor classes should be added here when they become part of the engine.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Import from `src/actors` when referencing default engine actors.
+ * - Keep this file updated as you create new generic actor types.
+ */
+export * from './Actor.js';
+export * from './GLTFMeshActor.js';
+export * from './GlobalParticleManager.js';
+export * from './Pawn.js';
+export * from './PlayerController.js';
+export * from './PlayerStart.js';
+export * from './Projectile.js';
+export * from './ThirdPersonCharacterPawn.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWN0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsK0JBQStCLENBQUMifQ==

package/dist/src/animation/AnimationClipCache.d.ts

@@ -0,0 +1,41 @@
+import type * as THREE from 'three';
+/**
+ * AnimationClipCache is a singleton utility for caching and reusing THREE.AnimationClip instances by name.
+ * This helps avoid duplicate memory usage and speeds up animation setup for components like AnimationStateMachineComponent.
+ */
+export declare class AnimationClipCache {
+    private static _instance;
+    private clipMap;
+    /**
+     * Get the singleton instance of the cache.
+     */
+    static get instance(): AnimationClipCache;
+    /**
+     * Add a clip to the cache. If a clip with the same name exists, it will be replaced.
+     */
+    addClip(clip: THREE.AnimationClip): void;
+    /**
+     * Add multiple clips to the cache.
+     */
+    addClips(clips: THREE.AnimationClip[]): void;
+    /**
+     * Get a clip by name. Returns undefined if not found.
+     */
+    getClip(name: string): THREE.AnimationClip | undefined;
+    /**
+     * Check if a clip exists in the cache.
+     */
+    hasClip(name: string): boolean;
+    /**
+     * Remove a clip from the cache by name.
+     */
+    removeClip(name: string): void;
+    /**
+     * Clear all cached clips.
+     */
+    clear(): void;
+    /**
+     * Get all cached clip names.
+     */
+    getClipNames(): string[];
+}

package/dist/src/animation/AnimationClipCache.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var AnimationClipCache_1;
+/**
+ * AnimationClipCache - singleton for sharing THREE.AnimationClip instances.
+ *
+ * Detailed explanation:
+ * - Stores clips by name so animations from separate models can reuse memory.
+ * - Queried by components before they create new `AnimationClip` objects.
+ * - Provides methods to inspect or clear the cache when assets change.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Call `AnimationClipCache.instance` to retrieve the shared cache.
+ * - Import clips using the same name to avoid duplication across models.
+ * - Clear the cache during hot reload or level transitions to free memory.
+ */
+import { EngineClass } from '../systems/ClassRegistry.js';
+/**
+ * AnimationClipCache is a singleton utility for caching and reusing THREE.AnimationClip instances by name.
+ * This helps avoid duplicate memory usage and speeds up animation setup for components like AnimationStateMachineComponent.
+ */
+let AnimationClipCache = AnimationClipCache_1 = class AnimationClipCache {
+    constructor() {
+        Object.defineProperty(this, "clipMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Get the singleton instance of the cache.
+     */
+    static get instance() {
+        this._instance ??= new AnimationClipCache_1();
+        return this._instance;
+    }
+    /**
+     * Add a clip to the cache. If a clip with the same name exists, it will be replaced.
+     */
+    addClip(clip) {
+        this.clipMap.set(clip.name, clip);
+    }
+    /**
+     * Add multiple clips to the cache.
+     */
+    addClips(clips) {
+        for (const clip of clips) {
+            this.addClip(clip);
+        }
+    }
+    /**
+     * Get a clip by name. Returns undefined if not found.
+     */
+    getClip(name) {
+        return this.clipMap.get(name);
+    }
+    /**
+     * Check if a clip exists in the cache.
+     */
+    hasClip(name) {
+        return this.clipMap.has(name);
+    }
+    /**
+     * Remove a clip from the cache by name.
+     */
+    removeClip(name) {
+        this.clipMap.delete(name);
+    }
+    /**
+     * Clear all cached clips.
+     */
+    clear() {
+        this.clipMap.clear();
+    }
+    /**
+     * Get all cached clip names.
+     */
+    getClipNames() {
+        return Array.from(this.clipMap.keys());
+    }
+};
+Object.defineProperty(AnimationClipCache, "_instance", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: null
+});
+AnimationClipCache = AnimationClipCache_1 = __decorate([
+    EngineClass('AnimationClipCache')
+], AnimationClipCache);
+export { AnimationClipCache };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQW5pbWF0aW9uQ2xpcENhY2hlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FuaW1hdGlvbi9BbmltYXRpb25DbGlwQ2FjaGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUFBOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUsxRDs7O0dBR0c7QUFFSSxJQUFNLGtCQUFrQiwwQkFBeEIsTUFBTSxrQkFBa0I7SUFBeEI7UUFFRzs7OzttQkFBNEMsSUFBSSxHQUFHLEVBQUU7V0FBQztJQTREaEUsQ0FBQztJQTFEQzs7T0FFRztJQUNJLE1BQU0sS0FBSyxRQUFRO1FBQ3hCLElBQUksQ0FBQyxTQUFTLEtBQUssSUFBSSxvQkFBa0IsRUFBRSxDQUFDO1FBQzVDLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztJQUN4QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxPQUFPLENBQUMsSUFBeUI7UUFDdEMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxRQUFRLENBQUMsS0FBNEI7UUFDMUMsS0FBSyxNQUFNLElBQUksSUFBSSxLQUFLLEVBQUUsQ0FBQztZQUN6QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3JCLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxPQUFPLENBQUMsSUFBWTtRQUN6QixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7T0FFRztJQUNJLE9BQU8sQ0FBQyxJQUFZO1FBQ3pCLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDaEMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksVUFBVSxDQUFDLElBQVk7UUFDNUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSztRQUNWLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDdkIsQ0FBQztJQUVEOztPQUVHO0lBQ0ksWUFBWTtRQUNqQixPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7O0FBNURjOzs7O1dBQXVDLElBQUk7RUFBbEMsQ0FBbUM7QUFEaEQsa0JBQWtCO0lBRDlCLFdBQVcsQ0FBQyxvQkFBb0IsQ0FBQztHQUNyQixrQkFBa0IsQ0E4RDlCIn0=

package/dist/src/animation/AnimationRetargeting.d.ts

@@ -0,0 +1,100 @@
+/**
+ * AnimationRetargeting - runtime animation retargeting between different skeleton conventions.
+ *
+ * Uses the UPF GTI AnimationRetargeting algorithm which handles bind pose differences
+ * between skeletons through quaternion space transformations.
+ *
+ * Retargets animation clips from one skeleton format to another using explicit semantic
+ * bone mappings defined in SkeletonProfiles. This enables using animations from external
+ * sources (Mixamo, UE5, etc.) on characters with different bone naming conventions.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Define source and target profiles explicitly in AnimationStateMachineConfig
+ * - Profiles are loaded from JSON assets or referenced by name
+ * - Retargeting happens automatically during external animation loading
+ */
+import * as THREE from 'three';
+import { applyTPose as applyTPoseInternal } from './retargeting.js';
+export { applyTPoseInternal as applyTPose };
+import type { SkeletonProfile } from './SkeletonProfile.js';
+/**
+ * Result of adding a synthetic root bone to a skeleton.
+ */
+export interface SyntheticRootResult {
+    /** The modified skeleton with synthetic root */
+    skeleton: THREE.Skeleton;
+    /** Name of the synthetic root bone */
+    rootBoneName: string;
+    /** Updated profile with synthetic root mapping */
+    updatedProfile: SkeletonProfile;
+}
+/**
+ * Add a synthetic root bone to a skeleton that doesn't have one.
+ *
+ * This modifies the skeleton in-place by:
+ * 1. Creating a new root bone at ground level (0,0,0)
+ * 2. Reparenting the current root (typically hips) to be a child of the new root
+ * 3. Rebuilding the skeleton's bone array and inverse bind matrices
+ *
+ * @param skeleton - The skeleton to modify (will be modified in-place)
+ * @param skinnedMesh - The skinned mesh using this skeleton (will be updated)
+ * @param profile - The skeleton profile (will be cloned and updated)
+ * @param rootBoneName - Name for the synthetic root bone
+ * @returns Result containing the modified skeleton and updated profile
+ */
+export declare function addSyntheticRootBone(skeleton: THREE.Skeleton, skinnedMesh: THREE.SkinnedMesh, profile: SkeletonProfile, rootBoneName?: string): SyntheticRootResult;
+/**
+ * Check if a skeleton needs a synthetic root bone for retargeting from a source that has one.
+ */
+export declare function needsSyntheticRoot(sourceProfile: SkeletonProfile, targetProfile: SkeletonProfile): boolean;
+/**
+ * Create a bone name mapping between source and target skeletons using their profiles.
+ * Returns an object compatible with UPF AnimationRetargeting: { sourceRole: targetBoneName }
+ */
+export declare function createBoneMapping(sourceProfile: SkeletonProfile, targetProfile: SkeletonProfile, sourceSkeleton: THREE.Skeleton, targetSkeleton: THREE.Skeleton): Record<string, string>;
+/**
+ * Retarget an animation clip from source skeleton to target skeleton using UPF GTI retargeting.
+ *
+ * @param sourceClip - The animation clip to retarget
+ * @param sourceProfile - Skeleton profile for the source animation
+ * @param targetProfile - Skeleton profile for the target character
+ * @param sourceSkeleton - Source skeleton (from the animation's original GLTF)
+ * @param targetSkeleton - Target skeleton (from the character being animated)
+ * @param targetSkinnedMesh - Target skinned mesh (required by Three.js retargeting)
+ * @returns Retargeted animation clip, or null if retargeting failed
+ */
+export declare function retargetAnimationClip(sourceClip: THREE.AnimationClip, sourceProfile: SkeletonProfile, targetProfile: SkeletonProfile, sourceSkeleton: THREE.Skeleton, targetSkeleton: THREE.Skeleton, targetSkinnedMesh: THREE.SkinnedMesh): THREE.AnimationClip | null;
+/**
+ * A reusable retargeting session that initializes T-poses once and can retarget multiple clips.
+ * This is more efficient than calling retargetAnimationClip for each clip individually.
+ */
+export declare class RetargetingSession {
+    private retargeter;
+    private sourceRoleToBone;
+    private targetProfile;
+    private targetSkeleton;
+    private initialized;
+    constructor(sourceProfile: SkeletonProfile, targetProfile: SkeletonProfile, sourceSkeleton: THREE.Skeleton, targetSkeleton: THREE.Skeleton);
+    /**
+     * Retarget a single clip using the pre-initialized session.
+     */
+    retargetClip(sourceClip: THREE.AnimationClip): THREE.AnimationClip | null;
+    /**
+     * Retarget multiple clips using the pre-initialized session.
+     */
+    retargetClips(sourceClips: THREE.AnimationClip[]): Array<{
+        clip: THREE.AnimationClip | null;
+        success: boolean;
+        originalName: string;
+    }>;
+    isInitialized(): boolean;
+}
+/**
+ * Batch retarget multiple animation clips.
+ * Uses RetargetingSession internally to apply T-poses only once.
+ */
+export declare function retargetAnimationClips(sourceClips: THREE.AnimationClip[], sourceProfile: SkeletonProfile, targetProfile: SkeletonProfile, sourceSkeleton: THREE.Skeleton, targetSkeleton: THREE.Skeleton, _targetSkinnedMesh: THREE.SkinnedMesh): Array<{
+    clip: THREE.AnimationClip | null;
+    success: boolean;
+    originalName: string;
+}>;