@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/native-engine/AnimationSystem.d.ts

@@ -0,0 +1,329 @@
+/**
+ * @file AnimationSystem.ts
+ * @description Animation System for Nice2Dev Game Engine
+ * PRO-1.11.4: Animation System
+ *
+ * Features:
+ * - Skeletal animation
+ * - Blend trees
+ * - Animation state machine
+ * - Inverse Kinematics (IK)
+ * - Procedural animation
+ * - Morph targets
+ * - Animation events
+ */
+export type BlendMode = 'override' | 'additive';
+export type WrapMode = 'once' | 'loop' | 'pingpong' | 'clamp';
+export type IKSolverType = 'ccd' | 'fabrik' | 'two-bone';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface BoneDescriptor {
+    name: string;
+    parentIndex: number;
+    position: Vec3;
+    rotation: Quaternion;
+    scale: Vec3;
+}
+export interface Bone {
+    name: string;
+    index: number;
+    parentIndex: number;
+    children: number[];
+    localPosition: Vec3;
+    localRotation: Quaternion;
+    localScale: Vec3;
+    worldPosition: Vec3;
+    worldRotation: Quaternion;
+    worldScale: Vec3;
+    inverseBindMatrix: Float32Array;
+}
+export interface Skeleton {
+    bones: Bone[];
+    boneMap: Map<string, number>;
+    getBone(nameOrIndex: string | number): Bone | undefined;
+    getBoneIndex(name: string): number;
+    getBoneCount(): number;
+    setLocalPose(boneIndex: number, position: Vec3, rotation: Quaternion, scale: Vec3): void;
+    getLocalPose(boneIndex: number): {
+        position: Vec3;
+        rotation: Quaternion;
+        scale: Vec3;
+    };
+    computeWorldTransforms(): void;
+    getJointMatrices(): Float32Array;
+}
+export interface AnimationClipDescriptor {
+    name: string;
+    duration: number;
+    tracks: AnimationTrack[];
+    events?: AnimationEvent[];
+}
+export interface AnimationTrack {
+    targetBone: string;
+    property: 'position' | 'rotation' | 'scale';
+    keyframes: Keyframe[];
+    interpolation?: 'linear' | 'step' | 'cubic';
+}
+export interface Keyframe {
+    time: number;
+    value: Vec3 | Quaternion;
+    inTangent?: Vec3 | Quaternion;
+    outTangent?: Vec3 | Quaternion;
+}
+export interface AnimationEvent {
+    time: number;
+    name: string;
+    data?: unknown;
+}
+export interface AnimationClip {
+    name: string;
+    duration: number;
+    tracks: AnimationTrack[];
+    events: AnimationEvent[];
+    sample(time: number, skeleton: Skeleton): void;
+    getEvent(time: number, previousTime: number): AnimationEvent | null;
+}
+export interface AnimationLayerDescriptor {
+    name: string;
+    blendMode?: BlendMode;
+    weight?: number;
+    mask?: string[];
+    avatarMask?: AvatarMask;
+}
+export interface AnimationLayer {
+    name: string;
+    blendMode: BlendMode;
+    getWeight(): number;
+    setWeight(weight: number): void;
+    getBlendMode(): BlendMode;
+    setBlendMode(mode: BlendMode): void;
+    getMask(): AvatarMask | null;
+    setMask(mask: AvatarMask | null): void;
+    getCurrentState(): AnimationState | null;
+    setCurrentState(state: AnimationState): void;
+    evaluate(deltaTime: number): void;
+}
+export interface AvatarMask {
+    getBoneWeight(boneName: string): number;
+    setBoneWeight(boneName: string, weight: number): void;
+    setAllWeights(weight: number): void;
+}
+export interface AnimationStateMachineDescriptor {
+    states: AnimationStateDescriptor[];
+    transitions: AnimationTransitionDescriptor[];
+    parameters?: AnimationParameter[];
+    defaultState?: string;
+}
+export interface AnimationStateDescriptor {
+    name: string;
+    type: 'clip' | 'blend-tree';
+    clip?: string;
+    blendTree?: BlendTreeDescriptor;
+    speed?: number;
+    wrapMode?: WrapMode;
+    transitions?: string[];
+}
+export interface AnimationTransitionDescriptor {
+    from: string;
+    to: string;
+    duration?: number;
+    offset?: number;
+    conditions?: TransitionCondition[];
+    hasExitTime?: boolean;
+    exitTime?: number;
+    interruptionSource?: 'none' | 'current' | 'next' | 'both';
+}
+export interface TransitionCondition {
+    parameter: string;
+    mode: 'equals' | 'not-equals' | 'greater' | 'less' | 'if' | 'if-not';
+    value?: number | boolean;
+}
+export interface AnimationParameter {
+    name: string;
+    type: 'float' | 'int' | 'bool' | 'trigger';
+    defaultValue?: number | boolean;
+}
+export interface AnimationState {
+    name: string;
+    type: 'clip' | 'blend-tree';
+    clip: AnimationClip | null;
+    blendTree: BlendTree | null;
+    speed: number;
+    wrapMode: WrapMode;
+    normalizedTime: number;
+    time: number;
+    enter(): void;
+    exit(): void;
+    update(deltaTime: number): void;
+    sample(skeleton: Skeleton): void;
+}
+export interface AnimationTransition {
+    from: AnimationState;
+    to: AnimationState;
+    duration: number;
+    offset: number;
+    conditions: TransitionCondition[];
+    hasExitTime: boolean;
+    exitTime: number;
+    progress: number;
+    check(parameters: Map<string, number | boolean>): boolean;
+    update(deltaTime: number): void;
+    isComplete(): boolean;
+}
+export interface BlendTreeDescriptor {
+    type: '1d' | '2d-simple' | '2d-freeform-directional' | '2d-freeform-cartesian' | 'direct';
+    parameter?: string;
+    parameterX?: string;
+    parameterY?: string;
+    children: BlendTreeChildDescriptor[];
+}
+export interface BlendTreeChildDescriptor {
+    motion: string | BlendTreeDescriptor;
+    threshold?: number;
+    position?: {
+        x: number;
+        y: number;
+    };
+    weight?: number;
+    timeScale?: number;
+}
+export interface BlendTree {
+    type: BlendTreeDescriptor['type'];
+    getParameter(): string;
+    setParameter(param: string): void;
+    getChildren(): BlendTreeChild[];
+    addChild(child: BlendTreeChildDescriptor): BlendTreeChild;
+    removeChild(child: BlendTreeChild): void;
+    computeWeights(parameters: Map<string, number | boolean>): void;
+    sample(skeleton: Skeleton): void;
+}
+export interface BlendTreeChild {
+    motion: AnimationClip | BlendTree;
+    threshold: number;
+    position: {
+        x: number;
+        y: number;
+    };
+    weight: number;
+    timeScale: number;
+}
+export interface IKChainDescriptor {
+    type: IKSolverType;
+    rootBone: string;
+    tipBone: string;
+    iterations?: number;
+    tolerance?: number;
+    weight?: number;
+    poleTarget?: Vec3;
+    hingeAxis?: Vec3;
+    jointLimits?: IKJointLimit[];
+}
+export interface IKJointLimit {
+    bone: string;
+    minAngle?: Vec3;
+    maxAngle?: Vec3;
+}
+export interface IKChain {
+    type: IKSolverType;
+    rootBone: string;
+    tipBone: string;
+    getTarget(): Vec3;
+    setTarget(target: Vec3): void;
+    getPoleTarget(): Vec3 | null;
+    setPoleTarget(target: Vec3 | null): void;
+    getWeight(): number;
+    setWeight(weight: number): void;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    solve(skeleton: Skeleton): void;
+}
+export interface MorphTargetDescriptor {
+    name: string;
+    vertices: Float32Array;
+    normals?: Float32Array;
+    tangents?: Float32Array;
+}
+export interface MorphTarget {
+    name: string;
+    weight: number;
+    vertices: Float32Array;
+    normals: Float32Array | null;
+    tangents: Float32Array | null;
+}
+export interface MorphTargetManager {
+    getMorphTarget(name: string): MorphTarget | undefined;
+    getMorphTargets(): MorphTarget[];
+    addMorphTarget(descriptor: MorphTargetDescriptor): MorphTarget;
+    removeMorphTarget(name: string): void;
+    getWeight(name: string): number;
+    setWeight(name: string, weight: number): void;
+    getBlendedVertices(baseVertices: Float32Array): Float32Array;
+}
+export declare class AnimatorController {
+    private skeleton;
+    private clips;
+    private layers;
+    private stateMachine;
+    private parameters;
+    private ikChains;
+    private morphTargets;
+    private eventCallbacks;
+    constructor(boneDescriptors: BoneDescriptor[]);
+    addClip(descriptor: AnimationClipDescriptor): AnimationClip;
+    getClip(name: string): AnimationClip | undefined;
+    removeClip(name: string): void;
+    addLayer(descriptor: AnimationLayerDescriptor): AnimationLayer;
+    getLayer(nameOrIndex: string | number): AnimationLayer | undefined;
+    getLayerCount(): number;
+    createStateMachine(descriptor: AnimationStateMachineDescriptor): AnimationStateMachine;
+    getStateMachine(): AnimationStateMachine | null;
+    setFloat(name: string, value: number): void;
+    getFloat(name: string): number;
+    setInt(name: string, value: number): void;
+    getInt(name: string): number;
+    setBool(name: string, value: boolean): void;
+    getBool(name: string): boolean;
+    setTrigger(name: string): void;
+    resetTrigger(name: string): void;
+    addIKChain(name: string, descriptor: IKChainDescriptor): IKChain;
+    getIKChain(name: string): IKChain | undefined;
+    removeIKChain(name: string): void;
+    createMorphTargetManager(): MorphTargetManager;
+    getMorphTargetManager(): MorphTargetManager | null;
+    onEvent(eventName: string, callback: (data?: unknown) => void): void;
+    offEvent(eventName: string, callback: (data?: unknown) => void): void;
+    private dispatchEvent;
+    update(deltaTime: number): void;
+    private isTrigger;
+    getSkeleton(): Skeleton;
+    getJointMatrices(): Float32Array;
+}
+export declare class AnimationStateMachine {
+    private states;
+    private transitions;
+    private currentState;
+    private activeTransition;
+    private parameters;
+    private previousTime;
+    private triggeredEvents;
+    constructor(descriptor: AnimationStateMachineDescriptor, clips: Map<string, AnimationClip>, parameters: Map<string, number | boolean>);
+    getCurrentState(): AnimationState | null;
+    isInTransition(): boolean;
+    getTransitionProgress(): number;
+    update(deltaTime: number): void;
+    private startTransition;
+    sample(skeleton: Skeleton): void;
+    getTriggeredEvents(): AnimationEvent[];
+    forceState(stateName: string): void;
+}
+export declare function createAnimatorController(bones: BoneDescriptor[]): AnimatorController;
+export declare function createAnimationClip(descriptor: AnimationClipDescriptor): AnimationClip;

package/dist/types/native-engine/AssetPipeline.d.ts

@@ -0,0 +1,358 @@
+/**
+ * @file AssetPipeline.ts
+ * @description Asset Pipeline for Nice2Dev Game Engine
+ * PRO-1.11.1: Core Engine Systems - Asset Pipeline
+ *
+ * Features:
+ * - glTF 2.0 import (primary format)
+ * - FBX, OBJ, Collada, 3DS import
+ * - Texture compression (Basis Universal)
+ * - Asset bundling (.ndasset)
+ * - Asset streaming
+ * - Hot reloading
+ */
+export type AssetFormat = 'gltf' | 'glb' | 'fbx' | 'obj' | 'dae' | '3ds' | 'png' | 'jpg' | 'webp' | 'ktx2' | 'basis' | 'hdr' | 'exr' | 'wav' | 'mp3' | 'ogg' | 'json' | 'ndasset';
+export type AssetType = 'mesh' | 'texture' | 'material' | 'animation' | 'skeleton' | 'audio' | 'scene' | 'prefab' | 'bundle';
+export type AssetState = 'unloaded' | 'loading' | 'loaded' | 'error' | 'streaming';
+export type TextureCompression = 'none' | 'bc1' | 'bc3' | 'bc5' | 'bc7' | 'etc1' | 'etc2' | 'astc' | 'basis';
+export interface Asset {
+    id: string;
+    name: string;
+    type: AssetType;
+    format: AssetFormat;
+    path: string;
+    state: AssetState;
+    size: number;
+    dependencies: string[];
+    metadata: AssetMetadata;
+    data: unknown;
+    lastModified: number;
+    loadedAt?: number;
+    error?: Error;
+}
+export interface AssetMetadata {
+    version: number;
+    author?: string;
+    tags?: string[];
+    description?: string;
+    thumbnail?: string;
+    importSettings?: Record<string, unknown>;
+    custom?: Record<string, unknown>;
+}
+export interface MeshAsset extends Asset {
+    type: 'mesh';
+    data: MeshData;
+}
+export interface TextureAsset extends Asset {
+    type: 'texture';
+    data: TextureData;
+}
+export interface MaterialAsset extends Asset {
+    type: 'material';
+    data: MaterialData;
+}
+export interface AnimationAsset extends Asset {
+    type: 'animation';
+    data: AnimationData;
+}
+export interface SkeletonAsset extends Asset {
+    type: 'skeleton';
+    data: SkeletonData;
+}
+export interface AudioAsset extends Asset {
+    type: 'audio';
+    data: AudioData;
+}
+export interface SceneAsset extends Asset {
+    type: 'scene';
+    data: SceneData;
+}
+export interface PrefabAsset extends Asset {
+    type: 'prefab';
+    data: PrefabData;
+}
+export interface BundleAsset extends Asset {
+    type: 'bundle';
+    data: BundleData;
+}
+export interface MeshData {
+    primitives: MeshPrimitive[];
+    bounds: BoundingBox;
+}
+export interface MeshPrimitive {
+    positions: Float32Array;
+    normals?: Float32Array;
+    tangents?: Float32Array;
+    uvs?: Float32Array;
+    uvs2?: Float32Array;
+    colors?: Float32Array;
+    joints?: Uint16Array;
+    weights?: Float32Array;
+    indices?: Uint32Array | Uint16Array;
+    materialIndex?: number;
+    mode: PrimitiveMode;
+}
+export type PrimitiveMode = 'triangles' | 'triangle-strip' | 'triangle-fan' | 'lines' | 'line-strip' | 'line-loop' | 'points';
+export interface BoundingBox {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface TextureData {
+    width: number;
+    height: number;
+    depth?: number;
+    format: TextureFormat;
+    compression?: TextureCompression;
+    mipLevels: number;
+    data: ArrayBuffer[];
+    sRGB: boolean;
+    generateMipmaps: boolean;
+    addressModeU: TextureAddressMode;
+    addressModeV: TextureAddressMode;
+    filterMin: TextureFilter;
+    filterMag: TextureFilter;
+    filterMip: TextureFilter;
+    anisotropy: number;
+}
+export type TextureFormat = 'r8' | 'rg8' | 'rgb8' | 'rgba8' | 'r16f' | 'rg16f' | 'rgb16f' | 'rgba16f' | 'r32f' | 'rg32f' | 'rgb32f' | 'rgba32f' | 'depth16' | 'depth24' | 'depth32f';
+export type TextureAddressMode = 'clamp' | 'repeat' | 'mirror';
+export type TextureFilter = 'nearest' | 'linear';
+export interface MaterialData {
+    shader: string;
+    baseColor: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    baseColorTexture?: string;
+    metallic: number;
+    roughness: number;
+    metallicRoughnessTexture?: string;
+    normalTexture?: string;
+    normalScale: number;
+    occlusionTexture?: string;
+    occlusionStrength: number;
+    emissive: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    emissiveTexture?: string;
+    emissiveIntensity: number;
+    alphaMode: 'opaque' | 'mask' | 'blend';
+    alphaCutoff: number;
+    doubleSided: boolean;
+    customProperties?: Record<string, unknown>;
+}
+export interface AnimationData {
+    name: string;
+    duration: number;
+    channels: AnimationChannel[];
+}
+export interface AnimationChannel {
+    targetNode: string;
+    targetProperty: 'translation' | 'rotation' | 'scale' | 'weights';
+    interpolation: 'linear' | 'step' | 'cubic';
+    times: Float32Array;
+    values: Float32Array;
+}
+export interface SkeletonData {
+    bones: Bone[];
+    inverseBindMatrices: Float32Array;
+}
+export interface Bone {
+    name: string;
+    parentIndex: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface AudioData {
+    sampleRate: number;
+    channels: number;
+    bitDepth: number;
+    duration: number;
+    buffer: AudioBuffer | ArrayBuffer;
+    format: 'wav' | 'mp3' | 'ogg';
+}
+export interface SceneData {
+    nodes: SceneNodeData[];
+    rootNodes: number[];
+    meshes: string[];
+    materials: string[];
+    textures: string[];
+    animations: string[];
+    skeletons: string[];
+    lights: LightData[];
+    cameras: CameraData[];
+}
+export interface SceneNodeData {
+    name: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    meshIndex?: number;
+    skinIndex?: number;
+    childIndices: number[];
+    extras?: Record<string, unknown>;
+}
+export interface LightData {
+    type: 'directional' | 'point' | 'spot';
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    intensity: number;
+    range?: number;
+    innerConeAngle?: number;
+    outerConeAngle?: number;
+}
+export interface CameraData {
+    type: 'perspective' | 'orthographic';
+    near: number;
+    far: number;
+    fov?: number;
+    aspectRatio?: number;
+    orthographicSize?: number;
+}
+export interface PrefabData {
+    rootNode: SceneNodeData;
+    meshes: MeshData[];
+    materials: MaterialData[];
+    textures: string[];
+}
+export interface BundleData {
+    assets: {
+        id: string;
+        type: AssetType;
+        offset: number;
+        size: number;
+    }[];
+    data: ArrayBuffer;
+}
+export interface MeshImportSettings {
+    normalGeneration: 'import' | 'calculate' | 'none';
+    tangentGeneration: 'import' | 'calculate' | 'none';
+    uvGeneration: 'import' | 'box' | 'sphere' | 'cylinder' | 'none';
+    scaleFactor: number;
+    optimizeMesh: boolean;
+    mergeVertices: boolean;
+    generateLODs: boolean;
+    lodLevels?: number[];
+    flipUVs: boolean;
+    swapYZ: boolean;
+}
+export interface TextureImportSettings {
+    maxSize: number;
+    generateMipmaps: boolean;
+    compression: TextureCompression;
+    sRGB: boolean;
+    premultiplyAlpha: boolean;
+    flipY: boolean;
+    format?: TextureFormat;
+}
+export interface AnimationImportSettings {
+    frameRate: number;
+    rootMotion: boolean;
+    bakeAnimations: boolean;
+    removeScaleFromBones: boolean;
+}
+export interface SceneImportSettings {
+    mesh: MeshImportSettings;
+    texture: TextureImportSettings;
+    animation: AnimationImportSettings;
+    importLights: boolean;
+    importCameras: boolean;
+    importAnimations: boolean;
+    importMaterials: boolean;
+}
+export declare class AssetManager {
+    private assets;
+    private loaders;
+    private processors;
+    private loadingPromises;
+    private callbacks;
+    private defaultSettings;
+    constructor(settings?: Partial<SceneImportSettings>);
+    private registerDefaultLoaders;
+    registerLoader(format: AssetFormat, loader: AssetLoader): void;
+    registerProcessor(type: AssetType, processor: AssetProcessor): void;
+    setCallbacks(callbacks: AssetCallbacks): void;
+    load(path: string, settings?: Partial<SceneImportSettings>): Promise<Asset>;
+    private doLoad;
+    loadMultiple(paths: string[], settings?: Partial<SceneImportSettings>): Promise<Asset[]>;
+    private fetchData;
+    unload(id: string): void;
+    unloadByPath(path: string): void;
+    unloadAll(): void;
+    unloadUnused(): void;
+    get(id: string): Asset | undefined;
+    getByPath(path: string): Asset | undefined;
+    getByType(type: AssetType): Asset[];
+    getAll(): Asset[];
+    has(id: string): boolean;
+    isLoaded(id: string): boolean;
+    reload(id: string): Promise<Asset>;
+    enableHotReload(_watchPaths: string[]): void;
+    disableHotReload(): void;
+    createBundle(assetIds: string[], bundlePath: string): Promise<BundleAsset>;
+    private serializeBundle;
+    private serializeAsset;
+    loadBundle(bundlePath: string): Promise<Asset[]>;
+    private deserializeAsset;
+    private getFormat;
+    private getName;
+    private inferType;
+    private generateId;
+}
+export interface AssetLoader {
+    load(data: ArrayBuffer, path: string, settings: Partial<SceneImportSettings>): Promise<unknown>;
+}
+export interface AssetProcessor {
+    process(data: unknown, settings: Partial<SceneImportSettings>): Promise<unknown>;
+    cleanup?(data: unknown): void;
+}
+export interface AssetCallbacks {
+    onLoadStart?: (asset: Asset) => void;
+    onLoadProgress?: (asset: Asset, progress: number) => void;
+    onLoadComplete?: (asset: Asset) => void;
+    onLoadError?: (asset: Asset, error: Error) => void;
+    onUnload?: (asset: Asset) => void;
+}
+export declare function createAssetManager(settings?: Partial<SceneImportSettings>): AssetManager;