reze-engine 0.14.0 → 0.15.0

package/dist/physics/types.d.ts

@@ -0,0 +1,46 @@
+import { Vec3, Mat4 } from "../math";
+export declare enum RigidbodyShape {
+    Sphere = 0,
+    Box = 1,
+    Capsule = 2
+}
+export declare enum RigidbodyType {
+    Static = 0,
+    Dynamic = 1,
+    Kinematic = 2
+}
+export interface Rigidbody {
+    name: string;
+    englishName: string;
+    boneIndex: number;
+    group: number;
+    collisionMask: number;
+    shape: RigidbodyShape;
+    size: Vec3;
+    shapePosition: Vec3;
+    shapeRotation: Vec3;
+    mass: number;
+    linearDamping: number;
+    angularDamping: number;
+    restitution: number;
+    friction: number;
+    type: RigidbodyType;
+    bodyOffsetMatrixInverse: Mat4;
+    bodyOffsetMatrix?: Mat4;
+}
+export interface Joint {
+    name: string;
+    englishName: string;
+    type: number;
+    rigidbodyIndexA: number;
+    rigidbodyIndexB: number;
+    position: Vec3;
+    rotation: Vec3;
+    positionMin: Vec3;
+    positionMax: Vec3;
+    rotationMin: Vec3;
+    rotationMax: Vec3;
+    springPosition: Vec3;
+    springRotation: Vec3;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/physics/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEpC,oBAAY,cAAc;IACxB,MAAM,IAAI;IACV,GAAG,IAAI;IACP,OAAO,IAAI;CACZ;AAED,oBAAY,aAAa;IACvB,MAAM,IAAI;IACV,OAAO,IAAI;IACX,SAAS,IAAI;CACd;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,cAAc,CAAA;IACrB,IAAI,EAAE,IAAI,CAAA;IACV,aAAa,EAAE,IAAI,CAAA;IACnB,aAAa,EAAE,IAAI,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,uBAAuB,EAAE,IAAI,CAAA;IAC7B,gBAAgB,CAAC,EAAE,IAAI,CAAA;CACxB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,IAAI,CAAA;IACd,WAAW,EAAE,IAAI,CAAA;IACjB,WAAW,EAAE,IAAI,CAAA;IACjB,WAAW,EAAE,IAAI,CAAA;IACjB,WAAW,EAAE,IAAI,CAAA;IACjB,cAAc,EAAE,IAAI,CAAA;IACpB,cAAc,EAAE,IAAI,CAAA;CACrB"}

package/dist/physics/types.js

@@ -0,0 +1,12 @@
+export var RigidbodyShape;
+(function (RigidbodyShape) {
+    RigidbodyShape[RigidbodyShape["Sphere"] = 0] = "Sphere";
+    RigidbodyShape[RigidbodyShape["Box"] = 1] = "Box";
+    RigidbodyShape[RigidbodyShape["Capsule"] = 2] = "Capsule";
+})(RigidbodyShape || (RigidbodyShape = {}));
+export var RigidbodyType;
+(function (RigidbodyType) {
+    RigidbodyType[RigidbodyType["Static"] = 0] = "Static";
+    RigidbodyType[RigidbodyType["Dynamic"] = 1] = "Dynamic";
+    RigidbodyType[RigidbodyType["Kinematic"] = 2] = "Kinematic";
+})(RigidbodyType || (RigidbodyType = {}));

package/dist/physics/world.d.ts

@@ -0,0 +1,12 @@
+import { Vec3 } from "../math";
+import type { RigidBodyStore } from "./body";
+import type { SixDofSpringConstraint } from "./constraint";
+import { type ContactPool } from "./contact";
+export declare class World {
+    readonly gravity: Vec3;
+    solverIterations: number;
+    constructor(gravity: Vec3);
+    setGravity(g: Vec3): void;
+    step(store: RigidBodyStore, constraints: SixDofSpringConstraint[], contacts: ContactPool, dt: number): void;
+}
+//# sourceMappingURL=world.d.ts.map

package/dist/physics/world.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAE5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAO1D,qBAAa,KAAK;IAChB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;IACtB,gBAAgB,SAAK;gBAET,OAAO,EAAE,IAAI;IAIzB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAMzB,IAAI,CAAC,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,sBAAsB,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;CA6H5G"}

package/dist/physics/world.js

@@ -0,0 +1,146 @@
+import { Vec3 } from "../math";
+import { RigidbodyType } from "./types";
+import { solveConstraints } from "./solver";
+import { findContacts } from "./contact";
+// World step: predict velocities → collide → solve → position correction →
+// integrate. Static and kinematic bodies are skipped during predict and
+// integrate; the parent class syncs them from bones around the step. The
+// solver pass runs on all bodies — kinematic ones have invMass = 0 and
+// act as anchors.
+export class World {
+    constructor(gravity) {
+        this.solverIterations = 10;
+        this.gravity = new Vec3(gravity.x, gravity.y, gravity.z);
+    }
+    setGravity(g) {
+        this.gravity.x = g.x;
+        this.gravity.y = g.y;
+        this.gravity.z = g.z;
+    }
+    step(store, constraints, contacts, dt) {
+        if (dt <= 0)
+            return;
+        const N = store.count;
+        const types = store.type;
+        const lv = store.linearVelocities;
+        const av = store.angularVelocities;
+        const pos = store.positions;
+        const ori = store.orientations;
+        const ldamp = store.linearDamping;
+        const adamp = store.angularDamping;
+        const invMass = store.invMass;
+        const gx = this.gravity.x;
+        const gy = this.gravity.y;
+        const gz = this.gravity.z;
+        // 1. Predict — gravity + damping. The pow form (vs the linear
+        //    1−damping·dt approximation) stays stable at high PMX damping
+        //    values like 0.99.
+        for (let i = 0; i < N; i++) {
+            if (types[i] !== RigidbodyType.Dynamic || invMass[i] <= 0)
+                continue;
+            const i3 = i * 3;
+            lv[i3 + 0] += gx * dt;
+            lv[i3 + 1] += gy * dt;
+            lv[i3 + 2] += gz * dt;
+            const ld = Math.pow(Math.max(0, 1 - ldamp[i]), dt);
+            const ad = Math.pow(Math.max(0, 1 - adamp[i]), dt);
+            lv[i3 + 0] *= ld;
+            lv[i3 + 1] *= ld;
+            lv[i3 + 2] *= ld;
+            av[i3 + 0] *= ad;
+            av[i3 + 1] *= ad;
+            av[i3 + 2] *= ad;
+        }
+        // 2. Collide.
+        contacts.reset();
+        findContacts(store, contacts);
+        // 3. Solve joint + contact constraints (velocity-only).
+        if (constraints.length > 0 || contacts.count > 0) {
+            solveConstraints(store, constraints, contacts, dt, this.solverIterations);
+        }
+        // 4. Position correction (split impulse). Direct translation along the
+        //    contact normal — joint constraints in the same SI loop can't undo
+        //    it because it doesn't go through the velocity channel. Inverse-mass
+        //    weighted so a kinematic body stays put and only the dynamic one
+        //    translates.
+        const POS_CORRECTION_FACTOR = 0.4;
+        const POS_SLOP = 0.005;
+        for (let ci = 0; ci < contacts.count; ci++) {
+            const c = contacts.get(ci);
+            if (c.depth <= POS_SLOP)
+                continue;
+            const imA = invMass[c.bodyA];
+            const imB = invMass[c.bodyB];
+            const total = imA + imB;
+            if (total <= 0)
+                continue;
+            const correction = (c.depth - POS_SLOP) * POS_CORRECTION_FACTOR;
+            const dx = correction * c.nx;
+            const dy = correction * c.ny;
+            const dz = correction * c.nz;
+            const ai = c.bodyA * 3;
+            const bi = c.bodyB * 3;
+            if (imA > 0) {
+                const fA = imA / total;
+                pos[ai + 0] -= dx * fA;
+                pos[ai + 1] -= dy * fA;
+                pos[ai + 2] -= dz * fA;
+            }
+            if (imB > 0) {
+                const fB = imB / total;
+                pos[bi + 0] += dx * fB;
+                pos[bi + 1] += dy * fB;
+                pos[bi + 2] += dz * fB;
+            }
+        }
+        // 5. Integrate. Cap angular velocity at π/2 per step — a high-impulse
+        //    contact spike on a low-inertia body would otherwise spin past π
+        //    in one step and trash the quaternion integration.
+        const MAX_ANGVEL_DT = Math.PI * 0.5;
+        for (let i = 0; i < N; i++) {
+            if (types[i] !== RigidbodyType.Dynamic || invMass[i] <= 0)
+                continue;
+            const i3 = i * 3;
+            const i4 = i * 4;
+            pos[i3 + 0] += lv[i3 + 0] * dt;
+            pos[i3 + 1] += lv[i3 + 1] * dt;
+            pos[i3 + 2] += lv[i3 + 2] * dt;
+            let wx = av[i3 + 0];
+            let wy = av[i3 + 1];
+            let wz = av[i3 + 2];
+            const wmag = Math.sqrt(wx * wx + wy * wy + wz * wz);
+            if (wmag * dt > MAX_ANGVEL_DT) {
+                const scale = MAX_ANGVEL_DT / (wmag * dt);
+                wx *= scale;
+                wy *= scale;
+                wz *= scale;
+                av[i3 + 0] = wx;
+                av[i3 + 1] = wy;
+                av[i3 + 2] = wz;
+            }
+            if (wx !== 0 || wy !== 0 || wz !== 0) {
+                const qx = ori[i4 + 0];
+                const qy = ori[i4 + 1];
+                const qz = ori[i4 + 2];
+                const qw = ori[i4 + 3];
+                const dx = qw * wx + wy * qz - wz * qy;
+                const dy = qw * wy + wz * qx - wx * qz;
+                const dz = qw * wz + wx * qy - wy * qx;
+                const dw = -(wx * qx + wy * qy + wz * qz);
+                const half = 0.5 * dt;
+                const nx = qx + dx * half;
+                const ny = qy + dy * half;
+                const nz = qz + dz * half;
+                const nw = qw + dw * half;
+                const len2 = nx * nx + ny * ny + nz * nz + nw * nw;
+                if (len2 > 0) {
+                    const inv = 1 / Math.sqrt(len2);
+                    ori[i4 + 0] = nx * inv;
+                    ori[i4 + 1] = ny * inv;
+                    ori[i4 + 2] = nz * inv;
+                    ori[i4 + 3] = nw * inv;
+                }
+            }
+        }
+    }
+}

package/dist/physics-debug.d.ts

@@ -0,0 +1,30 @@
+import type { RezePhysics } from "./physics";
+export declare class PhysicsDebugRenderer {
+    private device;
+    private bindGroup;
+    private wirePipelineSphere;
+    private wirePipelineBox;
+    private wirePipelineCapsule;
+    private wireSphereBuffer;
+    private wireBoxBuffer;
+    private wireCapsuleBuffer;
+    private wireSphereCount;
+    private wireBoxCount;
+    private wireCapsuleCount;
+    private solidPipelineSphere;
+    private solidPipelineBox;
+    private solidPipelineCapsule;
+    private solidSphereBuffer;
+    private solidBoxBuffer;
+    private solidCapsuleBuffer;
+    private solidSphereCount;
+    private solidBoxCount;
+    private solidCapsuleCount;
+    private instanceBuffer;
+    private instanceData;
+    private instanceCapacity;
+    constructor(device: GPUDevice, cameraUniformBuffer: GPUBuffer, presentationFormat: GPUTextureFormat);
+    render(pass: GPURenderPassEncoder, physics: RezePhysics): void;
+    destroy(): void;
+}
+//# sourceMappingURL=physics-debug.d.ts.map

package/dist/physics-debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../src/physics-debug.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAmB5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAc;IAG/B,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAW;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,SAAS,EAC9B,kBAAkB,EAAE,gBAAgB;IA2HtC,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAmI9D,OAAO,IAAI,IAAI;CAShB"}