reze-engine 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# Reze Engine
+
+A lightweight engine built with WebGPU and TypeScript for real-time 3D anime character rendering, physics simulation, and semantic pose control.

package/dist/ammo-loader.d.ts

@@ -0,0 +1,4 @@
+import type { AmmoInstance } from "@fred3d/ammo";
+export declare function loadAmmo(): Promise<AmmoInstance>;
+export declare function getAmmoInstance(): AmmoInstance | null;
+//# sourceMappingURL=ammo-loader.d.ts.map

package/dist/ammo-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ammo-loader.d.ts","sourceRoot":"","sources":["../src/ammo-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAKhD,wBAAsB,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC,CAyBtD;AAED,wBAAgB,eAAe,IAAI,YAAY,GAAG,IAAI,CAErD"}

package/dist/ammo-loader.js

@@ -0,0 +1,29 @@
+let ammoInstance = null;
+let ammoPromise = null;
+export async function loadAmmo() {
+    // Return cached instance if available
+    if (ammoInstance) {
+        return ammoInstance;
+    }
+    // Return existing promise if already loading
+    if (ammoPromise) {
+        return ammoPromise;
+    }
+    // Start loading Ammo
+    ammoPromise = (async () => {
+        try {
+            const { Ammo } = await import("@fred3d/ammo");
+            ammoInstance = await Ammo();
+            return ammoInstance;
+        }
+        catch (error) {
+            console.error("[Ammo] Failed to load:", error);
+            ammoPromise = null; // Reset promise so it can be retried
+            throw error;
+        }
+    })();
+    return ammoPromise;
+}
+export function getAmmoInstance() {
+    return ammoInstance;
+}

package/dist/camera.d.ts

@@ -0,0 +1,46 @@
+import { Mat4, Vec3 } from "./math";
+export declare class Camera {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vec3;
+    fov: number;
+    aspect: number;
+    near: number;
+    far: number;
+    private canvas;
+    private isDragging;
+    private mouseButton;
+    private lastMousePos;
+    private lastTouchPos;
+    private touchIdentifier;
+    private isPinching;
+    private lastPinchDistance;
+    private lastPinchMidpoint;
+    private initialPinchDistance;
+    angularSensitivity: number;
+    panSensitivity: number;
+    wheelPrecision: number;
+    pinchPrecision: number;
+    minZ: number;
+    maxZ: number;
+    lowerBetaLimit: number;
+    upperBetaLimit: number;
+    constructor(alpha: number, beta: number, radius: number, target: Vec3, fov?: number);
+    getPosition(): Vec3;
+    getViewMatrix(): Mat4;
+    private getCameraVectors;
+    private panCamera;
+    getProjectionMatrix(): Mat4;
+    attachControl(canvas: HTMLCanvasElement): void;
+    detachControl(): void;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private onWheel;
+    private onContextMenu;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+}
+//# sourceMappingURL=camera.d.ts.map

package/dist/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAInC,qBAAa,MAAM;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,IAAI,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAI;IAClB,IAAI,EAAE,MAAM,CAAO;IACnB,GAAG,EAAE,MAAM,CAAM;IAGjB,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,WAAW,CAAsB;IACzC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,iBAAiB,CAAY;IACrC,OAAO,CAAC,iBAAiB,CAAiB;IAC1C,OAAO,CAAC,oBAAoB,CAAY;IAGxC,kBAAkB,EAAE,MAAM,CAAQ;IAClC,cAAc,EAAE,MAAM,CAAS;IAC/B,cAAc,EAAE,MAAM,CAAO;IAC7B,cAAc,EAAE,MAAM,CAAO;IAC7B,IAAI,EAAE,MAAM,CAAM;IAClB,IAAI,EAAE,MAAM,CAAM;IAClB,cAAc,EAAE,MAAM,CAAQ;IAC9B,cAAc,EAAE,MAAM,CAAkB;gBAE5B,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAE,MAAoB;IAkBhG,WAAW,IAAI,IAAI;IAQnB,aAAa,IAAI,IAAI;IAQrB,OAAO,CAAC,gBAAgB;IA0CxB,OAAO,CAAC,SAAS;IAiBjB,mBAAmB,IAAI,IAAI;IAI3B,aAAa,CAAC,MAAM,EAAE,iBAAiB;IAiBvC,aAAa;IAkBb,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,WAAW;IAqBnB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;IA6BpB,OAAO,CAAC,WAAW;IAiFnB,OAAO,CAAC,UAAU;CA+BnB"}

package/dist/camera.js

@@ -0,0 +1,303 @@
+import { Mat4, Vec3 } from "./math";
+const FAR = 1000;
+export class Camera {
+    constructor(alpha, beta, radius, target, fov = Math.PI / 4) {
+        this.aspect = 1;
+        this.near = 0.05;
+        this.far = FAR;
+        // Input state
+        this.canvas = null;
+        this.isDragging = false;
+        this.mouseButton = null; // Track which mouse button is pressed (0 = left, 2 = right)
+        this.lastMousePos = { x: 0, y: 0 };
+        this.lastTouchPos = { x: 0, y: 0 };
+        this.touchIdentifier = null;
+        this.isPinching = false;
+        this.lastPinchDistance = 0;
+        this.lastPinchMidpoint = { x: 0, y: 0 }; // Midpoint of two fingers for panning
+        this.initialPinchDistance = 0; // Initial distance when pinch started
+        // Camera settings
+        this.angularSensitivity = 0.005;
+        this.panSensitivity = 0.0002; // Sensitivity for right-click panning
+        this.wheelPrecision = 0.01;
+        this.pinchPrecision = 0.05;
+        this.minZ = 0.1;
+        this.maxZ = FAR;
+        this.lowerBetaLimit = 0.001;
+        this.upperBetaLimit = Math.PI - 0.001;
+        this.alpha = alpha;
+        this.beta = beta;
+        this.radius = radius;
+        this.target = target;
+        this.fov = fov;
+        // Bind event handlers
+        this.onMouseDown = this.onMouseDown.bind(this);
+        this.onMouseMove = this.onMouseMove.bind(this);
+        this.onMouseUp = this.onMouseUp.bind(this);
+        this.onWheel = this.onWheel.bind(this);
+        this.onContextMenu = this.onContextMenu.bind(this);
+        this.onTouchStart = this.onTouchStart.bind(this);
+        this.onTouchMove = this.onTouchMove.bind(this);
+        this.onTouchEnd = this.onTouchEnd.bind(this);
+    }
+    getPosition() {
+        // Convert spherical coordinates to Cartesian position
+        const x = this.target.x + this.radius * Math.sin(this.beta) * Math.sin(this.alpha);
+        const y = this.target.y + this.radius * Math.cos(this.beta);
+        const z = this.target.z + this.radius * Math.sin(this.beta) * Math.cos(this.alpha);
+        return new Vec3(x, y, z);
+    }
+    getViewMatrix() {
+        const eye = this.getPosition();
+        const up = new Vec3(0, 1, 0);
+        return Mat4.lookAt(eye, this.target, up);
+    }
+    // Get camera's right and up vectors for panning
+    // Uses a more robust calculation similar to BabylonJS
+    getCameraVectors() {
+        const eye = this.getPosition();
+        const forward = this.target.subtract(eye);
+        const forwardLen = forward.length();
+        // Handle edge case where camera is at target
+        if (forwardLen < 0.0001) {
+            return { right: new Vec3(1, 0, 0), up: new Vec3(0, 1, 0) };
+        }
+        const forwardNorm = forward.scale(1 / forwardLen);
+        const worldUp = new Vec3(0, 1, 0);
+        // Calculate right vector: right = worldUp × forward
+        // Use a more stable calculation that handles parallel vectors
+        let right = worldUp.cross(forwardNorm);
+        const rightLen = right.length();
+        // If forward is parallel to worldUp, use a fallback
+        if (rightLen < 0.0001) {
+            // Camera is looking straight up or down, use X-axis as right
+            right = new Vec3(1, 0, 0);
+        }
+        else {
+            right = right.scale(1 / rightLen);
+        }
+        // Calculate camera up vector: up = forward × right (ensures orthogonality)
+        let up = forwardNorm.cross(right);
+        const upLen = up.length();
+        if (upLen < 0.0001) {
+            // Fallback to world up
+            up = new Vec3(0, 1, 0);
+        }
+        else {
+            up = up.scale(1 / upLen);
+        }
+        return { right, up };
+    }
+    // Pan the camera target based on mouse movement
+    // Uses screen-space to world-space translation similar to BabylonJS
+    panCamera(deltaX, deltaY) {
+        const { right, up } = this.getCameraVectors();
+        // Calculate pan distance based on camera distance
+        // The pan amount is proportional to the camera distance (radius) for consistent feel
+        // This makes panning feel natural at all zoom levels
+        const panDistance = this.radius * this.panSensitivity;
+        // Horizontal movement: drag right pans left (opposite direction)
+        // Vertical movement: drag up pans up (positive up vector)
+        const panRight = right.scale(-deltaX * panDistance);
+        const panUp = up.scale(deltaY * panDistance);
+        // Update target position smoothly
+        this.target = this.target.add(panRight).add(panUp);
+    }
+    getProjectionMatrix() {
+        return Mat4.perspective(this.fov, this.aspect, this.near, this.far);
+    }
+    attachControl(canvas) {
+        this.canvas = canvas;
+        // Attach mouse event listeners
+        // mousedown on canvas, but move/up on window so dragging works everywhere
+        this.canvas.addEventListener("mousedown", this.onMouseDown);
+        window.addEventListener("mousemove", this.onMouseMove);
+        window.addEventListener("mouseup", this.onMouseUp);
+        this.canvas.addEventListener("wheel", this.onWheel, { passive: false });
+        this.canvas.addEventListener("contextmenu", this.onContextMenu);
+        // Attach touch event listeners for mobile
+        this.canvas.addEventListener("touchstart", this.onTouchStart, { passive: false });
+        window.addEventListener("touchmove", this.onTouchMove, { passive: false });
+        window.addEventListener("touchend", this.onTouchEnd);
+    }
+    detachControl() {
+        if (!this.canvas)
+            return;
+        // Remove mouse event listeners
+        this.canvas.removeEventListener("mousedown", this.onMouseDown);
+        window.removeEventListener("mousemove", this.onMouseMove);
+        window.removeEventListener("mouseup", this.onMouseUp);
+        this.canvas.removeEventListener("wheel", this.onWheel);
+        this.canvas.removeEventListener("contextmenu", this.onContextMenu);
+        // Remove touch event listeners
+        this.canvas.removeEventListener("touchstart", this.onTouchStart);
+        window.removeEventListener("touchmove", this.onTouchMove);
+        window.removeEventListener("touchend", this.onTouchEnd);
+        this.canvas = null;
+    }
+    onMouseDown(e) {
+        this.isDragging = true;
+        this.mouseButton = e.button;
+        this.lastMousePos = { x: e.clientX, y: e.clientY };
+    }
+    onMouseMove(e) {
+        if (!this.isDragging)
+            return;
+        const deltaX = e.clientX - this.lastMousePos.x;
+        const deltaY = e.clientY - this.lastMousePos.y;
+        if (this.mouseButton === 2) {
+            // Right-click: pan the camera target
+            this.panCamera(deltaX, deltaY);
+        }
+        else {
+            // Left-click (or default): rotate the camera
+            this.alpha += deltaX * this.angularSensitivity;
+            this.beta -= deltaY * this.angularSensitivity;
+            // Clamp beta to prevent flipping
+            this.beta = Math.max(this.lowerBetaLimit, Math.min(this.upperBetaLimit, this.beta));
+        }
+        this.lastMousePos = { x: e.clientX, y: e.clientY };
+    }
+    onMouseUp() {
+        this.isDragging = false;
+        this.mouseButton = null;
+    }
+    onWheel(e) {
+        e.preventDefault();
+        // Update camera radius (zoom)
+        this.radius += e.deltaY * this.wheelPrecision;
+        // Clamp radius to reasonable bounds
+        this.radius = Math.max(this.minZ, Math.min(this.maxZ, this.radius));
+        // Expand far plane to keep scene visible when zooming out
+        this.far = Math.max(FAR, this.radius * 4);
+    }
+    onContextMenu(e) {
+        e.preventDefault();
+    }
+    onTouchStart(e) {
+        e.preventDefault();
+        if (e.touches.length === 1) {
+            // Single touch - rotation
+            const touch = e.touches[0];
+            this.isDragging = true;
+            this.isPinching = false;
+            this.touchIdentifier = touch.identifier;
+            this.lastTouchPos = { x: touch.clientX, y: touch.clientY };
+        }
+        else if (e.touches.length === 2) {
+            // Two touches - can be pinch zoom or pan
+            this.isDragging = false;
+            this.isPinching = true;
+            const touch1 = e.touches[0];
+            const touch2 = e.touches[1];
+            const dx = touch2.clientX - touch1.clientX;
+            const dy = touch2.clientY - touch1.clientY;
+            this.lastPinchDistance = Math.sqrt(dx * dx + dy * dy);
+            this.initialPinchDistance = this.lastPinchDistance;
+            // Calculate initial midpoint for panning
+            this.lastPinchMidpoint = {
+                x: (touch1.clientX + touch2.clientX) / 2,
+                y: (touch1.clientY + touch2.clientY) / 2,
+            };
+        }
+    }
+    onTouchMove(e) {
+        e.preventDefault();
+        if (this.isPinching && e.touches.length === 2) {
+            // Two-finger gesture: can be pinch zoom or pan
+            const touch1 = e.touches[0];
+            const touch2 = e.touches[1];
+            const dx = touch2.clientX - touch1.clientX;
+            const dy = touch2.clientY - touch1.clientY;
+            const distance = Math.sqrt(dx * dx + dy * dy);
+            // Calculate current midpoint
+            const currentMidpoint = {
+                x: (touch1.clientX + touch2.clientX) / 2,
+                y: (touch1.clientY + touch2.clientY) / 2,
+            };
+            // Calculate distance change and midpoint movement
+            const distanceDelta = Math.abs(distance - this.lastPinchDistance);
+            const midpointDeltaX = currentMidpoint.x - this.lastPinchMidpoint.x;
+            const midpointDeltaY = currentMidpoint.y - this.lastPinchMidpoint.y;
+            const midpointDelta = Math.sqrt(midpointDeltaX * midpointDeltaX + midpointDeltaY * midpointDeltaY);
+            // Determine gesture type based on relative changes
+            // Calculate relative change in distance (as percentage of initial distance)
+            const distanceChangeRatio = distanceDelta / Math.max(this.initialPinchDistance, 10.0);
+            // Threshold: if distance changes more than 3% of initial, it's primarily a zoom gesture
+            // Otherwise, if midpoint moves significantly, it's a pan gesture
+            const ZOOM_THRESHOLD = 0.03;
+            const PAN_THRESHOLD = 2.0; // Minimum pixels of midpoint movement for pan
+            const isZoomGesture = distanceChangeRatio > ZOOM_THRESHOLD;
+            const isPanGesture = midpointDelta > PAN_THRESHOLD && distanceChangeRatio < ZOOM_THRESHOLD * 2;
+            if (isZoomGesture) {
+                // Primary gesture is zoom (pinch)
+                const delta = this.lastPinchDistance - distance;
+                this.radius += delta * this.pinchPrecision;
+                // Clamp radius to reasonable bounds
+                this.radius = Math.max(this.minZ, Math.min(this.maxZ, this.radius));
+                // Expand far plane for pinch zoom as well
+                this.far = Math.max(FAR, this.radius * 4);
+            }
+            if (isPanGesture) {
+                // Primary gesture is pan (two-finger drag)
+                // Use panning similar to right-click pan
+                this.panCamera(midpointDeltaX, midpointDeltaY);
+            }
+            // Update tracking values
+            this.lastPinchDistance = distance;
+            this.lastPinchMidpoint = currentMidpoint;
+        }
+        else if (this.isDragging && this.touchIdentifier !== null) {
+            // Single-finger rotation
+            // Find the touch we're tracking
+            let touch = null;
+            for (let i = 0; i < e.touches.length; i++) {
+                if (e.touches[i].identifier === this.touchIdentifier) {
+                    touch = e.touches[i];
+                    break;
+                }
+            }
+            if (!touch)
+                return;
+            const deltaX = touch.clientX - this.lastTouchPos.x;
+            const deltaY = touch.clientY - this.lastTouchPos.y;
+            this.alpha += deltaX * this.angularSensitivity;
+            this.beta -= deltaY * this.angularSensitivity;
+            // Clamp beta to prevent flipping
+            this.beta = Math.max(this.lowerBetaLimit, Math.min(this.upperBetaLimit, this.beta));
+            this.lastTouchPos = { x: touch.clientX, y: touch.clientY };
+        }
+    }
+    onTouchEnd(e) {
+        if (e.touches.length === 0) {
+            // All touches ended
+            this.isDragging = false;
+            this.isPinching = false;
+            this.touchIdentifier = null;
+            this.initialPinchDistance = 0;
+        }
+        else if (e.touches.length === 1 && this.isPinching) {
+            // Went from 2 fingers to 1 - switch to rotation
+            const touch = e.touches[0];
+            this.isPinching = false;
+            this.isDragging = true;
+            this.touchIdentifier = touch.identifier;
+            this.lastTouchPos = { x: touch.clientX, y: touch.clientY };
+            this.initialPinchDistance = 0;
+        }
+        else if (this.touchIdentifier !== null) {
+            // Check if our tracked touch ended
+            let touchStillActive = false;
+            for (let i = 0; i < e.touches.length; i++) {
+                if (e.touches[i].identifier === this.touchIdentifier) {
+                    touchStillActive = true;
+                    break;
+                }
+            }
+            if (!touchStillActive) {
+                this.isDragging = false;
+                this.touchIdentifier = null;
+            }
+        }
+    }
+}

package/dist/engine.d.ts

@@ -0,0 +1,88 @@
+import { Camera } from "./camera";
+import { Vec3 } from "./math";
+export interface EngineStats {
+    fps: number;
+    frameTime: number;
+    memoryUsed: number;
+    vertices: number;
+    drawCalls: number;
+    triangles: number;
+    materials: number;
+    textures: number;
+    textureMemory: number;
+    bufferMemory: number;
+    gpuMemory: number;
+}
+export declare class Engine {
+    private canvas;
+    private device;
+    private context;
+    private presentationFormat;
+    camera: Camera;
+    private cameraUniformBuffer;
+    private cameraMatrixData;
+    private lightUniformBuffer;
+    private lightData;
+    private lightCount;
+    private vertexBuffer;
+    private vertexCount;
+    private indexBuffer?;
+    private resizeObserver;
+    private depthTexture;
+    private pipeline;
+    private outlinePipeline;
+    private jointsBuffer;
+    private weightsBuffer;
+    private skinMatrixBuffer?;
+    private worldMatrixBuffer?;
+    private inverseBindMatrixBuffer?;
+    private skinMatrixComputePipeline?;
+    private boneCountBuffer?;
+    private multisampleTexture;
+    private readonly sampleCount;
+    private renderPassDescriptor;
+    private currentModel;
+    private modelDir;
+    private physics;
+    private textureSampler;
+    private textureCache;
+    private textureSizes;
+    private lastFpsUpdate;
+    private framesSinceLastUpdate;
+    private frameTimeSamples;
+    private frameTimeSum;
+    private drawCallCount;
+    private lastFrameTime;
+    private stats;
+    private animationFrameId;
+    private renderLoopCallback;
+    constructor(canvas: HTMLCanvasElement);
+    init(): Promise<void>;
+    private createPipelines;
+    private createSkinMatrixComputePipeline;
+    private setupResize;
+    private handleResize;
+    private setupCamera;
+    private setupLighting;
+    addLight(direction: Vec3, color: Vec3, intensity?: number): boolean;
+    setAmbient(intensity: number): void;
+    getStats(): EngineStats;
+    runRenderLoop(callback?: () => void): void;
+    stopRenderLoop(): void;
+    dispose(): void;
+    loadModel(path: string): Promise<void>;
+    private setupModelBuffers;
+    private materialDraws;
+    private outlineDraws;
+    private setupMaterials;
+    private createTextureFromPath;
+    render(): void;
+    private updateCameraUniforms;
+    private updateRenderTarget;
+    private updateModelPose;
+    private computeSkinMatrices;
+    private drawOutlines;
+    private drawModel;
+    private updateStats;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}