@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/performance/WebGPURenderer.d.ts

@@ -0,0 +1,209 @@
+/**
+ * @file WebGPURenderer.ts
+ * @description Next-gen rendering backend using WebGPU
+ * PRO-1.5: Runtime & Performance
+ *
+ * Features:
+ * - WebGPU initialization
+ * - Render pipeline management
+ * - Shader compilation
+ * - Buffer management
+ * - Texture handling
+ * - Compute shaders
+ * - Multi-pass rendering
+ * - Instanced rendering
+ * - Bindless resources
+ */
+export type ShaderStage = 'vertex' | 'fragment' | 'compute';
+export type BufferUsage = 'vertex' | 'index' | 'uniform' | 'storage' | 'indirect' | 'query';
+export type TextureFormat = 'rgba8unorm' | 'rgba8snorm' | 'rgba16float' | 'rgba32float' | 'depth24plus' | 'depth32float' | 'depth24plus-stencil8';
+export type TextureUsage = 'sampled' | 'storage' | 'render_target' | 'copy_src' | 'copy_dst';
+export type PrimitiveTopology = 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
+export type CullMode = 'none' | 'front' | 'back';
+export type BlendMode = 'none' | 'alpha' | 'additive' | 'multiply' | 'screen';
+export interface ShaderSource {
+    code: string;
+    stage: ShaderStage;
+    entryPoint: string;
+}
+export interface VertexAttribute {
+    name: string;
+    format: GPUVertexFormat;
+    offset: number;
+    shaderLocation: number;
+}
+export interface VertexLayout {
+    stride: number;
+    stepMode: 'vertex' | 'instance';
+    attributes: VertexAttribute[];
+}
+export interface PipelineDescriptor {
+    id: string;
+    vertex: ShaderSource;
+    fragment?: ShaderSource;
+    vertexLayout: VertexLayout[];
+    primitive: {
+        topology: PrimitiveTopology;
+        cullMode: CullMode;
+        frontFace?: 'ccw' | 'cw';
+    };
+    depthStencil?: {
+        format: TextureFormat;
+        depthWrite: boolean;
+        depthCompare: GPUCompareFunction;
+    };
+    blend?: BlendMode;
+    colorFormat: TextureFormat;
+    multisample?: number;
+}
+export interface ComputePipelineDescriptor {
+    id: string;
+    shader: ShaderSource;
+    workgroupSize: [number, number, number];
+}
+export interface BufferDescriptor {
+    id: string;
+    size: number;
+    usage: BufferUsage[];
+    mappedAtCreation?: boolean;
+}
+export interface TextureDescriptor {
+    id: string;
+    width: number;
+    height: number;
+    depth?: number;
+    format: TextureFormat;
+    usage: TextureUsage[];
+    mipLevels?: number;
+    samples?: number;
+}
+export interface RenderPassDescriptor {
+    colorAttachments: {
+        view: GPUTextureView;
+        loadOp: 'load' | 'clear';
+        storeOp: 'store' | 'discard';
+        clearColor?: [number, number, number, number];
+    }[];
+    depthStencilAttachment?: {
+        view: GPUTextureView;
+        depthLoadOp: 'load' | 'clear';
+        depthStoreOp: 'store' | 'discard';
+        depthClearValue?: number;
+    };
+}
+export interface DrawCommand {
+    pipeline: string;
+    vertexBuffers: string[];
+    indexBuffer?: string;
+    indexFormat?: 'uint16' | 'uint32';
+    bindGroups: GPUBindGroup[];
+    vertexCount?: number;
+    indexCount?: number;
+    instanceCount?: number;
+    firstVertex?: number;
+    firstIndex?: number;
+    firstInstance?: number;
+}
+export interface DispatchCommand {
+    pipeline: string;
+    bindGroups: GPUBindGroup[];
+    workgroups: [number, number, number];
+}
+export interface RendererStats {
+    drawCalls: number;
+    triangles: number;
+    instances: number;
+    bufferUploads: number;
+    textureUploads: number;
+    pipelineSwitches: number;
+    bindGroupSwitches: number;
+    frameTime: number;
+    gpuTime?: number;
+}
+export interface RendererCapabilities {
+    maxTextureSize: number;
+    maxBufferSize: number;
+    maxBindGroups: number;
+    maxSamplers: number;
+    maxVertexBuffers: number;
+    maxVertexAttributes: number;
+    maxComputeWorkgroupSize: [number, number, number];
+    supportsTimestampQuery: boolean;
+    supportsIndirectFirstInstance: boolean;
+}
+export declare class WebGPURenderer {
+    private adapter;
+    private device;
+    private context;
+    private canvas;
+    private renderPipelines;
+    private computePipelines;
+    private buffers;
+    private textures;
+    private textureViews;
+    private samplers;
+    private shaderModules;
+    private bindGroupLayouts;
+    private pipelineLayouts;
+    private currentEncoder;
+    private currentRenderPass;
+    private currentComputePass;
+    private stats;
+    private onError?;
+    private onDeviceLost?;
+    initialize(canvas: HTMLCanvasElement): Promise<boolean>;
+    private getRequiredFeatures;
+    private getRequiredLimits;
+    isInitialized(): boolean;
+    getCapabilities(): RendererCapabilities | null;
+    createShaderModule(id: string, code: string): GPUShaderModule | null;
+    getShaderModule(id: string): GPUShaderModule | undefined;
+    createRenderPipeline(descriptor: PipelineDescriptor): GPURenderPipeline | null;
+    private getBlendState;
+    createComputePipeline(descriptor: ComputePipelineDescriptor): GPUComputePipeline | null;
+    getRenderPipeline(id: string): GPURenderPipeline | undefined;
+    getComputePipeline(id: string): GPUComputePipeline | undefined;
+    createBuffer(descriptor: BufferDescriptor): GPUBuffer | null;
+    writeBuffer(id: string, data: ArrayBuffer | ArrayBufferView, offset?: number): boolean;
+    getBuffer(id: string): GPUBuffer | undefined;
+    destroyBuffer(id: string): void;
+    createTexture(descriptor: TextureDescriptor): GPUTexture | null;
+    writeTexture(id: string, data: ArrayBuffer | ArrayBufferView, width: number, height: number, bytesPerRow?: number): boolean;
+    getTexture(id: string): GPUTexture | undefined;
+    getTextureView(id: string): GPUTextureView | undefined;
+    destroyTexture(id: string): void;
+    createSampler(id: string, options?: {
+        addressModeU?: GPUAddressMode;
+        addressModeV?: GPUAddressMode;
+        addressModeW?: GPUAddressMode;
+        magFilter?: GPUFilterMode;
+        minFilter?: GPUFilterMode;
+        mipmapFilter?: GPUMipmapFilterMode;
+        maxAnisotropy?: number;
+    }): GPUSampler | null;
+    getSampler(id: string): GPUSampler | undefined;
+    createBindGroup(pipeline: GPURenderPipeline | GPUComputePipeline, groupIndex: number, entries: GPUBindGroupEntry[]): GPUBindGroup | null;
+    beginFrame(): GPUCommandEncoder | null;
+    endFrame(): void;
+    beginRenderPass(descriptor: RenderPassDescriptor): GPURenderPassEncoder | null;
+    endRenderPass(): void;
+    draw(command: DrawCommand): void;
+    beginComputePass(): GPUComputePassEncoder | null;
+    endComputePass(): void;
+    dispatch(command: DispatchCommand): void;
+    getCurrentTexture(): GPUTexture | null;
+    getCurrentTextureView(): GPUTextureView | null;
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    } | null;
+    resize(width: number, height: number): void;
+    private resetStats;
+    getStats(): RendererStats;
+    destroy(): void;
+    setOnError(callback: (error: Error) => void): void;
+    setOnDeviceLost(callback: () => void): void;
+}
+export declare function createWebGPURenderer(): WebGPURenderer;
+export declare function createPipelineDescriptor(id: string, vertexCode: string, fragmentCode: string, options?: Partial<Omit<PipelineDescriptor, 'id' | 'vertex' | 'fragment'>>): PipelineDescriptor;
+export declare function isWebGPUSupported(): Promise<boolean>;

package/dist/types/physics/PhysicsEngine2D.d.ts

@@ -1,6 +1,5 @@
-import type { Vec2 } from '../core/types';
 import { EventBus } from '../core/EventBus';
-import type { EntityId } from '../core/types';
+import type { Vec2, EntityId } from '../core/types';
 import { World, System } from '../ecs/World';
 export interface CollisionInfo {
     entityA: EntityId;

package/dist/types/physics/RapierIntegration.d.ts

@@ -0,0 +1,404 @@
+export type Vec3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type Quat = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+export type RigidBodyType = 'dynamic' | 'static' | 'kinematic-position' | 'kinematic-velocity';
+export type ColliderShape = {
+    type: 'ball';
+    radius: number;
+} | {
+    type: 'box';
+    halfExtents: Vec3;
+} | {
+    type: 'capsule';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'cylinder';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'cone';
+    halfHeight: number;
+    radius: number;
+} | {
+    type: 'convexHull';
+    points: Float32Array;
+} | {
+    type: 'trimesh';
+    vertices: Float32Array;
+    indices: Uint32Array;
+} | {
+    type: 'heightfield';
+    heights: Float32Array;
+    rows: number;
+    cols: number;
+    scale: Vec3;
+};
+export type JointType = 'revolute' | 'prismatic' | 'spherical' | 'fixed' | 'rope' | 'spring' | 'generic';
+export interface RapierWorldConfig {
+    /** Gravity vector */
+    gravity: Vec3;
+    /** Integration parameters */
+    integration?: IntegrationParameters;
+    /** Broad phase algorithm */
+    broadPhase?: 'sweep-and-prune' | 'quadtree';
+    /** CCD (Continuous Collision Detection) enabled */
+    ccdEnabled?: boolean;
+    /** Sub-stepping for stability */
+    substeps?: number;
+    /** Maximum velocity iterations */
+    maxVelocityIterations?: number;
+    /** Maximum position iterations */
+    maxPositionIterations?: number;
+}
+export interface IntegrationParameters {
+    /** Time step (fixed) */
+    dt: number;
+    /** Minimum CCD dt */
+    minCcdDt: number;
+    /** Error reduction parameter */
+    erp: number;
+    /** Joint error reduction */
+    jointErp: number;
+    /** Warm start coefficient */
+    warmstartCoeff: number;
+    /** Allowed linear error */
+    allowedLinearError: number;
+    /** Max penetration correction */
+    maxPenetrationCorrection: number;
+    /** Prediction distance */
+    predictionDistance: number;
+    /** Max velocity iterations */
+    maxVelocityIterations: number;
+    /** Max velocity friction iterations */
+    maxVelocityFrictionIterations: number;
+    /** Max stabilization iterations */
+    maxStabilizationIterations: number;
+}
+export declare const DEFAULT_INTEGRATION_PARAMS: IntegrationParameters;
+export declare const DEFAULT_WORLD_CONFIG: RapierWorldConfig;
+export interface RigidBodyDescriptor {
+    /** Body type */
+    type: RigidBodyType;
+    /** Initial position */
+    position: Vec3;
+    /** Initial rotation (quaternion) */
+    rotation: Quat;
+    /** Linear velocity */
+    linearVelocity?: Vec3;
+    /** Angular velocity */
+    angularVelocity?: Vec3;
+    /** Gravity scale (1.0 = normal) */
+    gravityScale?: number;
+    /** Linear damping */
+    linearDamping?: number;
+    /** Angular damping */
+    angularDamping?: number;
+    /** Enable CCD for fast-moving objects */
+    ccdEnabled?: boolean;
+    /** CCD prediction distance */
+    ccdPrediction?: number;
+    /** Enable sleeping for optimization */
+    canSleep?: boolean;
+    /** Sleeping thresholds */
+    sleepThresholds?: {
+        linearVelocity: number;
+        angularVelocity: number;
+    };
+    /** User data (entity ID, etc.) */
+    userData?: unknown;
+}
+export interface ColliderDescriptor {
+    /** Shape definition */
+    shape: ColliderShape;
+    /** Density for mass calculation */
+    density?: number;
+    /** Friction coefficient */
+    friction?: number;
+    /** Restitution (bounciness) */
+    restitution?: number;
+    /** Collision groups (bitmask) */
+    collisionGroups?: number;
+    /** Solver groups (bitmask) */
+    solverGroups?: number;
+    /** Is sensor (trigger) */
+    isSensor?: boolean;
+    /** Contact force event threshold */
+    contactForceEventThreshold?: number;
+    /** Position offset from rigid body */
+    positionOffset?: Vec3;
+    /** Rotation offset from rigid body */
+    rotationOffset?: Quat;
+    /** User data */
+    userData?: unknown;
+}
+export interface JointDescriptor {
+    type: JointType;
+    body1: number;
+    body2: number;
+    anchor1: Vec3;
+    anchor2: Vec3;
+    axis1?: Vec3;
+    axis2?: Vec3;
+    limits?: JointLimits;
+    motor?: JointMotor;
+    stiffness?: number;
+    damping?: number;
+}
+export interface JointLimits {
+    min: number;
+    max: number;
+}
+export interface JointMotor {
+    targetVelocity?: number;
+    targetPosition?: number;
+    maxForce: number;
+    stiffness?: number;
+    damping?: number;
+}
+export interface RapierPhysicsWorld {
+    /** World handle (for WASM interop) */
+    handle: number;
+    /** Configuration */
+    config: RapierWorldConfig;
+    /** Body handles mapped to entity IDs */
+    bodyToEntity: Map<number, unknown>;
+    /** Entity IDs mapped to body handles */
+    entityToBody: Map<unknown, number>;
+    /** Collider handles */
+    colliders: Map<number, ColliderDescriptor>;
+    /** Joint handles */
+    joints: Map<number, JointDescriptor>;
+    /** Event queue */
+    eventQueue: PhysicsEventQueue;
+}
+export interface PhysicsEventQueue {
+    collisionStart: CollisionEvent[];
+    collisionEnd: CollisionEvent[];
+    contactForce: ContactForceEvent[];
+}
+export interface CollisionEvent {
+    handle1: number;
+    handle2: number;
+    started: boolean;
+}
+export interface ContactForceEvent {
+    handle1: number;
+    handle2: number;
+    totalForce: Vec3;
+    maxForceDirection: Vec3;
+    maxForceMagnitude: number;
+}
+export interface CharacterControllerConfig {
+    /** Capsule radius */
+    radius: number;
+    /** Capsule half-height */
+    halfHeight: number;
+    /** Step height (auto-step) */
+    maxStepHeight: number;
+    /** Slope limit (radians) */
+    maxSlopeAngle: number;
+    /** Skin width for collision detection */
+    skinWidth: number;
+    /** Snap to ground distance */
+    snapToGroundDistance: number;
+    /** Push force multiplier */
+    pushForce: number;
+    /** Slide on slopes */
+    slideOnSlopes: boolean;
+}
+export declare const DEFAULT_CHARACTER_CONFIG: CharacterControllerConfig;
+export interface CharacterControllerState {
+    position: Vec3;
+    velocity: Vec3;
+    isGrounded: boolean;
+    groundNormal: Vec3 | null;
+    isSlidingOnSlope: boolean;
+    lastGroundedTime: number;
+}
+export interface CharacterControllerInput {
+    desiredTranslation: Vec3;
+    jump?: boolean;
+    crouch?: boolean;
+}
+export declare function computeCharacterMovement(config: CharacterControllerConfig, state: CharacterControllerState, input: CharacterControllerInput, _dt: number): CharacterControllerState;
+export interface VehicleConfig {
+    /** Chassis mass */
+    chassisMass: number;
+    /** Chassis dimensions */
+    chassisHalfExtents: Vec3;
+    /** Chassis center of mass offset */
+    centerOfMassOffset: Vec3;
+    /** Wheel configurations */
+    wheels: WheelConfig[];
+    /** Maximum steering angle (radians) */
+    maxSteeringAngle: number;
+    /** Engine torque curve */
+    engineTorqueCurve: {
+        rpm: number;
+        torque: number;
+    }[];
+    /** Gear ratios */
+    gearRatios: number[];
+    /** Final drive ratio */
+    finalDriveRatio: number;
+    /** Drivetrain type */
+    driveType: 'fwd' | 'rwd' | 'awd';
+}
+export interface WheelConfig {
+    /** Wheel position relative to chassis */
+    position: Vec3;
+    /** Wheel radius */
+    radius: number;
+    /** Suspension rest length */
+    suspensionRestLength: number;
+    /** Suspension stiffness */
+    suspensionStiffness: number;
+    /** Suspension damping */
+    suspensionDamping: number;
+    /** Max suspension travel */
+    maxSuspensionTravel: number;
+    /** Is steering wheel */
+    isSteering: boolean;
+    /** Is drive wheel */
+    isDriven: boolean;
+    /** Brake force */
+    brakeForce: number;
+    /** Tire friction curve */
+    tireFriction: TireFrictionCurve;
+}
+export interface TireFrictionCurve {
+    /** Slip ratio at which max grip occurs */
+    peakSlipRatio: number;
+    /** Max grip coefficient */
+    peakGrip: number;
+    /** Grip at full slip */
+    fullSlipGrip: number;
+    /** Lateral stiffness */
+    lateralStiffness: number;
+}
+export interface VehicleState {
+    chassisPosition: Vec3;
+    chassisRotation: Quat;
+    chassisVelocity: Vec3;
+    chassisAngularVelocity: Vec3;
+    wheelStates: WheelState[];
+    currentGear: number;
+    engineRPM: number;
+    speed: number;
+}
+export interface WheelState {
+    suspensionCompression: number;
+    rotationAngle: number;
+    rotationSpeed: number;
+    steeringAngle: number;
+    isGrounded: boolean;
+    groundHit: {
+        position: Vec3;
+        normal: Vec3;
+        distance: number;
+    } | null;
+    slipRatio: number;
+    slipAngle: number;
+    lateralForce: number;
+    longitudinalForce: number;
+}
+export interface VehicleInput {
+    throttle: number;
+    brake: number;
+    steering: number;
+    handbrake: boolean;
+    gearUp: boolean;
+    gearDown: boolean;
+}
+export interface RaycastInput {
+    origin: Vec3;
+    direction: Vec3;
+    maxDistance: number;
+    solid?: boolean;
+    filterGroups?: number;
+    filterFlags?: QueryFilterFlags;
+}
+export interface RaycastHit {
+    point: Vec3;
+    normal: Vec3;
+    distance: number;
+    colliderHandle: number;
+    feature?: ColliderFeature;
+}
+export type ColliderFeature = {
+    type: 'vertex';
+    index: number;
+} | {
+    type: 'edge';
+    index: number;
+} | {
+    type: 'face';
+    index: number;
+};
+export interface ShapeCastInput {
+    shape: ColliderShape;
+    position: Vec3;
+    rotation: Quat;
+    direction: Vec3;
+    maxDistance: number;
+    filterGroups?: number;
+}
+export interface ShapeCastHit extends RaycastHit {
+    /** Time of impact (0-1) */
+    toi: number;
+    /** Witness points */
+    witness1: Vec3;
+    witness2: Vec3;
+}
+export type QueryFilterFlags = number;
+export declare const QUERY_FILTER: {
+    readonly EXCLUDE_STATIC: number;
+    readonly EXCLUDE_KINEMATIC: number;
+    readonly EXCLUDE_DYNAMIC: number;
+    readonly EXCLUDE_SENSORS: number;
+    readonly ONLY_DYNAMIC: number;
+    readonly ONLY_KINEMATIC: number;
+    readonly ONLY_STATIC: number;
+};
+export interface DebugRenderOptions {
+    /** Render rigid body AABBs */
+    renderAABBs: boolean;
+    /** Render collider shapes */
+    renderColliders: boolean;
+    /** Render contact points */
+    renderContacts: boolean;
+    /** Render joints */
+    renderJoints: boolean;
+    /** Render velocity vectors */
+    renderVelocities: boolean;
+    /** Colors */
+    colors: {
+        dynamic: [number, number, number, number];
+        static: [number, number, number, number];
+        kinematic: [number, number, number, number];
+        sleeping: [number, number, number, number];
+        contact: [number, number, number, number];
+        joint: [number, number, number, number];
+    };
+}
+export declare const DEFAULT_DEBUG_COLORS: DebugRenderOptions['colors'];
+export interface DebugRenderData {
+    vertices: Float32Array;
+    colors: Float32Array;
+    lineIndices: Uint32Array;
+}
+export declare function createBoxCollider(halfExtents: Vec3, options?: Partial<ColliderDescriptor>): ColliderDescriptor;
+export declare function createSphereCollider(radius: number, options?: Partial<ColliderDescriptor>): ColliderDescriptor;
+export declare function createCapsuleCollider(halfHeight: number, radius: number, options?: Partial<ColliderDescriptor>): ColliderDescriptor;
+export declare function createDynamicBody(position: Vec3, options?: Partial<RigidBodyDescriptor>): RigidBodyDescriptor;
+export declare function createStaticBody(position: Vec3, options?: Partial<RigidBodyDescriptor>): RigidBodyDescriptor;
+export declare function createKinematicBody(position: Vec3, options?: Partial<RigidBodyDescriptor>): RigidBodyDescriptor;

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

@@ -1 +1,2 @@
 export { PhysicsEngine2D, PhysicsSystem, type CollisionInfo, type RaycastHit, } from './PhysicsEngine2D';
+export { DEFAULT_INTEGRATION_PARAMS, DEFAULT_WORLD_CONFIG, DEFAULT_CHARACTER_CONFIG, DEFAULT_DEBUG_COLORS, QUERY_FILTER, createBoxCollider, createSphereCollider, createCapsuleCollider, createDynamicBody, createStaticBody, createKinematicBody, computeCharacterMovement, type Vec3, type Quat, type RigidBodyType, type ColliderShape, type JointType, type RapierWorldConfig, type IntegrationParameters, type RigidBodyDescriptor, type ColliderDescriptor, type JointDescriptor, type JointLimits, type JointMotor, type RapierPhysicsWorld, type PhysicsEventQueue, type CollisionEvent, type ContactForceEvent, type CharacterControllerConfig, type CharacterControllerState, type CharacterControllerInput, type VehicleConfig, type VehicleState, type VehicleInput, type WheelConfig, type WheelState, type TireFrictionCurve, type RaycastInput, type ShapeCastInput, type ShapeCastHit, type ColliderFeature, type QueryFilterFlags, type DebugRenderOptions, type DebugRenderData, } from './RapierIntegration';

package/dist/types/quest/QuestSystem.d.ts

@@ -1,6 +1,6 @@
-import type { EntityId } from '../core/types';
-import { EventBus } from '../core/EventBus';
 import React from 'react';
+import { EventBus } from '../core/EventBus';
+import type { EntityId } from '../core/types';
 /** Quest categories */
 export type QuestType = 'main' | 'side' | 'daily' | 'weekly' | 'achievement' | 'tutorial' | 'hidden';
 /** Quest status */