@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/systems/NiceXR.d.ts

@@ -0,0 +1,187 @@
+export type XRMode = 'inline' | 'immersive-vr' | 'immersive-ar';
+export type HandType = 'left' | 'right';
+export type ControllerType = 'controller' | 'hand' | 'gaze';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface Pose {
+    position: Vec3;
+    orientation: Quat;
+}
+export interface XRControllerState {
+    id: string;
+    type: ControllerType;
+    hand: HandType;
+    connected: boolean;
+    pose: Pose;
+    grip: Pose;
+    buttons: XRButtonState[];
+    axes: number[];
+    hapticActuator: boolean;
+    profiles: string[];
+}
+export interface XRButtonState {
+    id: string;
+    pressed: boolean;
+    touched: boolean;
+    value: number;
+}
+export type HandJoint = 'wrist' | 'thumb-metacarpal' | 'thumb-phalanx-proximal' | 'thumb-phalanx-distal' | 'thumb-tip' | 'index-finger-metacarpal' | 'index-finger-phalanx-proximal' | 'index-finger-phalanx-intermediate' | 'index-finger-phalanx-distal' | 'index-finger-tip' | 'middle-finger-metacarpal' | 'middle-finger-phalanx-proximal' | 'middle-finger-phalanx-intermediate' | 'middle-finger-phalanx-distal' | 'middle-finger-tip' | 'ring-finger-metacarpal' | 'ring-finger-phalanx-proximal' | 'ring-finger-phalanx-intermediate' | 'ring-finger-phalanx-distal' | 'ring-finger-tip' | 'pinky-finger-metacarpal' | 'pinky-finger-phalanx-proximal' | 'pinky-finger-phalanx-intermediate' | 'pinky-finger-phalanx-distal' | 'pinky-finger-tip';
+export interface HandJointPose {
+    joint: HandJoint;
+    pose: Pose;
+    radius: number;
+}
+export interface HandState {
+    hand: HandType;
+    visible: boolean;
+    joints: Map<HandJoint, HandJointPose>;
+    pinchStrength: number;
+    gripStrength: number;
+}
+export interface ARAnchor {
+    id: string;
+    pose: Pose;
+    trackingState: 'tracking' | 'paused' | 'stopped';
+    createdAt: number;
+}
+export interface ARPlane {
+    id: string;
+    pose: Pose;
+    orientation: 'horizontal' | 'vertical';
+    polygon: Vec3[];
+    extent: {
+        width: number;
+        height: number;
+    };
+    label?: 'floor' | 'wall' | 'ceiling' | 'table' | 'seat';
+}
+export interface ARHitTestResult {
+    pose: Pose;
+    plane?: ARPlane;
+    distance: number;
+}
+export interface ARLightEstimate {
+    primaryLightDirection: Vec3;
+    primaryLightIntensity: number;
+    sphericalHarmonicsCoefficients: Float32Array;
+}
+export interface PlayArea {
+    bounds: Vec3[];
+    center: Vec3;
+    size: {
+        width: number;
+        depth: number;
+    };
+    isConfigured: boolean;
+}
+export type XREventType = 'session-start' | 'session-end' | 'controller-connected' | 'controller-disconnected' | 'select-start' | 'select-end' | 'squeeze-start' | 'squeeze-end' | 'input-changed' | 'hand-tracking-start' | 'hand-tracking-end' | 'anchor-created' | 'anchor-updated' | 'anchor-removed' | 'plane-detected' | 'plane-updated' | 'plane-removed' | 'visibility-changed' | 'boundary-crossed' | 'error';
+export interface XREvent {
+    type: XREventType;
+    timestamp: number;
+    data: unknown;
+}
+export type XREventCallback = (event: XREvent) => void;
+export interface XRConfig {
+    /** Preferred mode */
+    preferredMode: XRMode;
+    /** Required features */
+    requiredFeatures: string[];
+    /** Optional features */
+    optionalFeatures: string[];
+    /** Frame rate */
+    frameRate: 72 | 80 | 90 | 120;
+    /** Reference space type */
+    referenceSpaceType: XRReferenceSpaceType;
+    /** Enable hand tracking */
+    handTracking: boolean;
+    /** Enable hit testing */
+    hitTesting: boolean;
+    /** Enable plane detection */
+    planeDetection: boolean;
+    /** Enable anchors */
+    anchors: boolean;
+    /** Enable light estimation */
+    lightEstimation: boolean;
+    /** Teleport enabled */
+    teleportEnabled: boolean;
+    /** Teleport max distance */
+    teleportMaxDistance: number;
+    /** Comfort vignette */
+    comfortVignette: boolean;
+}
+export declare const DEFAULT_XR_CONFIG: XRConfig;
+export declare class NiceXR {
+    private config;
+    private xr;
+    private session;
+    private referenceSpace;
+    private controllers;
+    private hands;
+    private anchors;
+    private planes;
+    private playArea;
+    private lightEstimate;
+    private eventListeners;
+    private frameCallback;
+    private isSupported;
+    private isSessionActive;
+    constructor(config?: Partial<XRConfig>);
+    on(event: XREventType, callback: XREventCallback): () => void;
+    private emit;
+    private checkSupport;
+    isXRSupported(mode?: XRMode): Promise<boolean>;
+    isVRSupported(): Promise<boolean>;
+    isARSupported(): Promise<boolean>;
+    startSession(mode?: XRMode): Promise<boolean>;
+    endSession(): Promise<void>;
+    private onSessionEnd;
+    private onInputSourcesChange;
+    private addInputSource;
+    private removeInputSource;
+    private getSourceId;
+    private startHandTracking;
+    private onSelect;
+    private onSelectStart;
+    private onSelectEnd;
+    private onSqueeze;
+    private onSqueezeStart;
+    private onSqueezeEnd;
+    private onVisibilityChange;
+    setFrameCallback(callback: (time: number, frame: XRFrame) => void): void;
+    startFrameLoop(): void;
+    private onFrame;
+    private updateInputSource;
+    private updateHandJoints;
+    private xrPoseToPose;
+    private vec3Distance;
+    private updatePlayArea;
+    getPlayArea(): PlayArea | null;
+    vibrate(hand: HandType, intensity?: number, duration?: number): void;
+    hitTest(_origin: Vec3, _direction: Vec3): Promise<ARHitTestResult[]>;
+    createAnchor(pose: Pose): Promise<string | null>;
+    removeAnchor(id: string): boolean;
+    getAnchor(id: string): ARAnchor | undefined;
+    getAllAnchors(): ARAnchor[];
+    getAllPlanes(): ARPlane[];
+    getLightEstimate(): ARLightEstimate | null;
+    teleportTo(position: Vec3): void;
+    getController(hand: HandType): XRControllerState | undefined;
+    getAllControllers(): XRControllerState[];
+    getHand(hand: HandType): HandState | undefined;
+    isHandTracking(): boolean;
+    getSession(): XRSession | null;
+    getReferenceSpace(): XRReferenceSpace | null;
+    isActive(): boolean;
+    getMode(): XRMode | null;
+    destroy(): Promise<void>;
+}
+export declare function createXRSystem(config?: Partial<XRConfig>): NiceXR;

package/dist/types/systems/PhysicsDebugSystem.d.ts

@@ -0,0 +1,369 @@
+/**
+ * @file PhysicsDebugSystem.ts
+ * @description Advanced Physics Debug Visualization System
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Collider visualization (all shapes)
+ * - Contact point visualization
+ * - Force/velocity vectors
+ * - Physics stats overlay
+ * - Joint visualization
+ * - Collision layers matrix
+ * - Performance profiling
+ * - Configurable visualizations
+ */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface Transform2D {
+    position: Vec2;
+    rotation: number;
+    scale: Vec2;
+}
+export interface Transform3D {
+    position: Vec3;
+    rotation: Vec3;
+    scale: Vec3;
+}
+export type ColliderType2D = 'circle' | 'box' | 'polygon' | 'edge' | 'chain' | 'capsule';
+export type ColliderType3D = 'sphere' | 'box' | 'capsule' | 'cylinder' | 'mesh' | 'convexHull' | 'terrain' | 'plane';
+export type BodyType = 'static' | 'kinematic' | 'dynamic';
+export interface Collider2D {
+    id: string;
+    entityId: string;
+    type: ColliderType2D;
+    offset: Vec2;
+    rotation: number;
+    isTrigger: boolean;
+    layer: number;
+    mask: number;
+    radius?: number;
+    halfExtents?: Vec2;
+    vertices?: Vec2[];
+    edgeStart?: Vec2;
+    edgeEnd?: Vec2;
+    chainVertices?: Vec2[];
+    capsuleHeight?: number;
+}
+export interface Collider3D {
+    id: string;
+    entityId: string;
+    type: ColliderType3D;
+    offset: Vec3;
+    rotation: Vec3;
+    isTrigger: boolean;
+    layer: number;
+    mask: number;
+    radius?: number;
+    halfExtents?: Vec3;
+    vertices?: Vec3[];
+    indices?: number[];
+    capsuleRadius?: number;
+    capsuleHeight?: number;
+    cylinderRadius?: number;
+    cylinderHeight?: number;
+}
+export interface Rigidbody2D {
+    id: string;
+    entityId: string;
+    bodyType: BodyType;
+    mass: number;
+    linearDamping: number;
+    angularDamping: number;
+    gravityScale: number;
+    fixedRotation: boolean;
+    isBullet: boolean;
+    isAwake: boolean;
+    isSleeping: boolean;
+    linearVelocity: Vec2;
+    angularVelocity: number;
+    forceAccumulator: Vec2;
+    torqueAccumulator: number;
+}
+export interface Rigidbody3D {
+    id: string;
+    entityId: string;
+    bodyType: BodyType;
+    mass: number;
+    linearDamping: number;
+    angularDamping: number;
+    useGravity: boolean;
+    constraints: {
+        freezePositionX: boolean;
+        freezePositionY: boolean;
+        freezePositionZ: boolean;
+        freezeRotationX: boolean;
+        freezeRotationY: boolean;
+        freezeRotationZ: boolean;
+    };
+    interpolation: 'none' | 'interpolate' | 'extrapolate';
+    collisionDetection: 'discrete' | 'continuous' | 'continuousDynamic';
+    isAwake: boolean;
+    isSleeping: boolean;
+    linearVelocity: Vec3;
+    angularVelocity: Vec3;
+    forceAccumulator: Vec3;
+    torqueAccumulator: Vec3;
+}
+export type JointType2D = 'distance' | 'hinge' | 'spring' | 'slider' | 'wheel' | 'weld' | 'friction' | 'motor' | 'rope';
+export type JointType3D = 'fixed' | 'hinge' | 'spring' | 'slider' | 'configurable' | 'character' | 'distance';
+export interface Joint2D {
+    id: string;
+    type: JointType2D;
+    bodyA: string;
+    bodyB: string;
+    anchorA: Vec2;
+    anchorB: Vec2;
+    enableCollision: boolean;
+    breakForce: number;
+    breakTorque: number;
+    distance?: number;
+    frequency?: number;
+    dampingRatio?: number;
+    minAngle?: number;
+    maxAngle?: number;
+    motorSpeed?: number;
+    maxMotorTorque?: number;
+    useMotor?: boolean;
+    useLimits?: boolean;
+}
+export interface Joint3D {
+    id: string;
+    type: JointType3D;
+    bodyA: string;
+    bodyB: string;
+    anchor: Vec3;
+    axis: Vec3;
+    connectedAnchor: Vec3;
+    enableCollision: boolean;
+    breakForce: number;
+    breakTorque: number;
+    spring?: number;
+    damper?: number;
+    minDistanceOrAngle?: number;
+    maxDistanceOrAngle?: number;
+    useLimits?: boolean;
+    useMotor?: boolean;
+}
+export interface ContactPoint2D {
+    point: Vec2;
+    normal: Vec2;
+    impulse: number;
+    separation: number;
+}
+export interface ContactPoint3D {
+    point: Vec3;
+    normal: Vec3;
+    impulse: number;
+    separation: number;
+}
+export interface CollisionPair {
+    idA: string;
+    idB: string;
+    contacts: ContactPoint2D[] | ContactPoint3D[];
+    totalImpulse: number;
+    isNew: boolean;
+    isPersistent: boolean;
+    isSeparating: boolean;
+}
+export interface RaycastHit2D {
+    collider: Collider2D;
+    point: Vec2;
+    normal: Vec2;
+    distance: number;
+    fraction: number;
+}
+export interface RaycastHit3D {
+    collider: Collider3D;
+    point: Vec3;
+    normal: Vec3;
+    distance: number;
+    fraction: number;
+    triangleIndex?: number;
+    barycentricCoord?: Vec3;
+}
+export interface PhysicsDebugColors {
+    staticCollider: Color;
+    kinematicCollider: Color;
+    dynamicCollider: Color;
+    triggerCollider: Color;
+    sleepingCollider: Color;
+    activeBody: Color;
+    sleepingBody: Color;
+    contactPoint: Color;
+    contactNormal: Color;
+    contactImpulse: Color;
+    velocity: Color;
+    angularVelocity: Color;
+    force: Color;
+    torque: Color;
+    jointActive: Color;
+    jointBroken: Color;
+    jointLimit: Color;
+    jointMotor: Color;
+    raycastHit: Color;
+    raycastMiss: Color;
+    aabbOverlap: Color;
+    layerColors: Color[];
+}
+export declare const DEFAULT_DEBUG_COLORS: PhysicsDebugColors;
+export interface PhysicsDebugOptions {
+    enabled: boolean;
+    showColliders: boolean;
+    showTriggers: boolean;
+    showContactPoints: boolean;
+    showContactNormals: boolean;
+    showContactImpulse: boolean;
+    showVelocities: boolean;
+    showAngularVelocities: boolean;
+    showForces: boolean;
+    showJoints: boolean;
+    showJointLimits: boolean;
+    showCenterOfMass: boolean;
+    showAABB: boolean;
+    showSleepState: boolean;
+    showLayerColors: boolean;
+    showRaycasts: boolean;
+    filterByLayer: number | null;
+    filterByBodyType: BodyType | null;
+    filterByEntity: string[] | null;
+    hideStaticColliders: boolean;
+    hideSleepingBodies: boolean;
+    velocityScale: number;
+    forceScale: number;
+    normalScale: number;
+    impulseScale: number;
+    colliderLineWidth: number;
+    vectorLineWidth: number;
+    jointLineWidth: number;
+    contactHistoryDuration: number;
+    maxContactHistory: number;
+    showStatsOverlay: boolean;
+    statsPosition: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    colors: PhysicsDebugColors;
+}
+export declare const DEFAULT_DEBUG_OPTIONS: PhysicsDebugOptions;
+export interface PhysicsStats {
+    totalBodies: number;
+    dynamicBodies: number;
+    kinematicBodies: number;
+    staticBodies: number;
+    awakeBodies: number;
+    sleepingBodies: number;
+    totalColliders: number;
+    activeColliders: number;
+    triggers: number;
+    collisionPairs: number;
+    contactPoints: number;
+    islandCount: number;
+    stepTime: number;
+    broadphaseTime: number;
+    narrowphaseTime: number;
+    solverTime: number;
+    integrationTime: number;
+    bodyMemory: number;
+    colliderMemory: number;
+    contactMemory: number;
+    totalJoints: number;
+    activeJoints: number;
+    brokenJoints: number;
+    raycastsThisFrame: number;
+    overlapTestsThisFrame: number;
+}
+export type DrawCommandType = 'line' | 'circle' | 'filledCircle' | 'rect' | 'filledRect' | 'polygon' | 'filledPolygon' | 'arrow' | 'cross' | 'text' | 'arc' | 'capsule' | 'sphere' | 'box3d';
+export interface DrawCommand {
+    type: DrawCommandType;
+    color: Color;
+    zOrder: number;
+    points?: Vec2[] | Vec3[];
+    position?: Vec2 | Vec3;
+    radius?: number;
+    size?: Vec2 | Vec3;
+    rotation?: number | Vec3;
+    text?: string;
+    fontSize?: number;
+    startAngle?: number;
+    endAngle?: number;
+    lineWidth?: number;
+}
+export declare class PhysicsDebugSystem {
+    private options;
+    private drawCommands;
+    private stats;
+    private contactHistory;
+    private colliders2D;
+    private colliders3D;
+    private bodies2D;
+    private bodies3D;
+    private joints2D;
+    private joints3D;
+    private transforms2D;
+    private transforms3D;
+    private collisionPairs;
+    private raycasts;
+    private is3D;
+    constructor();
+    private createEmptyStats;
+    setOptions(options: Partial<PhysicsDebugOptions>): void;
+    getOptions(): PhysicsDebugOptions;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    set3DMode(is3D: boolean): void;
+    updateCollider2D(collider: Collider2D): void;
+    removeCollider2D(colliderId: string): void;
+    updateCollider3D(collider: Collider3D): void;
+    removeCollider3D(colliderId: string): void;
+    updateBody2D(body: Rigidbody2D): void;
+    removeBody2D(bodyId: string): void;
+    updateBody3D(body: Rigidbody3D): void;
+    removeBody3D(bodyId: string): void;
+    updateTransform2D(entityId: string, transform: Transform2D): void;
+    updateTransform3D(entityId: string, transform: Transform3D): void;
+    updateJoint2D(joint: Joint2D): void;
+    removeJoint2D(jointId: string): void;
+    updateJoint3D(joint: Joint3D): void;
+    removeJoint3D(jointId: string): void;
+    setCollisionPairs(pairs: CollisionPair[]): void;
+    addRaycast(origin: Vec2 | Vec3, direction: Vec2 | Vec3, maxDistance: number, hit: RaycastHit2D | RaycastHit3D | null): void;
+    updateStats(stats: Partial<PhysicsStats>): void;
+    generateDrawCommands(): DrawCommand[];
+    private generateDrawCommands2D;
+    private generateDrawCommands3D;
+    private shouldDrawCollider2D;
+    private shouldDrawCollider3D;
+    private findBody2DForEntity;
+    private findBody3DForEntity;
+    private getColliderColor2D;
+    private getColliderColor3D;
+    private drawCollider2D;
+    private drawCollider3D;
+    private drawJoint2D;
+    private drawJoint3D;
+    private drawContacts2D;
+    private drawContacts3D;
+    private drawRaycasts2D;
+    private drawRaycasts3D;
+    private calculateStats;
+    getStats(): PhysicsStats;
+    generateStatsOverlayText(): string[];
+    generateLayerMatrix(layerCount?: number): boolean[][];
+    clear(): void;
+}
+export declare function createPhysicsDebugSystem(): PhysicsDebugSystem;
+export declare function createCollider2D(type: ColliderType2D, entityId: string): Collider2D;
+export declare function createCollider3D(type: ColliderType3D, entityId: string): Collider3D;
+export declare function createRigidbody2D(entityId: string, bodyType?: BodyType): Rigidbody2D;
+export declare function createRigidbody3D(entityId: string, bodyType?: BodyType): Rigidbody3D;