@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/xr/WebXRLayers.d.ts

@@ -0,0 +1,319 @@
+export type XRLayerType = 'projection' | 'quad' | 'cylinder' | 'equirect' | 'cube';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface XRLayerConfig {
+    type: XRLayerType;
+    width: number;
+    height: number;
+    /** Color format */
+    colorFormat: XRTextureFormat;
+    /** Depth/stencil format */
+    depthStencilFormat?: XRTextureFormat;
+    /** Multisampling */
+    sampleCount?: 1 | 4;
+    /** Layer is static (for better performance) */
+    isStatic?: boolean;
+    /** Layer alpha mode */
+    alphaMode?: 'opaque' | 'premultiplied-alpha';
+    /** Layer space */
+    space?: XRSpace;
+}
+export type XRTextureFormat = 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba16float' | 'depth24plus' | 'depth24plus-stencil8';
+export interface XRQuadLayerConfig extends XRLayerConfig {
+    type: 'quad';
+    /** Position offset from reference space */
+    transform: {
+        position: Vec3;
+        orientation: Quat;
+    };
+    /** Quad dimensions in meters */
+    quadWidth: number;
+    quadHeight: number;
+}
+export interface XRCylinderLayerConfig extends XRLayerConfig {
+    type: 'cylinder';
+    /** Position offset from reference space */
+    transform: {
+        position: Vec3;
+        orientation: Quat;
+    };
+    /** Cylinder parameters */
+    radius: number;
+    centralAngle: number;
+    aspectRatio: number;
+}
+export interface XREquirectLayerConfig extends XRLayerConfig {
+    type: 'equirect';
+    /** Position offset from reference space */
+    transform: {
+        position: Vec3;
+        orientation: Quat;
+    };
+    /** Equirect sphere parameters */
+    radius: number;
+    centralHorizontalAngle: number;
+    upperVerticalAngle: number;
+    lowerVerticalAngle: number;
+}
+export interface XRCubeLayerConfig extends XRLayerConfig {
+    type: 'cube';
+    /** Position offset from reference space */
+    transform: {
+        position: Vec3;
+        orientation: Quat;
+    };
+    /** Cubemap layout */
+    layout: 'mono' | 'stereo' | 'stereo-top-bottom' | 'stereo-left-right';
+}
+export interface FoveatedRenderingConfig {
+    /** Enable foveated rendering */
+    enabled: boolean;
+    /** Minimum density (lowest quality, periphery) */
+    minDensity: number;
+    /** Maximum density (highest quality, fovea) */
+    maxDensity: number;
+    /** Use dynamic foveation (based on eye tracking) */
+    dynamic: boolean;
+    /** Fovea inner radius (normalized, 0-1) */
+    innerRadius: number;
+    /** Fovea outer radius (normalized, 0-1) */
+    outerRadius: number;
+    /** Foveation level (0 = off, 4 = maximum) */
+    level: 0 | 1 | 2 | 3 | 4;
+}
+export declare const DEFAULT_FOVEATED_CONFIG: FoveatedRenderingConfig;
+export interface FoveatedRegion {
+    /** Center position in NDC (-1 to 1) */
+    center: {
+        x: number;
+        y: number;
+    };
+    /** Inner radius (full quality) */
+    innerRadius: number;
+    /** Outer radius (minimum quality beyond this) */
+    outerRadius: number;
+    /** Quality multiplier at center */
+    qualityFactor: number;
+}
+export interface EyeTrackingConfig {
+    /** Enable eye tracking */
+    enabled: boolean;
+    /** Update rate in Hz */
+    updateRate: 60 | 90 | 120 | 240;
+    /** Enable gaze prediction */
+    prediction: boolean;
+    /** Prediction time (ms) */
+    predictionTime: number;
+    /** Smoothing factor (0 = none, 1 = heavy) */
+    smoothing: number;
+    /** Use eye tracking for foveated rendering */
+    foveatedRendering: boolean;
+}
+export declare const DEFAULT_EYE_TRACKING_CONFIG: EyeTrackingConfig;
+export interface EyeTrackingData {
+    /** Timestamp */
+    timestamp: number;
+    /** Left eye data */
+    left: EyeData;
+    /** Right eye data */
+    right: EyeData;
+    /** Combined gaze (binocular) */
+    combined: GazeData;
+    /** Eye openness (0-1) */
+    leftOpenness: number;
+    rightOpenness: number;
+    /** Pupil dilation (relative) */
+    leftPupilDilation: number;
+    rightPupilDilation: number;
+    /** Validity flags */
+    isValid: {
+        leftGaze: boolean;
+        rightGaze: boolean;
+        combinedGaze: boolean;
+        leftOpenness: boolean;
+        rightOpenness: boolean;
+        pupilDilation: boolean;
+    };
+}
+export interface EyeData {
+    /** Eye position in HMD space */
+    position: Vec3;
+    /** Gaze direction (normalized) */
+    gazeDirection: Vec3;
+    /** Gaze origin (eye position in world space) */
+    gazeOrigin: Vec3;
+}
+export interface GazeData {
+    /** Combined gaze origin */
+    origin: Vec3;
+    /** Combined gaze direction */
+    direction: Vec3;
+    /** Gaze point at given distance */
+    point?: Vec3;
+    /** Confidence (0-1) */
+    confidence: 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 HandJointData {
+    joint: HandJoint;
+    position: Vec3;
+    orientation: Quat;
+    radius: number;
+    linearVelocity?: Vec3;
+    angularVelocity?: Vec3;
+}
+export type GestureType = 'pinch' | 'grab' | 'point' | 'palm-open' | 'fist' | 'thumbs-up' | 'thumbs-down' | 'peace' | 'ok' | 'rock' | 'metal';
+export interface GestureData {
+    type: GestureType;
+    hand: 'left' | 'right';
+    confidence: number;
+    position: Vec3;
+    direction: Vec3;
+    progress?: number;
+}
+export interface GestureRecognizer {
+    /** Recognized gestures this frame */
+    gestures: GestureData[];
+    /** Gesture event callbacks */
+    onGestureStart?: (gesture: GestureData) => void;
+    onGestureUpdate?: (gesture: GestureData) => void;
+    onGestureEnd?: (gesture: GestureData) => void;
+}
+/** Detect pinch gesture */
+export declare function detectPinchGesture(joints: Map<HandJoint, HandJointData>): GestureData | null;
+/** Detect grab gesture */
+export declare function detectGrabGesture(joints: Map<HandJoint, HandJointData>): GestureData | null;
+export interface PassthroughConfig {
+    /** Enable passthrough */
+    enabled: boolean;
+    /** Passthrough mode */
+    mode: 'blend' | 'additive' | 'alpha-blend';
+    /** Opacity (0-1) */
+    opacity: number;
+    /** Brightness adjustment (-1 to 1) */
+    brightness: number;
+    /** Contrast adjustment (-1 to 1) */
+    contrast: number;
+    /** Saturation (0 = grayscale, 1 = normal, 2 = vivid) */
+    saturation: number;
+    /** Edge enhancement */
+    edgeEnhancement: number;
+    /** Color LUT (lookup table) for stylization */
+    colorLUT?: Float32Array;
+}
+export declare const DEFAULT_PASSTHROUGH_CONFIG: PassthroughConfig;
+export interface DepthSensingConfig {
+    /** Enable depth sensing */
+    enabled: boolean;
+    /** Usage hint */
+    usagePreference: 'cpu-optimized' | 'gpu-optimized';
+    /** Data format */
+    dataFormat: 'luminance-alpha' | 'float32';
+    /** Near plane (meters) */
+    nearPlane: number;
+    /** Far plane (meters) */
+    farPlane: number;
+}
+export declare const DEFAULT_DEPTH_CONFIG: DepthSensingConfig;
+export interface DepthData {
+    /** Depth texture */
+    texture: GPUTexture | null;
+    /** Raw depth values */
+    rawData?: Float32Array | Uint16Array;
+    /** Texture width */
+    width: number;
+    /** Texture height */
+    height: number;
+    /** Normalization scale */
+    normScale: number;
+    /** Normalization offset */
+    normOffset: number;
+    /** Transform from depth to view space */
+    depthToViewTransform: Float32Array;
+}
+export interface SpatialAnchor {
+    /** Unique identifier */
+    id: string;
+    /** Anchor name */
+    name?: string;
+    /** Position in world space */
+    position: Vec3;
+    /** Orientation */
+    orientation: Quat;
+    /** Anchor space */
+    anchorSpace: XRSpace | null;
+    /** Persistence ID (for cloud anchors) */
+    persistenceId?: string;
+    /** Is persistent (survives sessions) */
+    isPersistent: boolean;
+    /** Tracking state */
+    trackingState: 'tracking' | 'limited' | 'lost';
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface SpatialAnchorStore {
+    /** All anchors */
+    anchors: Map<string, SpatialAnchor>;
+    /** Pending anchor requests */
+    pending: Map<string, Promise<SpatialAnchor>>;
+    /** Create anchor at pose */
+    createAnchor(position: Vec3, orientation: Quat, name?: string): Promise<SpatialAnchor>;
+    /** Delete anchor */
+    deleteAnchor(id: string): Promise<void>;
+    /** Persist anchor to cloud */
+    persistAnchor(id: string): Promise<string>;
+    /** Load persisted anchors */
+    loadPersistedAnchors(): Promise<SpatialAnchor[]>;
+    /** Query anchors in radius */
+    queryAnchors(position: Vec3, radius: number): SpatialAnchor[];
+}
+export interface XRLayersManager {
+    /** Active layers */
+    layers: Map<string, XRCompositionLayer>;
+    /** Layer render order */
+    renderOrder: string[];
+    /** Create a quad layer */
+    createQuadLayer(config: XRQuadLayerConfig): Promise<string>;
+    /** Create a cylinder layer */
+    createCylinderLayer(config: XRCylinderLayerConfig): Promise<string>;
+    /** Create an equirect layer */
+    createEquirectLayer(config: XREquirectLayerConfig): Promise<string>;
+    /** Create a cube layer */
+    createCubeLayer(config: XRCubeLayerConfig): Promise<string>;
+    /** Update layer transform */
+    updateLayerTransform(id: string, transform: {
+        position: Vec3;
+        orientation: Quat;
+    }): void;
+    /** Update layer texture */
+    updateLayerTexture(id: string, texture: GPUTexture | ImageBitmap): void;
+    /** Remove a layer */
+    removeLayer(id: string): void;
+    /** Set layer render order */
+    setRenderOrder(order: string[]): void;
+}
+/** XR Composition Layer type */
+export type XRCompositionLayer = XRProjectionLayer | XRQuadLayer | XRCylinderLayer | XREquirectLayer | XRCubeLayer;
+export interface XRSessionFeatures {
+    /** Required features */
+    required: XRFeature[];
+    /** Optional features */
+    optional: XRFeature[];
+}
+export type XRFeature = 'local' | 'local-floor' | 'bounded-floor' | 'unbounded' | 'viewer' | 'hand-tracking' | 'eye-tracking' | 'depth-sensing' | 'dom-overlay' | 'hit-test' | 'light-estimation' | 'anchors' | 'camera-access' | 'mesh-detection' | 'plane-detection' | 'layers';
+export declare const VR_SESSION_FEATURES: XRSessionFeatures;
+export declare const AR_SESSION_FEATURES: XRSessionFeatures;
+export declare const MR_SESSION_FEATURES: XRSessionFeatures;

package/dist/types/xr/index.d.ts

@@ -1 +1,2 @@
 export * from './ARVR';
+export { DEFAULT_FOVEATED_CONFIG, DEFAULT_EYE_TRACKING_CONFIG, DEFAULT_PASSTHROUGH_CONFIG, DEFAULT_DEPTH_CONFIG, VR_SESSION_FEATURES, AR_SESSION_FEATURES, MR_SESSION_FEATURES, detectPinchGesture, detectGrabGesture, type XRLayerType, type XRLayerConfig, type XRTextureFormat, type XRQuadLayerConfig, type XRCylinderLayerConfig, type XREquirectLayerConfig, type XRCubeLayerConfig, type FoveatedRenderingConfig, type FoveatedRegion, type EyeTrackingConfig, type EyeTrackingData, type EyeData, type GazeData, type HandJoint, type HandJointData, type GestureType, type GestureData, type GestureRecognizer, type PassthroughConfig, type DepthSensingConfig, type DepthData, type SpatialAnchor, type SpatialAnchorStore, type XRLayersManager, type XRCompositionLayer, type XRSessionFeatures, type XRFeature, } from './WebXRLayers';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice2dev/game-engine",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "Nice2Dev Game Engine — No-code game engine and editor for React",
   "author": "NiceToDev <contact@nicetodev.com>",
   "license": "SEE LICENSE IN LICENSE",
@@ -22,8 +22,7 @@
       "types": "./dist/types/index.d.ts",
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js"
-    },
-    "./style.css": "./dist/nice2dev-game-engine.css"
+    }
   },
   "files": [
     "dist",
@@ -36,7 +35,7 @@
   ],
   "scripts": {
     "build": "npm run build:types && rollup -c",
-    "build:types": "tsc --noEmit",
+    "build:types": "tsc -p tsconfig.types.json",
     "build:full": "npm run build:types && rollup -c",
     "dev": "rollup -c -w",
     "demo": "vite --config vite.demo.config.ts",
@@ -73,7 +72,7 @@
   },
   "devDependencies": {
     "@microsoft/signalr": "^10.0.11",
-    "@nice2dev/ui": "^1.1.5",
+    "@nice2dev/ui": "^1.1.6",
     "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",