@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,71 +0,0 @@
-export interface WebGPUConfig {
-    maxWorkGroupSize: number;
-    preferredFormat: string;
-    powerPreference: 'low-power' | 'high-performance';
-}
-export interface ComputeBuffer {
-    gpuBuffer: GPUBuffer | null;
-    size: number;
-    usage: number;
-    data: Float32Array | Uint32Array;
-}
-export interface ComputePipeline {
-    id: string;
-    shaderSource: string;
-    entryPoint: string;
-    workGroupSize: [number, number, number];
-}
-export interface PhysicsBroadphaseResult {
-    pairs: [number, number][];
-    count: number;
-}
-export declare class WebGPUContext {
-    private device;
-    private adapter;
-    private config;
-    private pipelines;
-    constructor(config?: Partial<WebGPUConfig>);
-    init(): Promise<boolean>;
-    get isAvailable(): boolean;
-    getDevice(): GPUDevice;
-    createBuffer(data: Float32Array | Uint32Array, usage: number): GPUBuffer;
-    createComputePipeline(id: string, shaderSource: string, entryPoint?: string): GPUComputePipeline;
-    getPipeline(id: string): GPUComputePipeline | undefined;
-    readBuffer(buffer: GPUBuffer, size: number): Promise<ArrayBuffer>;
-    destroy(): void;
-}
-export declare class GPUPhysicsBroadphase {
-    private ctx;
-    private pipeline;
-    constructor(ctx: WebGPUContext);
-    init(): void;
-    computePairs(aabbs: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    }[]): Promise<PhysicsBroadphaseResult>;
-}
-export declare class GPUParticleSystem {
-    private ctx;
-    private pipeline;
-    private particleBuffer;
-    private maxParticles;
-    constructor(ctx: WebGPUContext, maxParticles?: number);
-    init(): void;
-    update(dt: number, gravity?: {
-        x: number;
-        y: number;
-    }): Promise<void>;
-    readParticles(): Promise<Float32Array>;
-    destroy(): void;
-}
-export declare class GPUPathfinder {
-    private ctx;
-    private pipeline;
-    constructor(ctx: WebGPUContext);
-    init(): void;
-    computeDistanceField(costGrid: number[][], targetX: number, targetY: number, maxIterations?: number): Promise<number[][]>;
-}
-export declare function isWebGPUAvailable(): Promise<boolean>;
-export declare function getWebGPUShaders(): Record<string, string>;

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

@@ -1 +0,0 @@
-export * from './Performance';

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

@@ -1,404 +0,0 @@
-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,2 +0,0 @@
-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/plugins/index.d.ts

@@ -1,2 +0,0 @@
-export * from './PluginSDK';
-export * from './PluginTestKit';

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

@@ -1,2 +0,0 @@
-export { SeededRandom, PerlinNoise, WaveGenerator, LootTable, ProceduralSprite, } from './Procedural';
-export type { WaveEntry, WaveConfig, LootDrop } from './Procedural';

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

@@ -1 +0,0 @@
-export * from './Release';

package/dist/types/rendering/WebGPUv2.d.ts

@@ -1,173 +0,0 @@
-export interface WebGPUv2Features {
-    /** Timestamp queries for profiling */
-    timestampQuery: boolean;
-    /** Indirect multi-draw */
-    indirectFirstInstance: boolean;
-    /** Shader f16 support */
-    shaderF16: boolean;
-    /** Depth clip control */
-    depthClipControl: boolean;
-    /** RG11B10 storage textures */
-    rg11b10Storage: boolean;
-    /** BGRA read-write storage */
-    bgraStorage: boolean;
-    /** Float32 filterable textures */
-    float32Filterable: boolean;
-    /** Subgroups extension */
-    subgroups: boolean;
-    /** Max texture dimension */
-    maxTextureDimension: number;
-    /** Max bind groups */
-    maxBindGroups: number;
-    /** Max storage buffers per shader stage */
-    maxStorageBuffers: number;
-    /** Max compute workgroup size */
-    maxComputeWorkgroupSize: [number, number, number];
-}
-export declare function detectWebGPUv2Features(device: GPUDevice): Promise<WebGPUv2Features>;
-export interface BindlessTextureArray {
-    textureArray: GPUTexture;
-    sampler: GPUSampler;
-    bindGroup: GPUBindGroup;
-    layout: GPUBindGroupLayout;
-    capacity: number;
-    usedSlots: number;
-    slotMap: Map<string, number>;
-}
-export interface BindlessTextureConfig {
-    width: number;
-    height: number;
-    layers: number;
-    format: GPUTextureFormat;
-    mipLevelCount?: number;
-    sampleCount?: 1 | 4;
-}
-export declare function createBindlessTextureArray(device: GPUDevice, config: BindlessTextureConfig): BindlessTextureArray;
-export interface DrawIndirectCommand {
-    vertexCount: number;
-    instanceCount: number;
-    firstVertex: number;
-    firstInstance: number;
-}
-export interface DrawIndexedIndirectCommand {
-    indexCount: number;
-    instanceCount: number;
-    firstIndex: number;
-    baseVertex: number;
-    firstInstance: number;
-}
-export interface GPUDrivenRenderer {
-    /** Buffer for indirect draw commands */
-    drawBuffer: GPUBuffer;
-    /** Buffer for instance data */
-    instanceBuffer: GPUBuffer;
-    /** Buffer for visibility results (from culling) */
-    visibilityBuffer: GPUBuffer;
-    /** Compute pipeline for GPU culling */
-    cullPipeline: GPUComputePipeline;
-    /** Compute pipeline for compaction */
-    compactPipeline: GPUComputePipeline;
-    /** Max draw calls per frame */
-    maxDrawCalls: number;
-    /** Max instances total */
-    maxInstances: number;
-}
-export interface CullUniforms {
-    viewProjectionMatrix: Float32Array;
-    frustumPlanes: Float32Array;
-    cameraPosition: Float32Array;
-    lodDistances: Float32Array;
-}
-/** WGSL compute shader for frustum culling */
-export declare const GPU_CULL_SHADER = "\nstruct CullUniforms {\n  viewProj: mat4x4<f32>,\n  frustum0: vec4<f32>,\n  frustum1: vec4<f32>,\n  frustum2: vec4<f32>,\n  frustum3: vec4<f32>,\n  frustum4: vec4<f32>,\n  frustum5: vec4<f32>,\n  cameraPos: vec4<f32>,\n  lodDistances: vec4<f32>,\n}\n\nstruct InstanceData {\n  modelMatrix: mat4x4<f32>,\n  boundingSphere: vec4<f32>, // xyz = center, w = radius\n  lodLevel: u32,\n  meshIndex: u32,\n  materialIndex: u32,\n  flags: u32,\n}\n\nstruct DrawCommand {\n  vertexCount: u32,\n  instanceCount: atomic<u32>,\n  firstVertex: u32,\n  firstInstance: u32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CullUniforms;\n@group(0) @binding(1) var<storage, read> instances: array<InstanceData>;\n@group(0) @binding(2) var<storage, read_write> drawCommands: array<DrawCommand>;\n@group(0) @binding(3) var<storage, read_write> visibleInstances: array<u32>;\n@group(0) @binding(4) var<storage, read_write> visibilityCount: atomic<u32>;\n\nfn isInsideFrustum(sphere: vec4<f32>) -> bool {\n  let planes = array<vec4<f32>, 6>(\n    uniforms.frustum0, uniforms.frustum1, uniforms.frustum2,\n    uniforms.frustum3, uniforms.frustum4, uniforms.frustum5\n  );\n  \n  for (var i = 0u; i < 6u; i++) {\n    let dist = dot(planes[i].xyz, sphere.xyz) + planes[i].w;\n    if (dist < -sphere.w) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfn computeLOD(worldPos: vec3<f32>) -> u32 {\n  let dist = distance(worldPos, uniforms.cameraPos.xyz);\n  if (dist < uniforms.lodDistances.x) { return 0u; }\n  if (dist < uniforms.lodDistances.y) { return 1u; }\n  if (dist < uniforms.lodDistances.z) { return 2u; }\n  return 3u;\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let instanceIndex = gid.x;\n  if (instanceIndex >= arrayLength(&instances)) {\n    return;\n  }\n  \n  let instance = instances[instanceIndex];\n  \n  // Transform bounding sphere to world space\n  let worldCenter = (instance.modelMatrix * vec4<f32>(instance.boundingSphere.xyz, 1.0)).xyz;\n  let worldSphere = vec4<f32>(worldCenter, instance.boundingSphere.w);\n  \n  // Frustum cull\n  if (!isInsideFrustum(worldSphere)) {\n    return;\n  }\n  \n  // Compute LOD\n  let lod = computeLOD(worldCenter);\n  \n  // Add to visible instances\n  let slot = atomicAdd(&visibilityCount, 1u);\n  visibleInstances[slot] = instanceIndex;\n  \n  // Increment instance count for draw command\n  atomicAdd(&drawCommands[instance.meshIndex].instanceCount, 1u);\n}\n";
-export declare function createGPUDrivenRenderer(device: GPUDevice, maxDrawCalls: number, maxInstances: number): Promise<GPUDrivenRenderer>;
-export type ShadingRate = '1x1' | '1x2' | '2x1' | '2x2' | '2x4' | '4x2' | '4x4';
-export interface VRSConfig {
-    /** Enable VRS */
-    enabled: boolean;
-    /** Default shading rate */
-    defaultRate: ShadingRate;
-    /** Use velocity-based adaptive VRS */
-    velocityAdaptive: boolean;
-    /** Use luminance-based adaptive VRS */
-    luminanceAdaptive: boolean;
-    /** Edge detection for fine detail preservation */
-    edgePreservation: boolean;
-    /** Foveated regions (for VR) */
-    foveatedRegions?: FoveatedRegion[];
-}
-export interface FoveatedRegion {
-    centerX: number;
-    centerY: number;
-    innerRadius: number;
-    middleRadius: number;
-    outerRadius: number;
-    innerRate: ShadingRate;
-    middleRate: ShadingRate;
-    outerRate: ShadingRate;
-}
-export declare const DEFAULT_VRS_CONFIG: VRSConfig;
-/** WGSL shader for generating VRS rate image */
-export declare const VRS_RATE_SHADER = "\nstruct VRSParams {\n  enableVelocity: u32,\n  enableLuminance: u32,\n  enableEdge: u32,\n  defaultRate: u32,\n  screenSize: vec2<f32>,\n  foveaCenter: vec2<f32>,\n  foveaRadii: vec4<f32>, // inner, middle, outer, _\n}\n\n@group(0) @binding(0) var<uniform> params: VRSParams;\n@group(0) @binding(1) var velocityTex: texture_2d<f32>;\n@group(0) @binding(2) var depthTex: texture_2d<f32>;\n@group(0) @binding(3) var rateOutput: texture_storage_2d<r8uint, write>;\n\nfn velocityToRate(velocity: vec2<f32>) -> u32 {\n  let speed = length(velocity);\n  if (speed < 0.01) { return 0u; } // 1x1\n  if (speed < 0.05) { return 1u; } // 1x2\n  if (speed < 0.1) { return 3u; }  // 2x2\n  return 7u; // 4x4\n}\n\nfn foveaToRate(uv: vec2<f32>) -> u32 {\n  let dist = distance(uv, params.foveaCenter);\n  if (dist < params.foveaRadii.x) { return 0u; } // 1x1\n  if (dist < params.foveaRadii.y) { return 1u; } // 1x2\n  if (dist < params.foveaRadii.z) { return 3u; } // 2x2\n  return 7u; // 4x4\n}\n\n@compute @workgroup_size(8, 8)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let screenPos = vec2<i32>(gid.xy);\n  let uv = vec2<f32>(gid.xy) / params.screenSize;\n  \n  var rate = params.defaultRate;\n  \n  // Foveated rendering (highest priority)\n  if (params.foveaRadii.w > 0.0) {\n    rate = max(rate, foveaToRate(uv));\n  }\n  \n  // Velocity-based\n  if (params.enableVelocity != 0u) {\n    let velocity = textureLoad(velocityTex, screenPos, 0).xy;\n    rate = max(rate, velocityToRate(velocity));\n  }\n  \n  textureStore(rateOutput, screenPos, vec4<u32>(rate, 0u, 0u, 0u));\n}\n";
-export interface RTAccelerationStructure {
-    /** BVH nodes buffer */
-    bvhBuffer: GPUBuffer;
-    /** Triangle data buffer */
-    triangleBuffer: GPUBuffer;
-    /** Instance transforms buffer */
-    instanceBuffer: GPUBuffer;
-    /** Compute pipeline for ray-BVH traversal */
-    traversalPipeline: GPUComputePipeline;
-    /** Total triangles */
-    triangleCount: number;
-    /** Total instances */
-    instanceCount: number;
-}
-export interface BVHNode {
-    boundsMin: [number, number, number];
-    boundsMax: [number, number, number];
-    leftChild: number;
-    rightChild: number;
-    firstTriangle: number;
-    triangleCount: number;
-}
-export interface RTConfig {
-    /** Max ray bounces */
-    maxBounces: number;
-    /** Samples per pixel */
-    samplesPerPixel: number;
-    /** Use importance sampling */
-    importanceSampling: boolean;
-    /** Enable soft shadows */
-    softShadows: boolean;
-    /** Enable ambient occlusion */
-    ambientOcclusion: boolean;
-    /** Enable global illumination */
-    globalIllumination: boolean;
-    /** Denoiser enabled */
-    denoiser: boolean;
-}
-export declare const DEFAULT_RT_CONFIG: RTConfig;
-/** BVH construction (SAH-based) */
-export declare function buildBVH(triangles: Float32Array, triangleCount: number): {
-    nodes: BVHNode[];
-    reorderedTriangles: Float32Array;
-};
-export interface TAAConfig {
-    /** Enable TAA */
-    enabled: boolean;
-    /** Jitter sample count (8 or 16) */
-    jitterSamples: 8 | 16;
-    /** Blend factor (0.9 = 90% history, 10% current) */
-    blendFactor: number;
-    /** Velocity rejection threshold */
-    velocityRejection: number;
-    /** Enable sharpening pass */
-    sharpen: boolean;
-    /** Sharpening strength */
-    sharpenStrength: number;
-}
-export declare const DEFAULT_TAA_CONFIG: TAAConfig;
-/** Halton sequence for jitter offsets */
-export declare function haltonSequence(index: number, base: number): number;
-export declare function generateJitterOffsets(sampleCount: 8 | 16): [number, number][];

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

@@ -1,3 +0,0 @@
-export { Camera2D, type CameraShake } from './Camera2D';
-export { Renderer2D, RenderSystem, type RenderStats } from './Renderer2D';
-export { detectWebGPUv2Features, createBindlessTextureArray, createGPUDrivenRenderer, buildBVH, haltonSequence, generateJitterOffsets, GPU_CULL_SHADER, VRS_RATE_SHADER, DEFAULT_VRS_CONFIG, DEFAULT_RT_CONFIG, DEFAULT_TAA_CONFIG, type WebGPUv2Features, type BindlessTextureArray, type BindlessTextureConfig, type GPUDrivenRenderer, type CullUniforms, type VRSConfig, type FoveatedRegion, type ShadingRate, type RTAccelerationStructure, type BVHNode, type RTConfig, type TAAConfig, type DrawIndirectCommand, type DrawIndexedIndirectCommand, } from './WebGPUv2';

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

@@ -1,2 +0,0 @@
-export * from './Runtime3D';
-export * from './SceneEditor3D';

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

@@ -1,2 +0,0 @@
-export { SceneManager } from './SceneManager';
-export type { SceneConfig, SceneTransition, TransitionType, PrefabDef } from './SceneManager';