update bullet library (#354)

* update bullet library

* fix bullet.d.ts export

emscripten/bullet/bullet.d.ts

@@ -0,0 +1,284 @@
+declare module 'external:emscripten/bullet/bullet.asm.js' {
+    function factory (env: any, wasmMemory: ArrayBuffer): Bullet.instance;
+    export default factory;
+}
+
+declare namespace Bullet {
+    type ptr = number;
+    interface instance {
+        _malloc(bytes: number): ptr;
+        _free(p: ptr): void;
+        _read_f32(p: ptr): void;
+        _write_f32(p: ptr, v: number): void;
+        _safe_delete(p: ptr, bulletType: number): void;
+
+        Vec3_new(x: number, y: number, z: number): ptr;
+        Vec3_x(p: ptr): number;
+        Vec3_y(p: ptr): number;
+        Vec3_z(p: ptr): number;
+        Vec3_set(p: ptr, x: number, y: number, z: number): void;
+
+        Quat_new(x: number, y: number, z: number, w: number): ptr;
+        Quat_x(p: ptr): number;
+        Quat_y(p: ptr): number;
+        Quat_z(p: ptr): number;
+        Quat_w(p: ptr): number;
+        Quat_set(p: ptr, x: number, y: number, z: number, w: number): void;
+
+        Transform_new(): ptr;
+        Transform_setIdentity(p: ptr): void;
+        Transform_getOrigin(p: ptr): ptr;
+        Transform_setRotation(p: ptr, quate: ptr): void;
+        Transform_getRotation(p: ptr, quate: ptr): void;
+
+        MotionState_getWorldTransform(p: ptr, transform: ptr): void;
+        MotionState_setWorldTransform(p: ptr, transform: ptr): void;
+        ccMotionState_new(id: number, initTrans: ptr): ptr;
+
+        int_array_size(p: ptr): number;
+        int_array_at(p: ptr, index: number): number;
+        Vec3_array_at(p: ptr, index: number): ptr;
+
+        // constraints
+
+        TypedConstraint_getFixedBody(): ptr;
+        HingeConstraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr): ptr;
+        HingeConstraint_setFrames(ptr0: ptr, ptr1: ptr, ptr2: ptr): void;
+        HingeConstraint_setLimit(p: ptr, low: number, upper: number, softness: number, biasFactor: number, relaxationFactor: number): void;
+        HingeConstraint_setAngularOnly(p: ptr, angular: number): void;
+        HingeConstraint_enableMotor(p: ptr, enable: boolean): void;
+        HingeConstraint_setMotorVelocity(p: ptr, velocity: number): void;
+        HingeConstraint_setMaxMotorImpulse(p: ptr, maxImpulse: number): void;
+        HingeConstraint_setMotorTarget(p: ptr, target: number, dt: number): void;
+        P2PConstraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr): ptr;
+        P2PConstraint_setPivotA(ptr0: ptr, ptr1: ptr): void;
+        P2PConstraint_setPivotB(ptr0: ptr, ptr1: ptr): void;
+        TypedConstraint_setMaxImpulseThreshold(ptr0: ptr, maxImpulse: number): void;
+        FixedConstraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr): ptr;
+        FixedConstraint_setFrames(ptr0: ptr, ptr1: ptr, ptr2: ptr): void;
+        Generic6DofSpring2Constraint_new(ptr0: ptr, ptr1: ptr, ptr2: ptr, ptr3: ptr, rotateOrder: number): ptr;
+        Generic6DofSpring2Constraint_setFrames(ptr0: ptr, ptr1: ptr, ptr2: ptr): void;
+        Generic6DofSpring2Constraint_setLimit(ptr0: ptr, index: number, lo: number, hi: number): void;
+        Generic6DofSpring2Constraint_enableSpring(ptr0: ptr, index: number, onOff: boolean): void;
+        Generic6DofSpring2Constraint_setStiffness(ptr0: ptr, index: number, stiffness: number): void;
+        Generic6DofSpring2Constraint_setDamping(ptr0: ptr, index: number, damping: number): void;
+        Generic6DofSpring2Constraint_setBounce(ptr0: ptr, index: number, bounce: number): void;
+        Generic6DofSpring2Constraint_setEquilibriumPoint(ptr0: ptr, index: number, val: number): void;
+        Generic6DofSpring2Constraint_enableMotor(ptr0: ptr, index: number, onOff: boolean): void;
+        Generic6DofSpring2Constraint_setMaxMotorForce(ptr0: ptr, index: number, force: number): void;
+        Generic6DofSpring2Constraint_setTargetVelocity(ptr0: ptr, index: number, velocity: number): void;
+        Generic6DofSpring2Constraint_setServo(ptr0: ptr, index: number, onOff: boolean): number;
+        Generic6DofSpring2Constraint_setServoTarget(ptr0: ptr, index: number, target: number): number;
+
+        // shapes
+
+        // CollisionShape_getUserIndex(p: ptr): number;
+        // CollisionShape_setUserIndex(p: ptr, i: number): void;
+        CollisionShape_isCompound(p: ptr): boolean;
+        CollisionShape_setLocalScaling(p: ptr, scale: ptr): void;
+        CollisionShape_calculateLocalInertia(p: ptr, mass: number, localInertia: ptr): void;
+        CollisionShape_getAabb(p: ptr, t: ptr, min: ptr, max: ptr): void;
+        CollisionShape_getLocalBoundingSphere(p: ptr): number;
+        CollisionShape_setMargin(p: ptr, margin: number): void;
+        CollisionShape_setMaterial(p: ptr, mat: ptr): void;
+        CollisionShape_setUserPointer(p: ptr, p0: ptr): void;
+
+        EmptyShape_static(): ptr;
+
+        ConvexInternalShape_getImplicitShapeDimensions(p: ptr): ptr;
+
+        BoxShape_new(p: ptr): ptr;
+        BoxShape_setUnscaledHalfExtents(p: ptr, halfExtents: ptr): void;
+
+        SphereShape_new(radius: number): ptr;
+        SphereShape_setUnscaledRadius(p: ptr, radius: number): void;
+
+        CylinderShape_new(halfExtents: ptr): ptr;
+        CylinderShape_updateProp(p: ptr, r: number, g: number, d: number): void;
+
+        CapsuleShape_new(radius: number, height: number): ptr;
+        CapsuleShape_updateProp(p: ptr, r: number, g: number, d: number): void;
+
+        ConeShape_new(radius: number, height: number): ptr;
+        ConeShape_setRadius(p: ptr, v: number): void;
+        ConeShape_setHeight(p: ptr, v: number): void;
+        ConeShape_setConeUpIndex(p: ptr, v: number): void;
+
+        StaticPlaneShape_new(normal: ptr, constant: number): ptr;
+        StaticPlaneShape_getPlaneNormal(p: ptr): ptr;
+        StaticPlaneShape_setPlaneConstant(p: ptr, constant: number): void;
+
+        TerrainShape_new(i: number, j: number, p: ptr, hs: number, min: number, max: number): ptr;
+
+        TriangleMesh_new(): ptr;
+        TriangleMesh_addTriangle(p: ptr, v0: ptr, v1: ptr, v2: ptr): void;
+        BvhTriangleMeshShape_new(p: ptr, c: boolean, bvh: boolean): ptr;
+        BvhTriangleMeshShape_getOptimizedBvh(p: ptr): ptr;
+        BvhTriangleMeshShape_setOptimizedBvh(p: ptr, p1: ptr, scaleX: number, scaleY: number, scaleZ: number);
+        ScaledBvhTriangleMeshShape_new(p: ptr, scaleX: number, scaleY: number, scaleZ: number): ptr;
+        ConvexTriangleMeshShape_new(p: ptr): ptr;
+
+        SimplexShape_new(): ptr;
+        SimplexShape_addVertex(p: ptr, pt: ptr): void;
+
+        ccCompoundShape_new(): ptr;
+        CompoundShape_getNumChildShapes(p: ptr): number;
+        CompoundShape_getChildShape(p: ptr, i: number): ptr;
+        CompoundShape_addChildShape(p: ptr, local: ptr, shape: ptr): void;
+        CompoundShape_removeChildShape(p: ptr, shape: ptr): void;
+        CompoundShape_updateChildTransform(p: ptr, i: number, trans: ptr, shouldRecalculateLocalAabb: boolean): void;
+        CompoundShape_setMaterial(p: ptr, i: number, f: number, r: number, rf: number, sf: number): void;
+
+        // collision
+
+        CollisionObject_new(): number;
+        CollisionObject_getCollisionShape(p: ptr): ptr;
+        CollisionObject_setContactProcessingThreshold(p: ptr, contactProcessingThreshold: number): void;
+        CollisionObject_getActivationState(p: ptr): number;
+        CollisionObject_setActivationState(p: ptr, newState: number): void;
+        CollisionObject_forceActivationState(p: ptr, newState: number): void;
+        CollisionObject_activate(p: ptr, forceActivation?: boolean): void;
+        CollisionObject_isActive(p: ptr): boolean;
+        CollisionObject_isKinematicObject(p: ptr): boolean;
+        CollisionObject_isStaticObject(p: ptr): boolean;
+        CollisionObject_isStaticOrKinematicObject(p: ptr): boolean;
+        CollisionObject_getWorldTransform(p: ptr): ptr;
+        CollisionObject_getCollisionFlags(p: ptr): number;
+        CollisionObject_setCollisionFlags(p: ptr, flags: number): void;
+        CollisionObject_setWorldTransform(p: ptr, transform: ptr): void;
+        CollisionObject_setCollisionShape(p: ptr, shape: ptr): void;
+        CollisionObject_setCcdMotionThreshold(p: ptr, ccdMotionThreshold: number): void;
+        CollisionObject_setCcdSweptSphereRadius(p: ptr, radius: number): void;
+        CollisionObject_getUserIndex(p: ptr): number;
+        CollisionObject_setUserIndex(p: ptr, index: number): void;
+        CollisionObject_getUserPointer(p: ptr): number;
+        CollisionObject_setUserPointer(p: ptr, userPointer: number): void;
+        CollisionObject_setMaterial(p: ptr, f: number, r: number, rf: number, sf: number): void;
+        CollisionObject_setIgnoreCollisionCheck(p: ptr, p0: ptr, v: boolean): void;
+
+        RigidBody_new(m: number, ms: number): ptr;
+        RigidBody_getFlags(p: ptr): number;
+        RigidBody_setFlags(p: ptr, flags: number): void;
+        RigidBody_setGravity(p: ptr, g: ptr): number;
+        RigidBody_setDamping(p: ptr, lin: number, ang: number): void;
+        RigidBody_setMass(p: ptr, m: number);
+        RigidBody_setMassProps(p: ptr, m: number, localInertia: ptr): void;
+        RigidBody_setLinearFactor(p: ptr, f: ptr): number;
+        RigidBody_setAngularFactor(p: ptr, f: ptr): number;
+        RigidBody_getLinearVelocity(p: ptr): ptr;
+        RigidBody_getAngularVelocity(p: ptr): ptr;
+        RigidBody_setLinearVelocity(p: ptr, v: ptr): void;
+        RigidBody_setAngularVelocity(p: ptr, v: ptr): void;
+        RigidBody_clearState(p: ptr): void;
+        RigidBody_clearForces(p: ptr): void;
+        RigidBody_wantsSleeping(p: ptr): boolean;
+        RigidBody_setSleepingThresholds(p: ptr, linear: number, angular: number): void;
+        RigidBody_getLinearSleepingThreshold(p: ptr): number;
+        RigidBody_getMotionState(p: ptr): ptr;
+        RigidBody_applyTorque(p: ptr, f: ptr): void;
+        RigidBody_applyForce(p: ptr, f: ptr, rp: ptr): void;
+        RigidBody_applyImpulse(p: ptr, f: ptr, rp: ptr): void;
+
+        // dynamic
+
+        DefaultCollisionConfiguration_static(): ptr;
+        CollisionDispatcher_new(): ptr;
+        Dispatcher_getNumManifolds(p: ptr): number;
+        Dispatcher_getManifoldByIndexInternal(p: ptr, i: number): ptr;
+
+        ManifoldPoint_getShape0(p: ptr): ptr;
+        ManifoldPoint_getShape1(p: ptr): ptr;
+        ManifoldPoint_get_m_index0(p: ptr): number;
+        ManifoldPoint_get_m_index1(p: ptr): number;
+        PersistentManifold_getBody0(p: ptr): ptr;
+        PersistentManifold_getBody1(p: ptr): ptr;
+        PersistentManifold_getNumContacts(p: ptr): number;
+        PersistentManifold_getContactPoint(p: ptr, i: number): ptr;
+        ManifoldPoint_get_m_localPointA(p: ptr): ptr;
+        ManifoldPoint_get_m_localPointB(p: ptr): ptr;
+        ManifoldPoint_get_m_positionWorldOnA(p: ptr): ptr;
+        ManifoldPoint_get_m_positionWorldOnB(p: ptr): ptr;
+        ManifoldPoint_get_m_normalWorldOnB(p: ptr): ptr;
+        ManifoldPoint_get_m_positionWorldOnB(p: ptr): ptr;
+
+        DbvtBroadphase_new(): ptr;
+        SequentialImpulseConstraintSolver_new(): ptr;
+
+        CollisionWorld_addCollisionObject(p: ptr, body: ptr, g: number, m: number): void;
+        CollisionWorld_removeCollisionObject(p: ptr, body: ptr): void;
+        CollisionWorld_rayTest(p: ptr, p0: ptr, p1: ptr, p2: ptr): void;
+        CollisionWorld_convexSweepTest(p: ptr, castShape: ptr, from: ptr, to: ptr, resultCallback: ptr, allowedCcdPenetration: ptr): void;
+
+        ccDiscreteDynamicsWorld_new(dispatcher: ptr, pairCache: ptr, solver: ptr): ptr;
+        ccDiscreteDynamicsWorld_setAllowSleep(p: ptr, v: boolean): void;
+        DynamicsWorld_setGravity(p: ptr, g: ptr): void;
+        DynamicsWorld_stepSimulation(p: ptr, timeStep: number, maxSubSteps: number, fixedTimeStep: number): ptr;
+        DynamicsWorld_addRigidBody(p: ptr, body: ptr, g: number, m: number): void;
+        DynamicsWorld_removeRigidBody(p: ptr, body: ptr): void;
+        DynamicsWorld_addConstraint(p: ptr, p2: ptr, v: boolean): void;
+        DynamicsWorld_removeConstraint(p: ptr, p2: ptr): void;
+        DynamicsWorld_addAction(p: ptr, action: ptr): void;
+        DynamicsWorld_removeAction(p: ptr, action: ptr): void;
+
+        RayCallback_hasHit(p: ptr): boolean;
+        ConvexCallback_hasHit(p: ptr): boolean;
+
+        ccAllRayCallback_static(): ptr;
+        ccAllRayCallback_setFlags(p: ptr, flag: number): void;
+        ccAllRayCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccAllRayCallback_getHitPointWorld(p: ptr): ptr;
+        ccAllRayCallback_getHitNormalWorld(p: ptr): ptr;
+        ccAllRayCallback_getCollisionShapePtrs(p: ptr): ptr;
+
+        ccClosestRayCallback_static(): ptr;
+        ccClosestRayCallback_setFlags(p: ptr, flag: number): void;
+        ccClosestRayCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccClosestRayCallback_getHitPointWorld(p: ptr): ptr;
+        ccClosestRayCallback_getHitNormalWorld(p: ptr): ptr;
+        ccClosestRayCallback_getCollisionShapePtr(p: ptr): ptr;
+
+        ccAllConvexCallback_static(): ptr;
+        ccAllConvexCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccAllConvexCallback_getHitPointWorld(p: ptr): ptr;
+        ccAllConvexCallback_getHitNormalWorld(p: ptr): ptr;
+        ccAllConvexCallback_getCollisionShapePtrs(p: ptr): ptr;
+
+        ccClosestConvexCallback_static(): ptr;
+        ccClosestConvexCallback_reset(p: ptr, p0: ptr, p1: ptr, m: number, q: boolean): void;
+        ccClosestConvexCallback_getHitPointWorld(p: ptr): ptr;
+        ccClosestConvexCallback_getHitNormalWorld(p: ptr): ptr;
+        ccClosestConvexCallback_getCollisionShapePtr(p: ptr): ptr;
+
+        ccMaterial_new(): ptr;
+        ccMaterial_set(p: ptr, r: number, f: number, rf: number, sf: number): void;
+
+        // CharacterController
+        ControllerHitReport_new(): ptr;
+        CharacterController_getGhostObject(ptrCCT: ptr): ptr;
+        ControllerHit_getCurrentController(p: ptr): ptr;
+        ControllerHit_getHitWorldPos(p: ptr): ptr;
+        ControllerHit_getHitWorldNormal(p: ptr): ptr;
+        ControllerHit_getHitMotionDir(p: ptr): ptr;         //CCT hit Motion direction
+        ControllerHit_getHitMotionLength(p: ptr): number;   //CCT hit Motion length
+        ControllerShapeHit_getHitShape(p: ptr): ptr;
+        ControllerShapeHit_getHitCollisionObject(p: ptr): ptr;
+        CharacterController_move(ptrCCT: ptr, ptrMovement: ptr, minDist: number, deltaTime: number):number;
+        CharacterController_getPosition(ptrCCT: ptr);
+        CharacterController_setContactOffset(ptrCCT: ptr, v: number);
+        CharacterController_setStepOffset(ptrCCT: ptr, v: number);
+        CharacterController_setSlopeLimit(ptrCCT: ptr, v: number);
+        CharacterController_setCollision(ptrCCT: ptr, collision: boolean);
+        CharacterController_setOverlapRecovery(ptrCCT: ptr, value: boolean);
+        CapsuleCharacterControllerDesc_new(maxSlopeRadians: number, stepHeight: number, contactOffset: number, 
+            ptrUpAxis: ptr, ptrInitPos: ptr, ptruUserControllerHitReport: ptr, radius: number, height: number): ptr;
+        CapsuleCharacterController_new(collisionWorld: ptr, ptrBtCapsuleCharacterControllerDesc: ptr, userObjectPointer: ptr): ptr;
+        CapsuleCharacterController_setRadius(ptrCCT: ptr, radius: number): void;
+        CapsuleCharacterController_setHeight(ptrCCT: ptr, height: number): void;
+        BoxCharacterControllerDesc_new(maxSlopeRadians: number, stepHeight: number, contactOffset: number, 
+            ptrUpAxis: ptr, ptrInitPos: ptr, ptruUserControllerHitReport: ptr, halfHeight: number, halfSideExtent: number, halfForwardExtent: number): ptr;
+        BoxCharacterController_new(collisionWorld: ptr, ptrBtBoxCharacterControllerDesc: ptr, userObjectPointer: ptr): ptr;
+        BoxCharacterController_setHalfHeight(ptrCCT: ptr, v: number): void;
+        BoxCharacterController_setHalfSideExtent(ptrCCT: ptr, v: number): void;
+        BoxCharacterController_setHalfForwardExtent(ptrCCT: ptr, v: number): void;
+    }
+}

emscripten/external-wasm.d.ts

@@ -0,0 +1,7 @@
+declare module 'external:emscripten/*.wasm' {
+    /**
+     * This is a url relative from build output chunk.
+     */
+    const wasmPath: string;
+    export default wasmPath;
+}

emscripten/physx/physx.d.ts

@@ -0,0 +1,103 @@
+/// <reference path="./phy.d.ts" />
+
+declare module 'external:emscripten/physx/physx.release.asm.js' {
+  export default PhysX;
+}
+
+declare module 'external:emscripten/physx/physx.release.wasm.js' {
+  export default PhysX;
+}
+
+// tslint:disable
+declare function PhysX (moduleOptions?: any): Promise<void>;
+
+declare namespace PhysX {
+  type Constructor<T = {}> = new (...args: any[]) => T;
+  type VoidPtr = number;
+  const NULL: {};
+  const HEAPF32: Float32Array;
+  function destroy (obj: PhysX.Type): void;
+  function castObject<T1, T2 extends PhysX.Type> (obj: T1, fun: Constructor<T2>): T2;
+  function wrapPointer<T extends PhysX.Type> (params: number, obj: Constructor<T>): T;
+  function addFunction (params: Function): number;
+  function getClass (obj: PhysX.Type): void;
+  function getPointer (obj: PhysX.Type): void;
+  function getCache (fun: Constructor<PhysX.Type>): void;
+  function _malloc (byte: number): number;
+  function _free (...args: any): any;
+  function compare (obj1: PhysX.Type, obj2: PhysX.Type): boolean;
+
+  class GeometryType {
+    Enum: {
+      eSPHERE: number,
+      ePLANE: number,
+      eCAPSULE: number,
+      eBOX: number,
+      eCONVEXMESH: number,
+      eTRIANGLEMESH: number,
+      eHEIGHTFIELD: number,
+      eGEOMETRY_COUNT: number,	//!< internal use only!
+      eINVALID: number //= -1		//!< internal use only!
+    }
+  }
+
+  const PX_PHYSICS_VERSION: number
+  interface AllocatorCallback { }
+  class DefaultErrorCallback implements AllocatorCallback { }
+  interface ErrorCallback { }
+  class DefaultAllocator implements ErrorCallback { }
+
+  class Foundation { }
+  function createFoundation (a: number, b: AllocatorCallback, c: ErrorCallback): Foundation
+
+  class Transform {
+    constructor (p: number[], q: number[]);
+    setPosition (t: number[]): void;
+    getPosition (): number[];
+    setQuaternion (t: number[]): void;
+    getQuaternion (): number[];
+  }
+
+  class Base { }
+
+  class Geometry { getType (): number }
+  class BoxGeometry extends Geometry { constructor (x: number, y: number, z: number); }
+  class SphereGeometry extends Geometry { constructor (r: number); }
+
+  class Material extends Base { }
+
+  class Shape extends Base { }
+
+  class Actor extends Base {
+    getGlobalPose (): Transform;
+  }
+  class RigidActor extends Actor {
+    attachShape (shape: Shape): void;
+    detachShape (shape: Shape, wakeOnLostTouch?: boolean | true): void;
+  }
+  class RigidBody extends RigidActor { }
+  class RigidStatic extends RigidBody { }
+  class RigidDynamic extends RigidBody { }
+
+  class SceneDesc { }
+  class Scene {
+    simulate (timeStep: number): void;
+    fetchResults (b: boolean): void;
+    getActiveActors (len: number): Actor[];
+  }
+
+  class Physics {
+    createSceneDesc (): SceneDesc;
+    createScene (a: SceneDesc): Scene;
+    createRigidDynamic (a: Transform): RigidDynamic;
+    createRigidStatic (a: Transform): RigidStatic;
+    createMaterial (staticFriction: number, dynamicFriction: number, restitution: number): Material;
+    //shapeFlags = PxShapeFlag:: eVISUALIZATION | PxShapeFlag:: eSCENE_QUERY_SHAPE | PxShapeFlag:: eSIMULATION_SHAPE
+    createShape (geometry: Geometry, material: Material, isExclusive: boolean | false, shapeFlags: number): Shape;
+  }
+  class TolerancesScale { length: number | 1.0; speed: number | 10.0 }
+  class Pvd { }
+  function createPhysics (a?: number, b?: Foundation, c?: TolerancesScale, trackOutstandingAllocations?: boolean, e?: Pvd): Physics;
+
+  type Type = {}
+}

emscripten/physx/physx.debug.wasm.js

@@ -60,16 +60,10 @@ var quit_ = function(status, toThrow) {
 // Determine the runtime environment we are in. You can customize this by
 // setting the ENVIRONMENT setting at compile time (see settings.js).
 
-var ENVIRONMENT_IS_WEB = false;
+var ENVIRONMENT_IS_WEB = true;
 var ENVIRONMENT_IS_WORKER = false;
 var ENVIRONMENT_IS_NODE = false;
 var ENVIRONMENT_IS_SHELL = false;
-ENVIRONMENT_IS_WEB = typeof window === 'object';
-ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
-// N.b. Electron.js environment is simultaneously a NODE-environment, but
-// also a web environment.
-ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof process.versions === 'object' && typeof process.versions.node === 'string';
-ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
 
 
 
@@ -581,8 +575,8 @@ var wasmMemory;
 // In the wasm backend, we polyfill the WebAssembly object,
 // so this creates a (non-native-wasm) table for us.
 var wasmTable = new WebAssembly.Table({
-  'initial': 5024,
-  'maximum': 5024 + 0,
+  'initial': 5437,
+  'maximum': 5437 + 0,
   'element': 'anyfunc'
 });
 
@@ -1204,11 +1198,11 @@ function updateGlobalBufferAndViews(buf) {
 }
 
 var STATIC_BASE = 1024,
-    STACK_BASE = 5607968,
+    STACK_BASE = 5608208,
     STACKTOP = STACK_BASE,
-    STACK_MAX = 365088,
-    DYNAMIC_BASE = 5607968,
-    DYNAMICTOP_PTR = 364928;
+    STACK_MAX = 365328,
+    DYNAMIC_BASE = 5608208,
+    DYNAMICTOP_PTR = 365168;
 
 
 
@@ -1684,7 +1678,7 @@ var ASM_CONSTS = {
 
 
 
-// STATICTOP = STATIC_BASE + 364064;
+// STATICTOP = STATIC_BASE + 364304;
 /* global initializers */  __ATINIT__.push({ func: function() { ___wasm_call_ctors() } });
 
 
@@ -3909,7 +3903,7 @@ var ASM_CONSTS = {
     }
 
   function _emscripten_get_sbrk_ptr() {
-      return 364928;
+      return 365168;
     }
 
   function _emscripten_memcpy_big(dest, src, num) {
@@ -4316,11 +4310,6 @@ var dynCall_viii = Module["dynCall_viii"] = function() {
   return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["dynCall_viii"]).apply(null, arguments);
 };
 
-/** @type {function(...*):?} */
-var dynCall_i = Module["dynCall_i"] = function() {
-  return (dynCall_i = Module["dynCall_i"] = Module["asm"]["dynCall_i"]).apply(null, arguments);
-};
-
 /** @type {function(...*):?} */
 var dynCall_fii = Module["dynCall_fii"] = function() {
   return (dynCall_fii = Module["dynCall_fii"] = Module["asm"]["dynCall_fii"]).apply(null, arguments);
@@ -4336,6 +4325,11 @@ var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
   return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["dynCall_iiiii"]).apply(null, arguments);
 };
 
+/** @type {function(...*):?} */
+var dynCall_i = Module["dynCall_i"] = function() {
+  return (dynCall_i = Module["dynCall_i"] = Module["asm"]["dynCall_i"]).apply(null, arguments);
+};
+
 /** @type {function(...*):?} */
 var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() {
   return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = Module["asm"]["dynCall_iiiiiii"]).apply(null, arguments);
@@ -4346,6 +4340,26 @@ var dynCall_vii = Module["dynCall_vii"] = function() {
   return (dynCall_vii = Module["dynCall_vii"] = Module["asm"]["dynCall_vii"]).apply(null, arguments);
 };
 
+/** @type {function(...*):?} */
+var dynCall_iiff = Module["dynCall_iiff"] = function() {
+  return (dynCall_iiff = Module["dynCall_iiff"] = Module["asm"]["dynCall_iiff"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var dynCall_iifff = Module["dynCall_iifff"] = function() {
+  return (dynCall_iifff = Module["dynCall_iifff"] = Module["asm"]["dynCall_iifff"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var dynCall_iiiff = Module["dynCall_iiiff"] = function() {
+  return (dynCall_iiiff = Module["dynCall_iiiff"] = Module["asm"]["dynCall_iiiff"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var dynCall_iiifff = Module["dynCall_iiifff"] = function() {
+  return (dynCall_iiifff = Module["dynCall_iiifff"] = Module["asm"]["dynCall_iiifff"]).apply(null, arguments);
+};
+
 /** @type {function(...*):?} */
 var dynCall_viiii = Module["dynCall_viiii"] = function() {
   return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["dynCall_viiii"]).apply(null, arguments);
@@ -4362,13 +4376,13 @@ var dynCall_viifi = Module["dynCall_viifi"] = function() {
 };
 
 /** @type {function(...*):?} */
-var dynCall_dii = Module["dynCall_dii"] = function() {
-  return (dynCall_dii = Module["dynCall_dii"] = Module["asm"]["dynCall_dii"]).apply(null, arguments);
+var dynCall_iifffi = Module["dynCall_iifffi"] = function() {
+  return (dynCall_iifffi = Module["dynCall_iifffi"] = Module["asm"]["dynCall_iifffi"]).apply(null, arguments);
 };
 
 /** @type {function(...*):?} */
-var dynCall_viid = Module["dynCall_viid"] = function() {
-  return (dynCall_viid = Module["dynCall_viid"] = Module["asm"]["dynCall_viid"]).apply(null, arguments);
+var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
+  return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["dynCall_viiiii"]).apply(null, arguments);
 };
 
 /** @type {function(...*):?} */
@@ -4397,13 +4411,13 @@ var dynCall_iiiiiifiiiiif = Module["dynCall_iiiiiifiiiiif"] = function() {
 };
 
 /** @type {function(...*):?} */
-var dynCall_iiiif = Module["dynCall_iiiif"] = function() {
-  return (dynCall_iiiif = Module["dynCall_iiiif"] = Module["asm"]["dynCall_iiiif"]).apply(null, arguments);
+var dynCall_iiiiiifiiiiiif = Module["dynCall_iiiiiifiiiiiif"] = function() {
+  return (dynCall_iiiiiifiiiiiif = Module["dynCall_iiiiiifiiiiiif"] = Module["asm"]["dynCall_iiiiiifiiiiiif"]).apply(null, arguments);
 };
 
 /** @type {function(...*):?} */
-var dynCall_iiifff = Module["dynCall_iiifff"] = function() {
-  return (dynCall_iiifff = Module["dynCall_iiifff"] = Module["asm"]["dynCall_iiifff"]).apply(null, arguments);
+var dynCall_iiiif = Module["dynCall_iiiif"] = function() {
+  return (dynCall_iiiif = Module["dynCall_iiiif"] = Module["asm"]["dynCall_iiiif"]).apply(null, arguments);
 };
 
 /** @type {function(...*):?} */
@@ -4421,11 +4435,6 @@ var dynCall_iif = Module["dynCall_iif"] = function() {
   return (dynCall_iif = Module["dynCall_iif"] = Module["asm"]["dynCall_iif"]).apply(null, arguments);
 };
 
-/** @type {function(...*):?} */
-var dynCall_iiff = Module["dynCall_iiff"] = function() {
-  return (dynCall_iiff = Module["dynCall_iiff"] = Module["asm"]["dynCall_iiff"]).apply(null, arguments);
-};
-
 /** @type {function(...*):?} */
 var dynCall_iiiifff = Module["dynCall_iiiifff"] = function() {
   return (dynCall_iiiifff = Module["dynCall_iiiifff"] = Module["asm"]["dynCall_iiiifff"]).apply(null, arguments);
@@ -4436,6 +4445,16 @@ var dynCall_iiffff = Module["dynCall_iiffff"] = function() {
   return (dynCall_iiffff = Module["dynCall_iiffff"] = Module["asm"]["dynCall_iiffff"]).apply(null, arguments);
 };
 
+/** @type {function(...*):?} */
+var dynCall_viiif = Module["dynCall_viiif"] = function() {
+  return (dynCall_viiif = Module["dynCall_viiif"] = Module["asm"]["dynCall_viiif"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var dynCall_iiiiffii = Module["dynCall_iiiiffii"] = function() {
+  return (dynCall_iiiiffii = Module["dynCall_iiiiffii"] = Module["asm"]["dynCall_iiiiffii"]).apply(null, arguments);
+};
+
 /** @type {function(...*):?} */
 var dynCall_vifi = Module["dynCall_vifi"] = function() {
   return (dynCall_vifi = Module["dynCall_vifi"] = Module["asm"]["dynCall_vifi"]).apply(null, arguments);
@@ -4462,8 +4481,13 @@ var dynCall_iiiifiiiiii = Module["dynCall_iiiifiiiiii"] = function() {
 };
 
 /** @type {function(...*):?} */
-var dynCall_viiif = Module["dynCall_viiif"] = function() {
-  return (dynCall_viiif = Module["dynCall_viiif"] = Module["asm"]["dynCall_viiif"]).apply(null, arguments);
+var dynCall_iiiiifiiiiif = Module["dynCall_iiiiifiiiiif"] = function() {
+  return (dynCall_iiiiifiiiiif = Module["dynCall_iiiiifiiiiif"] = Module["asm"]["dynCall_iiiiifiiiiif"]).apply(null, arguments);
+};
+
+/** @type {function(...*):?} */
+var dynCall_iiiiifiiiiiif = Module["dynCall_iiiiifiiiiiif"] = function() {
+  return (dynCall_iiiiifiiiiiif = Module["dynCall_iiiiifiiiiiif"] = Module["asm"]["dynCall_iiiiifiiiiiif"]).apply(null, arguments);
 };
 
 /** @type {function(...*):?} */
@@ -4476,6 +4500,11 @@ var dynCall_vif = Module["dynCall_vif"] = function() {
   return (dynCall_vif = Module["dynCall_vif"] = Module["asm"]["dynCall_vif"]).apply(null, arguments);
 };
 
+/** @type {function(...*):?} */
+var dynCall_iiiffii = Module["dynCall_iiiffii"] = function() {
+  return (dynCall_iiiffii = Module["dynCall_iiiffii"] = Module["asm"]["dynCall_iiiffii"]).apply(null, arguments);
+};
+
 /** @type {function(...*):?} */
 var dynCall_v = Module["dynCall_v"] = function() {
   return (dynCall_v = Module["dynCall_v"] = Module["asm"]["dynCall_v"]).apply(null, arguments);
@@ -4511,11 +4540,6 @@ var dynCall_viiiiiiiiiiifii = Module["dynCall_viiiiiiiiiiifii"] = function() {
   return (dynCall_viiiiiiiiiiifii = Module["dynCall_viiiiiiiiiiifii"] = Module["asm"]["dynCall_viiiiiiiiiiifii"]).apply(null, arguments);
 };
 
-/** @type {function(...*):?} */
-var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
-  return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["dynCall_viiiii"]).apply(null, arguments);
-};
-
 /** @type {function(...*):?} */
 var dynCall_iifiiiijii = Module["dynCall_iifiiiijii"] = function() {
   return (dynCall_iifiiiijii = Module["dynCall_iifiiiijii"] = Module["asm"]["dynCall_iifiiiijii"]).apply(null, arguments);
@@ -4596,11 +4620,6 @@ var dynCall_viifffi = Module["dynCall_viifffi"] = function() {
   return (dynCall_viifffi = Module["dynCall_viifffi"] = Module["asm"]["dynCall_viifffi"]).apply(null, arguments);
 };
 
-/** @type {function(...*):?} */
-var dynCall_iifff = Module["dynCall_iifff"] = function() {
-  return (dynCall_iifff = Module["dynCall_iifff"] = Module["asm"]["dynCall_iifff"]).apply(null, arguments);
-};
-
 /** @type {function(...*):?} */
 var dynCall_viiifiiiii = Module["dynCall_viiifiiiii"] = function() {
   return (dynCall_viiifiiiii = Module["dynCall_viiifiiiii"] = Module["asm"]["dynCall_viiifiiiii"]).apply(null, arguments);
@@ -4611,11 +4630,6 @@ var dynCall_viiiifiiiiif = Module["dynCall_viiiifiiiiif"] = function() {
   return (dynCall_viiiifiiiiif = Module["dynCall_viiiifiiiiif"] = Module["asm"]["dynCall_viiiifiiiiif"]).apply(null, arguments);
 };
 
-/** @type {function(...*):?} */
-var dynCall_iiiiifiiiiif = Module["dynCall_iiiiifiiiiif"] = function() {
-  return (dynCall_iiiiifiiiiif = Module["dynCall_iiiiifiiiiif"] = Module["asm"]["dynCall_iiiiifiiiiif"]).apply(null, arguments);
-};
-
 /** @type {function(...*):?} */
 var dynCall_iiiiifiii = Module["dynCall_iiiiifiii"] = function() {
   return (dynCall_iiiiifiii = Module["dynCall_iiiiifiii"] = Module["asm"]["dynCall_iiiiifiii"]).apply(null, arguments);
@@ -4671,6 +4685,11 @@ var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = function() {
   return (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = Module["asm"]["dynCall_iiiiiiiiii"]).apply(null, arguments);
 };
 
+/** @type {function(...*):?} */
+var dynCall_viiiffii = Module["dynCall_viiiffii"] = function() {
+  return (dynCall_viiiffii = Module["dynCall_viiiffii"] = Module["asm"]["dynCall_viiiffii"]).apply(null, arguments);
+};
+
 /** @type {function(...*):?} */
 var dynCall_viij = Module["dynCall_viij"] = function() {
   return (dynCall_viij = Module["dynCall_viij"] = Module["asm"]["dynCall_viij"]).apply(null, arguments);

emscripten/spine/spine.d.ts

@@ -0,0 +1,46 @@
+declare module 'external:emscripten/spine/spine.asm.js' {
+    export default SpineWasm;
+}
+
+declare function SpineWasm (moduleOptions?: any): Promise<void>;
+
+declare namespace SpineWasm {
+    type ptr = number;
+    interface instance {
+        spineWasmInstanceInit(): number;
+        spineWasmInstanceDestroy(): number;
+        queryStoreMemory(): ptr;
+        createSkeletonObject (): ptr;
+        setSkeletonData(objPtr: ptr, datPtr: ptr);
+        setAnimation(objPtr: ptr, length: number, trackIndex: number, loop: boolean): boolean;
+        clearTrack(objPtr: ptr, trackIndex: number): void;
+        clearTracks(objPtr: ptr): void;
+        setToSetupPose(objPtr: ptr): void;
+        setSlotsToSetupPose(objPtr: ptr): void;
+        setBonesToSetupPose(objPtr: ptr): void;
+        setTimeScale(objPtr: ptr, timeScale: number): number;
+        setSkin(objPtr: ptr, length: number): number;
+        updateAnimation(objPtr: ptr, dltTime: number): number;
+        setMix(objPtr: ptr, start: number, fromLength: number, toLength: number, duration: number);
+        setAttachment(objPtr: ptr, start: number, length1: number, length2: number);
+        updateRenderData(objPtr: ptr): number;
+        getDrawOrderSize(objPtr: ptr): number;
+        getSlotNameByOrder(objPtr: ptr, index: number): number;
+        getBoneMatrix(objPtr: ptr, index: number): number;
+        queryMemory(size: number): number;
+        freeMemory(data: ptr);
+        setDefaultScale(objPtr: ptr, scale: number): boolean;
+        setVertexEffect(objPtr: ptr, effect: number, effectType: number);
+        setPremultipliedAlpha(objPtr: ptr, premultipliedAlpha: boolean);
+        setColor(objPtr: ptr, r: number, g: number, b: number, a: number);
+        destroyInstance(objPtr: ptr);
+        retainSkeletonDataByUUID(length: number): number;
+        initSkeletonData(length: number, isJosn: boolean): number;
+        recordSkeletonDataUUID(length: number, datPtr: number);
+        createJitterVertexEffect(x: number, y: number): number;
+        updateJitterParameters(handle: number, x: number, y: number);
+        createSwirlVertexEffect(radius: number, power: number, usePowerOut: boolean): number;
+        updateSwirlParameters(handle: number, centerX: number, centerY: number, radius: number, angle: number);
+        memory: any;
+    }
+}

emscripten/webgpu/webgpu.d.ts

@@ -0,0 +1,9 @@
+declare module 'external:emscripten/webgpu/webgpu_wasm.js' {
+    function factory (gfx: any): Promise<any>;
+    export default factory;
+}
+
+declare module 'external:emscripten/webgpu/glslang.js' {
+    function factory (wasmUrl: string): Promise<any>;
+    export default factory;
+}

versions.txt

@@ -139,7 +139,7 @@ glslang (Built using https://github.com/YunHsiao/glslang/tree/build)
     linux:      11.5.0
     openharmony:11.5.0 (commit: 1978c76)
     
-swig ( Built using https://github.com/cocos/swig/tree/cocos-se, executable files are downloaded from https://github.com/cocos/swig/releases/tag/cocos-v1.1.2 )
-    win64:      cocos-v1.1.2 (commit: 5c7c430)
-    mac:        cocos-v1.1.2 (commit: 5c7c430)
-    linux:      cocos-v1.1.2 (commit: 5c7c430)
+swig ( Built using https://github.com/cocos/swig/tree/cocos-se, executable files are downloaded from https://github.com/cocos/swig/releases/tag/cocos-v1.1.4 )
+    win64:      cocos-v1.1.4 (commit: 9807544)
+    mac:        cocos-v1.1.4 (commit: 9807544)
+    linux:      cocos-v1.1.4 (commit: 9807544)