add box2d-wasm (#397)

Solve unchecked websocket link failure issue.

emscripten/box2d/b2.d.ts

@@ -0,0 +1,575 @@
+declare namespace B2 {
+    const maxPolygonVertices: number;
+
+    interface Vec2 {
+        x: number, y: number
+    }
+
+    interface Vec2Vector {
+        push_back(v: Vec2): void;
+        get(i: number): Vec2;
+        size(): number;
+    }
+
+    interface Int32Vector {
+        push_back(v: number): void;
+        get(i: number): number;
+        size(): number;
+    }
+
+    interface Transform {
+        p: Vec2, q: Vec2
+    }
+
+    interface Color {
+        r: number, g: number, b: number, a: number
+    }
+
+    interface MassData {
+        mass: number;
+        center: Vec2;
+        I: number;
+    }
+
+    class AABB {
+        constructor();
+        lowerBound: Vec2;
+        upperBound: Vec2;
+        IsValid(): boolean;
+        GetCenter(): Vec2;
+        GetExtents(): Vec2;
+        GetPerimeter(): number;
+        Combine(aabb: AABB): void;
+        CombineTwo(aabb1: AABB, aabb2: AABB): void;
+        Contains(aabb: AABB): boolean;
+        RayCast(output: RayCastOutput, input: RayCastInput): boolean;
+        TestOverlap(other: AABB): boolean;
+    }
+
+    class RayCastCallback {
+        constructor();
+        ReportFixture(fixture: Fixture, point: Vec2, normal: Vec2, fraction: number): number;
+    }
+
+    class QueryCallback {
+        constructor();
+        ReportFixture(fixture: Fixture): boolean;
+    }
+
+    interface RayCastInput {
+        p1: Vec2;
+        p2: Vec2;
+        maxFraction: number;
+    }
+
+    interface RayCastOutput {
+        normal: Vec2;
+        fraction: number;
+    }
+
+    interface Filter {
+        categoryBits: number;
+        maskBits: number;
+        groupIndex: number;
+    }
+
+    class ContactListener {
+        constructor();
+        BeginContact(contact: number): void;
+        EndContact(contact: number): void;
+        PreSolve(contact: number, oldManifold: number): void;
+        PostSolve(contact: number, impulse: number): void;
+        registerContactFixture(fixture: number): void;
+        unregisterContactFixture(fixture: number): void;
+        isIndexOf(fixture: number): void;
+    }
+
+    class Draw {
+        constructor();
+        SetFlags(flags: number): void;
+        GetFlags(): number;
+        AppendFlags(flags: number): void;
+        ClearFlags(flags: number): void;
+        DrawPolygon(vertices: Vec2[], vertexCount: number, color: Color): void;
+        DrawSolidPolygon(vertices: Vec2[], vertexCount: number, color: Color): void;
+        DrawCircle(center: Vec2, radius: number, color: Color): void;
+        DrawSolidCircle(center: Vec2, radius: number, axis: Vec2, color: Color): void;
+    }
+
+    class World {
+        constructor(gravity: Vec2);
+        SetContactListener(listener: ContactListener): void;
+        SetDebugDraw(debugDraw: Draw): void;
+        CreateBody(def: BodyDef): Body;
+        DestroyBody(body: Body): void;
+        CreateJoint(def: JointDef): Joint;
+        DestroyJoint(joint: Joint): void;
+        Step(timeStep: number, velocityIterations: number, positionIterations: number): void;
+        DebugDraw(): void;
+        QueryAABB(callback: QueryCallback, aabb: AABB): void;
+        RayCast(callback: RayCastCallback, point1: Vec2, point2: Vec2): void;
+        SetAllowSleeping(flag: boolean): void;
+        GetAllowSleeping(): boolean;
+        SetGravity(gravity: Vec2): void;
+        GetGravity(): Vec2;
+        Dump(): void;
+    }
+
+    class Shape {
+        m_type: number;
+        m_radius: number;
+        GetType(): number;
+        GetChildCount(): number;
+        TestPoint(xf: Transform, p: Vec2): boolean;
+        RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean;
+        ComputeAABB(aabb: AABB, xf: Transform, childIndex: number): void;
+        ComputeMass(massData: MassData, density: number): void;
+        SetRadius(radius: number): void;
+        GetRadius(): number;
+    }
+
+    class CircleShape extends Shape {
+        constructor();
+        m_p: Vec2;
+        Clone(): CircleShape;
+        GetChildCount(): number;
+        TestPoint(transform: Transform, p: Vec2): boolean;
+        RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean;
+        ComputeAABB(aabb: AABB, transform: Transform, childIndex: number): void;
+        ComputeMass(massData: MassData, density: number): void;
+    }
+
+    class EdgeShape extends Shape {
+        constructor();
+        Set(v1: Vec2, v2: Vec2): void;
+        Clone(): EdgeShape;
+        GetChildCount(): number;
+        TestPoint(transform: Transform, p: Vec2): boolean;
+        RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean;
+        ComputeAABB(aabb: AABB, transform: Transform, childIndex: number): void;
+        ComputeMass(massData: MassData, density: number): void;
+    }
+
+    class PolygonShape extends Shape {
+        constructor();
+        Clone(): PolygonShape;
+        Set(vertices: any, count: number): void;
+        SetAsBox(hx: number, hy: number): void;
+        SetAsBoxWithCenterAndAngle(hx: number, hy: number, center: Vec2, angle: number): void;
+        GetChildCount(): number;
+        TestPoint(transform: Transform, p: Vec2): boolean;
+        RayCast(output: RayCastOutput, input: RayCastInput, transform: Transform, childIndex: number): boolean;
+        ComputeAABB(aabb: AABB, transform: Transform, childIndex: number): void;
+        ComputeMass(massData: MassData, density: number): void;
+        Validate(): boolean;
+    }
+
+    class FixtureDef {
+        shape: Shape;
+        userData: any;
+        friction: number;
+        restitution: number;
+        density: number;
+        isSensor: boolean;
+        filter: Filter;
+        SetShape(shape: Shape): void;
+        GetShape(): Shape;
+    }
+
+    class Fixture {
+        GetType(): number;
+        GetShape(): Shape;
+        SetSensor(sensor: boolean): void;
+        IsSensor(): boolean;
+        SetFilterData(filter: Filter): void;
+        GetFilterData(): Filter;
+        Refilter(): void;
+        GetBody(): Body;
+        TestPoint(p: Vec2): boolean;
+        RayCast(output: RayCastOutput, input: RayCastInput, childIndex: number): boolean;
+        GetMassData(massData: MassData): void;
+        SetDensity(density: number): void;
+        GetDensity(): number;
+        GetFriction(): number;
+        SetFriction(friction: number): void;
+        GetRestitution(): number;
+        SetRestitution(restitution: number): void;
+        GetAABB(childIndex: number): AABB;
+        Dump(bodyIndex: number): void;
+    }
+
+    enum BodyType{
+        b2_staticBody = 0,
+        b2_kinematicBody,
+        b2_dynamicBody,
+        cc_animatedBody,
+    }
+
+    class BodyDef {
+        constructor();
+        type: BodyType;
+        position: Vec2;
+        angle: number;
+        linearVelocity: Vec2;
+        angularVelocity: number;
+        linearDamping: number;
+        angularDamping: number;
+        allowSleep: boolean;
+        awake: boolean;
+        fixedRotation: boolean;
+        bullet: boolean;
+        gravityScale: number;
+    }
+
+    class Body {
+        CreateFixture (fixtureDef: FixtureDef): Fixture;
+        CreateFixtureWithShape (shape: Shape, density: number): Fixture;
+        DestroyFixture(fixture: Fixture): void;
+        SetTransform(position: Vec2, angle: number): void;
+        GetTransform(): Transform;
+        GetPosition(): Vec2;
+        SetPosition(pos: Vec2): void;
+        GetAngle(): number;
+        SetAngle(angle: number): void;
+        GetWorldCenter(): Vec2;
+        GetLocalCenter(): Vec2;
+        SetLinearVelocity(v: Vec2): void;
+        GetLinearVelocity(): Vec2;
+        SetAngularVelocity(omega: number): void;
+        GetAngularVelocity(): number;
+        ApplyForce(force: Vec2, point: Vec2, wake: boolean): void;
+        ApplyForceToCenter(force: Vec2, wake: boolean): void;
+        ApplyTorque(torque: number, wake: boolean): void;
+        ApplyLinearImpulse(impulse: Vec2, point: Vec2, wake: boolean): void;
+        ApplyLinearImpulseToCenter(impulse: Vec2, wake: boolean): void;
+        ApplyAngularImpulse(impulse: number, wake: boolean): void;
+        GetMass(): number;
+        GetInertia(): number;
+        GetMassData(data: MassData): void;
+        SetMassData(data: MassData): void;
+        ResetMassData(): void;
+        GetWorldPoint(localPoint: Vec2): Vec2;
+        GetWorldVector(localVector: Vec2): Vec2;
+        GetLocalPoint(worldPoint: Vec2): Vec2;
+        GetLocalVector(worldVector: Vec2): Vec2;
+        GetLinearVelocityFromWorldPoint(worldPoint: Vec2): Vec2;
+        GetLinearVelocityFromLocalPoint(localPoint: Vec2): Vec2;
+        GetLinearDamping(): number;
+        SetLinearDamping(linearDamping: number): void;
+        GetAngularDamping(): number;
+        SetAngularDamping(angularDamping: number): void;
+        GetGravityScale(): number;
+        SetGravityScale(scale: number): void;
+        SetType(type: BodyType): void;
+        GetType(): BodyType;
+        SetBullet(flag: boolean): void;
+        IsBullet(): boolean;
+        SetSleepingAllowed(flag: boolean): void;
+        IsSleepingAllowed(): boolean;
+        SetAwake(flag: boolean): void;
+        IsAwake(): boolean;
+        SetEnabled(flag: boolean): void;
+        IsEnabled(): boolean;
+        SetFixedRotation(flag: boolean): void;
+        IsFixedRotation(): boolean;
+        GetWorld(): World;
+        Dump(): void;
+    }
+
+    enum JointType {
+        e_unknownJoint,
+        e_revoluteJoint,
+        e_prismaticJoint,
+        e_distanceJoint,
+        e_pulleyJoint,
+        e_mouseJoint,
+        e_gearJoint,
+        e_wheelJoint,
+        e_weldJoint,
+        e_frictionJoint,
+        e_ropeJoint,
+        e_motorJoint
+    }
+
+    class JointDef {
+        constructor(type: JointType);
+        type: JointType;
+        collideConnected: boolean;
+        SetBodyA(bodyA: Body): void;
+        SetBodyB(bodyB: Body): void;
+        GetBodyA(): Body;
+        GetBodyB(): Body;
+        SetCollideConnected(flag: boolean): void;
+    }
+
+    class Joint {
+        GetType(): JointType;
+        GetBodyA(): Body;
+        GetBodyB(): Body;
+        GetAnchorA(): Vec2;
+        GetAnchorB(): Vec2;
+        GetReactionForce(inv_dt: number): Vec2;
+        GetReactionTorque(inv_dt: number): number;
+        IsActive(): boolean;
+        GetCollideConnected(): boolean;
+        Dump(): void;
+    }
+
+    class DistanceJointDef extends JointDef {
+        constructor();
+        localAnchorA: Vec2;
+        localAnchorB: Vec2;
+        length: number;
+        stiffness: number;
+        damping: number;
+    }
+
+    class DistanceJoint extends Joint {
+        GetLocalAnchorA(): Vec2;
+        GetLocalAnchorB(): Vec2;
+        SetLength(length: number): void;
+        GetLength(): number;
+        SetStiffness(stiffness: number): void;
+        GetStiffness(): number;
+        SetDamping(damping: number): void;
+        GetDamping(): number;
+        Dump(): void;
+    }
+
+    class MotorJointDef extends JointDef {
+        constructor();
+        linearOffset: Vec2;
+        angularOffset: number;
+        maxForce: number;
+        maxTorque: number;
+        correctionFactor: number;
+    }
+
+    class MotorJoint extends Joint {
+        SetLinearOffset(linearOffset: Vec2): void;
+        GetLinearOffset(): Vec2;
+        SetAngularOffset(angularOffset: number): void;
+        GetAngularOffset(): number;
+        SetMaxForce(force: number): void;
+        GetMaxForce(): number;
+        SetMaxTorque(torque: number): void;
+        GetMaxTorque(): number;
+        SetCorrectionFactor(factor: number): void;
+        GetCorrectionFactor(): number;
+        Dump(): void;
+    }
+
+    class MouseJointDef extends JointDef {
+        constructor();
+        target: Vec2;
+        maxForce: number;
+        frequencyHz: number;
+        dampingRatio: number;
+    }
+
+    class MouseJoint extends Joint {
+        SetTarget(target: Vec2): void;
+        GetTarget(): Vec2;
+        SetMaxForce(force: number): void;
+        GetMaxForce(): number;
+        SetFrequency(hz: number): void;
+        GetFrequency(): number;
+        SetDampingRatio(ratio: number): void;
+        GetDampingRatio(): number;
+        Dump(): void;
+    }
+
+    class PrismaticJointDef extends JointDef {
+        constructor();
+        localAnchorA: Vec2;
+        localAnchorB: Vec2;
+        localAxisA: Vec2;
+        referenceAngle: number;
+        enableLimit: boolean;
+        lowerTranslation: number;
+        upperTranslation: number;
+        enableMotor: boolean;
+        maxMotorForce: number;
+        motorSpeed: number;
+    }
+
+    class PrismaticJoint extends Joint {
+        GetLocalAnchorA(): Vec2;
+        GetLocalAnchorB(): Vec2;
+        GetLocalAxisA(): Vec2;
+        GetReferenceAngle(): number;
+        GetJointTranslation(): number;
+        GetJointSpeed(): number;
+        IsLimitEnabled(): boolean;
+        EnableLimit(flag: boolean): void;
+        GetLowerLimit(): number;
+        GetUpperLimit(): number;
+        SetLimits(lower: number, upper: number): void;
+        IsMotorEnabled(): boolean;
+        EnableMotor(flag: boolean): void;
+        SetMotorSpeed(speed: number): void;
+        GetMotorSpeed(): number;
+        SetMaxMotorForce(force: number): void;
+        GetMaxMotorForce(): number;
+        GetMotorForce(inv_dt: number): number;
+        Dump(): void;
+    }
+
+    class RevoluteJointDef extends JointDef {
+        constructor();
+        localAnchorA: Vec2;
+        localAnchorB: Vec2;
+        referenceAngle: number;
+        enableLimit: boolean;
+        lowerAngle: number;
+        upperAngle: number;
+        enableMotor: boolean;
+        motorSpeed: number;
+        maxMotorTorque: number;
+    }
+
+    class RevoluteJoint extends Joint {
+        GetLocalAnchorA(): Vec2;
+        GetLocalAnchorB(): Vec2;
+        GetReferenceAngle(): number;
+        GetJointAngle(): number;
+        GetJointSpeed(): number;
+        IsLimitEnabled(): boolean;
+        EnableLimit(flag: boolean): void;
+        GetLowerLimit(): number;
+        GetUpperLimit(): number;
+        SetLimits(lower: number, upper: number): void;
+        IsMotorEnabled(): boolean;
+        EnableMotor(flag: boolean): void;
+        SetMotorSpeed(speed: number): void;
+        GetMotorSpeed(): number;
+        SetMaxMotorTorque(torque: number): void;
+        GetMaxMotorTorque(): number;
+        GetMotorTorque(inv_dt: number): number;
+        Dump(): void;
+    }
+
+    class RopeJointDef extends JointDef {
+        constructor();
+        localAnchorA: Vec2;
+        localAnchorB: Vec2;
+        maxLength: number;
+    }
+
+    class RopeJoint extends Joint {
+        GetLocalAnchorA(): Vec2;
+        GetLocalAnchorB(): Vec2;
+        GetReactionForce(inv_dt: number): Vec2;
+        GetReactionTorque(inv_dt: number): number;
+        SetMaxLength(length: number): void;
+        GetMaxLength(): number;
+        GetLength(): number;
+        Dump(): void;
+    }
+
+    class WeldJointDef extends JointDef {
+        constructor();
+        localAnchorA: Vec2;
+        localAnchorB: Vec2;
+        referenceAngle: number;
+        stiffness: number;
+        damping: number;
+    }
+
+    class WeldJoint extends Joint {
+        GetLocalAnchorA(): Vec2;
+        GetLocalAnchorB(): Vec2;
+        GetReferenceAngle(): number;
+        SetStiffness(stiffness: number): void;
+        GetStiffness(): number;
+        SetDamping(damping: number): void;
+        GetDamping(): number;
+        Dump(): void;
+    }
+
+    class WheelJointDef extends JointDef {
+        constructor();
+        localAnchorA: Vec2;
+        localAnchorB: Vec2;
+        localAxisA: Vec2;
+        enableLimit: boolean;
+        lowerTranslation: number;
+        upperTranslation: number;
+        enableMotor: boolean;
+        maxMotorTorque: number;
+        motorSpeed: number;
+        stiffness: number;
+        damping: number;
+    }
+
+    class WheelJoint extends Joint {
+        GetLocalAnchorA(): Vec2;
+        GetLocalAnchorB(): Vec2;
+        GetLocalAxisA(): Vec2;
+        GetJointTranslation(): number;
+        IsMotorEnabled(): boolean;
+        EnableMotor(flag: boolean): void;
+        SetMotorSpeed(speed: number): void;
+        GetMotorSpeed(): number;
+        SetMaxMotorTorque(torque: number): void;
+        GetMaxMotorTorque(): number;
+        GetMotorTorque(inv_dt: number): number;
+        SetStiffness(stiffness: number): void;
+        GetStiffness(): number;
+        SetDamping(damping: number): void;
+        GetDamping(): number;
+        Dump(): void;
+    }
+
+    //
+    // functions
+    //
+    function ConvexPartition(verticesIn: Vec2Vector, trianglesIn: Int32Vector, verticesOut: Vec2Vector, trianglesOut: Int32Vector): void;
+    function GetFloat32(memory: number, offset: number): number;
+    function SetLinearFrequencyAndDampingRatio(body: Joint, frequencyHertz: number, dampingRatio: number): void;
+
+    //Contact
+    function ContactSetEnabled(contactPtr: number, flag: boolean): void;
+    function ContactIsTouching(contactPtr: number): boolean;
+    function ContactSetTangentSpeed(contactPtr: number, speed: number): void;
+    function ContactGetTangentSpeed(contactPtr: number): number;
+    function ContactSetFriction(contactPtr: number, friction: number): void;
+    function ContactGetFriction(contactPtr: number): number;
+    function ContactResetFriction(contactPtr: number): void;
+    function ContactSetRestitution(contactPtr: number, restitution: number): void;
+    function ContactGetRestitution(contactPtr: number): number;
+    function ContactResetRestitution(contactPtr: number): void;
+    function ContactGetFixtureA(contactPtr: number): number;
+    function ContactGetFixtureB(contactPtr: number): number;
+    function ContactGetWorldManifold(contactPtr: number, worldManifoldPtr: number): number;
+    function ContactGetManifold(contactPtr: number): number;
+
+    //Manifold
+    function ManifoldGetType(manifoldPtr: number): number;
+    function ManifoldGetPointCount(manifoldPtr: number): number;
+    function ManifoldGetManifoldPointPtr(manifoldPtr: number, index: number): number;
+    function ManifoldGetLocalPointValueX(manifoldPtr: number): number;
+    function ManifoldGetLocalPointValueY(manifoldPtr: number): number;
+    function ManifoldGetLocalNormalValueX(manifoldPtr: number): number;
+    function ManifoldGetLocalNormalValueY(manifoldPtr: number): number;
+
+    //ManifoldPoint
+    function ManifoldPointGetLocalPointX(manifoldPointPtr: number): number;
+    function ManifoldPointGetLocalPointY(manifoldPointPtr: number): number;
+    function ManifoldPointGetNormalImpulse(manifoldPointPtr: number): number;
+    function ManifoldPointGetTangentImpulse(manifoldPointPtr: number): number;
+
+    //WorldManifold
+    function WorldManifoldNew(): number;
+    function WorldManifoldGetPointValueX(worldManifoldPtr: number, index: number): number;
+    function WorldManifoldGetPointValueY(worldManifoldPtr: number, index: number): number;
+    function WorldManifoldGetSeparationValue(worldManifoldPtr: number, index: number): number;
+    function WorldManifoldGetNormalValueX(worldManifoldPtr: number): number;
+    function WorldManifoldGetNormalValueY(worldManifoldPtr: number): number;
+    function WorldManifoldDelete(worldManifoldPtr: number): void;
+
+    //ContactImpulse
+    function ContactImpulseGetNormalImpulse(contactImpulsePtr: number, index: number): number;
+    function ContactImpulseGetTangentImpulse(contactImpulsePtr: number, index: number): number;
+    function ContactImpulseGetCount(contactImpulsePtr: number): number;
+}

emscripten/box2d/box2d.d.ts

@@ -0,0 +1,13 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./b2.d.ts" />
+
+declare module 'external:emscripten/box2d/box2d.release.asm.js' {
+    export default BOX2D;
+}
+
+declare module 'external:emscripten/box2d/box2d.release.wasm.js' {
+    export default BOX2D;
+}
+
+// tslint:disable
+declare function BOX2D (moduleOptions?: any): Promise<void>;

emscripten/bullet/bullet.d.ts

@@ -255,6 +255,7 @@ declare namespace Bullet {
         // CharacterController
         ControllerHitReport_new(): ptr;
         CharacterController_getGhostObject(ptrCCT: ptr): ptr;
+        CharacterController_getCollisionShape(ptrCCT: ptr): ptr;
         ControllerHit_getCurrentController(p: ptr): ptr;
         ControllerHit_getHitWorldPos(p: ptr): ptr;
         ControllerHit_getHitWorldNormal(p: ptr): ptr;

emscripten/external-wasm.d.ts

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

emscripten/spine/spine.d.ts

@@ -2,45 +2,16 @@ declare module 'external:emscripten/spine/spine.asm.js' {
     export default SpineWasm;
 }
 
+declare module 'external:emscripten/spine/spine.wasm.js' {
+    export default SpineWasm;
+}
+
+// tslint:disable
 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;
+        spineWasmInit(): void;
+        spineWasmDestroy(): void;
     }
 }

ohos/CMakeLists.txt

@@ -143,7 +143,8 @@ add_library(glslang-default-resource-limits STATIC IMPORTED GLOBAL)
 set_target_properties(glslang-default-resource-limits PROPERTIES
   IMPORTED_LOCATION ${ohos_lib_dir}/libglslang-default-resource-limits.a
 )
-set(glslang_libs_name glslang OGLCompiler OSDependent SPIRV glslang-default-resource-limits MachineIndependent GenericCodeGen)
+# Unable to link MachineIndependent with GenericCodeGen
+set(glslang_libs_name glslang OGLCompiler OSDependent SPIRV glslang-default-resource-limits)
 
 if(USE_PHYSICS_PHYSX)
   set(PhysXSDK PhysXCooking PhysXCharacterKinematic PhysXVehicle PhysXExtensions PhysX PhysXPvdSDK PhysXCommon PhysXFoundation)
@@ -214,7 +215,8 @@ list(APPEND CC_EXTERNAL_INCLUDES
   ${platform_spec_path}/include/v8
   ${platform_spec_path}/include/sqlite
   ${platform_spec_path}/include/png16
-  ${platform_spec_path}/include/uv
+  # Will conflict with the header file of harmonyos' standard library (error.h).
+  # ${platform_spec_path}/include/uv
 )
 
 #TODO: remove in future version

openharmony/CMakeLists.txt

@@ -72,6 +72,13 @@ set_target_properties(curl PROPERTIES
   IMPORTED_LOCATION ${ohos_lib_dir}/libcurl.a
 )
 
+# curl needs to link the following libraries.  
+list(APPEND CC_EXTERNAL_LIBS
+    mbedtls
+    mbedcrypto
+    mbedx509
+)
+
 set(se_libs_name)
 
 if(USE_SE_V8)
@@ -122,9 +129,6 @@ endif()
 if(USE_SOCKET)
     list(APPEND CC_EXTERNAL_LIBS
         websockets
-        mbedtls
-        mbedcrypto
-        mbedx509
     )
 endif()
 

versions.txt

@@ -40,7 +40,7 @@ png
     openharmony: 1.6.37
 sdl
     win32: 2.0.10
-    win64: 2.0.14
+    win64: 2.28.1
     linux: 2.0.20
 
 jpeg
@@ -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.4 )
-    win64:      cocos-v1.1.4 (commit: 9807544)
-    mac:        cocos-v1.1.4 (commit: 9807544)
-    linux:      cocos-v1.1.4 (commit: 9807544)
+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.6 )
+    win64:      cocos-v1.1.6 (commit: f52be17)
+    mac:        cocos-v1.1.6 (commit: f52be17)
+    linux:      cocos-v1.1.6 (commit: f52be17)