@safe-engine/cocos 1.5.2 → 1.5.5

package/dist/box2d-wasm/PhysicsSystem.js

@@ -0,0 +1,139 @@
+import Box2DFactory from 'box2d-wasm';
+import { EventTypes } from 'entityx-ts';
+import { GameWorld, instantiate, NodeComp } from '..';
+import { makeContactListener } from './ContactListener';
+import { makeDebugDraw } from './debugDraw';
+import { BoxColliderPhysics, CircleColliderPhysics, ColliderPhysics, PhysicsMaterial, PolygonColliderPhysics, RigidBody, } from './PhysicsComponent';
+import { PhysicsSprite } from './PhysicsSprite';
+export let box2D;
+export function initBox2d(cb) {
+    Box2DFactory().then((b2) => {
+        box2D = b2;
+        cb();
+    });
+}
+// Box2D.b2Fixture.prototype.shouldCollide = function (other) {
+//   const nodeThis: NodeComp = this.getBody().getUserData()
+//   const nodeOther = other.getBody().getUserData() as NodeComp
+//   const { colliderMatrix } = GameWorld.Instance.systems.get(PhysicsSystem)
+//   return colliderMatrix[nodeOther.group][nodeThis.group]
+// }
+export function setColliderMatrix(colliderMatrix = [[true]]) {
+    const physicsSystem = GameWorld.Instance.systems.get(PhysicsSystem);
+    physicsSystem.colliderMatrix = colliderMatrix;
+}
+const maxTimeStep = 1 / 60;
+const velocityIterations = 1;
+const positionIterations = 1;
+const metadata = {};
+const pixelsPerMeter = 1;
+export class PhysicsSystem {
+    world;
+    listRemoveBody = [];
+    listRemoveShape = [];
+    colliderMatrix = [[true]];
+    graphics;
+    configure(event_manager) {
+        const { b2BodyDef, b2_dynamicBody, b2_staticBody, b2FixtureDef, b2PolygonShape, b2Vec2, b2World, getPointer, b2ContactListener } = box2D;
+        const gravity = new b2Vec2(0, -10);
+        this.world = new b2World(gravity);
+        console.log('configure PhysicsSystem world', this.world);
+        // event_manager.world.physicsManager = this
+        const graphics = new cc.DrawNode();
+        this.graphics = graphics;
+        graphics.zIndex = 1000;
+        const scene = cc.director.getRunningScene();
+        scene.addChild(graphics);
+        const debugDraw = makeDebugDraw(graphics, pixelsPerMeter, box2D);
+        this.world.SetDebugDraw(debugDraw);
+        // event_manager.subscribe(ComponentAddedEvent(RigidBody), this);
+        event_manager.subscribe(EventTypes.ComponentAdded, BoxColliderPhysics, ({ entity, component }) => {
+            console.log('ComponentAddedEvent BoxColliderPhysics', component);
+            let rigidBody = entity.getComponent(RigidBody);
+            if (!rigidBody) {
+                rigidBody = instantiate(RigidBody);
+                entity.assign(rigidBody);
+            }
+            const { type = 'static', gravityScale = 1 } = rigidBody.props;
+            const physicsMaterial = entity.getComponent(PhysicsMaterial);
+            const { density = 1, friction = 0.5, restitution = 0.3 } = physicsMaterial?.props || {};
+            const box = component;
+            const node = entity.getComponent(NodeComp);
+            const { width, height, ...colliderProps } = box.props;
+            // ett.assign(instantiate(ColliderPhysics, { tag, offset }))
+            const { x = 0, y = 0 } = colliderProps.offset || {};
+            const zero = new b2Vec2(0, 0);
+            const position = new b2Vec2(node.posX, node.posY);
+            const offset = new b2Vec2(x, y);
+            const bd = new b2BodyDef();
+            bd.set_type(type === 'dynamic' ? b2_dynamicBody : b2_staticBody);
+            bd.set_position(zero);
+            bd.set_gravityScale(gravityScale);
+            const body = this.world.CreateBody(bd);
+            rigidBody.body = body;
+            // console.log('body', type, b2_dynamicBody, b2_staticBody, getPointer(body));
+            // body.setMassData({ mass: 1 } as any)
+            const physicsNode = new PhysicsSprite(node.instance, body);
+            const square = new b2PolygonShape();
+            square.SetAsBox(width / 2, height / 2);
+            const fixtureDef = new b2FixtureDef();
+            fixtureDef.set_shape(square);
+            fixtureDef.set_density(density);
+            fixtureDef.set_friction(friction);
+            fixtureDef.set_restitution(restitution);
+            body.CreateFixture(fixtureDef);
+            body.SetTransform(position, 0);
+            body.SetLinearVelocity(zero);
+            body.SetAwake(true);
+            body.SetEnabled(true);
+            metadata[getPointer(body)] = node;
+            const physicsCollide = entity.assign(instantiate(ColliderPhysics, colliderProps));
+            physicsCollide.instance = physicsNode;
+            physicsCollide.node = node;
+            box.node = node;
+        });
+        event_manager.subscribe(EventTypes.ComponentAdded, CircleColliderPhysics, () => { });
+        event_manager.subscribe(EventTypes.ComponentAdded, PolygonColliderPhysics, () => { });
+        event_manager.subscribe(EventTypes.ComponentRemoved, NodeComp, ({ entity }) => {
+            // log('ComponentRemovedEvent NodeComp', event);
+            const node = entity.getComponent(NodeComp);
+            if (node.instance instanceof PhysicsSprite) {
+                const body = node.instance.getBody();
+                // this.listRemoveShape.push(...body.shapeList)
+                this.listRemoveBody.push(body);
+            }
+        });
+        const listener = makeContactListener(this.world, metadata, box2D);
+        this.world.SetContactListener(listener);
+    }
+    update(entities, events, dt) {
+        if (this.world) {
+            const { getPointer } = box2D;
+            // remove bodies and shapes
+            this.listRemoveBody.forEach((body) => {
+                if (body) {
+                    this.world.DestroyBody(getPointer(body));
+                }
+            });
+            // this.listRemoveShape.forEach((shape) => {
+            //   if (shape) {
+            //     this.world.DestroyShape(shape)
+            //   }
+            // })
+            this.listRemoveBody = [];
+            this.listRemoveShape = [];
+            const clampedDelta = Math.min(dt, maxTimeStep);
+            this.world.Step(clampedDelta, velocityIterations, positionIterations);
+            this.graphics.clear();
+            this.world.DebugDraw();
+            // console.log('GetBodyCount', this.world.GetBodyCount())
+        }
+    }
+    set enabled(val) {
+        if (val) {
+            this.world.SetGravity(new Box2D.b2Vec2(0, -9.8));
+            // this.world.iterations = 60
+            // this.world.collisionSlop = 0.5
+        }
+    }
+}

package/dist/box2d-wasm/debugDraw.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Forked from Box2D.js
+ * @see https://github.com/kripken/box2d.js/blob/f75077b/helpers/embox2d-helpers.js
+ * @author dmagunov + Huy Nguyen + fork contributions from Alex Birch
+ * @see https://github.com/kripken/box2d.js/blob/49dddd6/helpers/embox2d-html5canvas-debugDraw.js
+ * @author dmagunov + fork contributions from Alex Birch
+ * @license Zlib https://opensource.org/licenses/Zlib
+ * License evidence: https://github.com/kripken/box2d.js/blob/master/README.markdown#box2djs
+ *   "box2d.js is zlib licensed, just like Box2D."
+ *
+ * @typedef {import('box2d-wasm')} Box2DFactory
+ * @param {CanvasRenderingContext2D} ctx
+ * @param {number} pixelsPerMeter
+ * @param {typeof Box2D & EmscriptenModule} box2D
+ */
+export declare const makeDebugDraw: (graphics: cc.DrawNode, pixelsPerMeter: any, box2D: typeof Box2D) => Box2D.JSDraw & {
+    /**
+     * @param {number} vert1_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} vert2_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} color_p pointer to {@link Box2D.b2Color}
+     * @returns {void}
+     */
+    DrawSegment(vert1_p: any, vert2_p: any, color_p: any): void;
+    /**
+     * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
+     * @param {number} vertexCount
+     * @param {number} color_p pointer to {@link Box2D.b2Color}
+     * @returns {void}
+     */
+    DrawPolygon(vertices_p: any, vertexCount: any, color_p: any): void;
+    /**
+     * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
+     * @param {number} vertexCount
+     * @param {number} color_p pointer to {@link Box2D.b2Color}
+     * @returns {void}
+     */
+    DrawSolidPolygon(vertices_p: any, vertexCount: any, color_p: any): void;
+    /**
+     * @param {number} center_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} radius
+     * @param {number} color_p pointer to {@link Box2D.b2Color}
+     * @returns {void}
+     */
+    DrawCircle(center_p: any, radius: any, color_p: any): void;
+    /**
+     * @param {number} center_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} radius
+     * @param {number} axis_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} color_p pointer to {@link Box2D.b2Color}
+     * @returns {void}
+     */
+    DrawSolidCircle(center_p: any, radius: any, axis_p: any, color_p: any): void;
+    /**
+     * @param {number} transform_p pointer to {@link Box2D.b2Transform}
+     * @returns {void}
+     */
+    DrawTransform(transform_p: any): void;
+    /**
+     * @param {number} vertex_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} sizeMetres
+     * @param {number} pointer to {@link Box2D.b2Color}
+     * @returns {void}
+     */
+    DrawPoint(vertex_p: any, sizeMetres: any, color_p: any): void;
+};
+//# sourceMappingURL=debugDraw.d.ts.map

package/dist/box2d-wasm/debugDraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugDraw.d.ts","sourceRoot":"","sources":["../../src/box2d-wasm/debugDraw.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU,EAAE,CAAC,QAAQ,EAAE,mBAAc,EAAE,OAAO,OAAO,KAAK;IA6HpF;;;;;OAKG;;IAQH;;;;;OAKG;;IAQH;;;;;OAKG;;IAOH;;;;;OAKG;;IAQH;;;;;;OAMG;;IAQH;;;OAGG;;IAKH;;;;;OAKG;;CAUN,CAAA"}

package/dist/box2d-wasm/debugDraw.js

@@ -0,0 +1,210 @@
+import { Color4B, Vec2 } from '../polyfills';
+/**
+ * Forked from Box2D.js
+ * @see https://github.com/kripken/box2d.js/blob/f75077b/helpers/embox2d-helpers.js
+ * @author dmagunov + Huy Nguyen + fork contributions from Alex Birch
+ * @see https://github.com/kripken/box2d.js/blob/49dddd6/helpers/embox2d-html5canvas-debugDraw.js
+ * @author dmagunov + fork contributions from Alex Birch
+ * @license Zlib https://opensource.org/licenses/Zlib
+ * License evidence: https://github.com/kripken/box2d.js/blob/master/README.markdown#box2djs
+ *   "box2d.js is zlib licensed, just like Box2D."
+ *
+ * @typedef {import('box2d-wasm')} Box2DFactory
+ * @param {CanvasRenderingContext2D} ctx
+ * @param {number} pixelsPerMeter
+ * @param {typeof Box2D & EmscriptenModule} box2D
+ */
+export const makeDebugDraw = (graphics, pixelsPerMeter, box2D) => {
+    const { b2Color, b2Draw: { e_shapeBit }, b2Transform, b2Vec2, JSDraw, wrapPointer, } = box2D;
+    /**
+     * to replace original C++ operator =
+     * @param {Box2D.b2Vec2} vec
+     * @returns {Box2D.b2Vec2}
+     */
+    // const copyVec2 = (vec: Box2D.b2Vec2) => new b2Vec2(vec.get_x(), vec.get_y())
+    /**
+     * to replace original C++ operator *= (float)
+     * @param {Box2D.b2Vec2} vec
+     * @param {number} scale
+     * @returns {Box2D.b2Vec2}
+     */
+    // const scaledVec2 = (vec: Box2D.b2Vec2, scale: number) => new b2Vec2(scale * vec.get_x(), scale * vec.get_y())
+    /**
+     * @param {Box2D.b2Color} color
+     * @returns {string}
+     */
+    const getRgbStr = (color) => {
+        const red = (color.get_r() * 255) | 0;
+        const green = (color.get_g() * 255) | 0;
+        const blue = (color.get_b() * 255) | 0;
+        return Color4B(red, green, blue, 100);
+    };
+    /**
+     * @param {string} rgbStr
+     * @returns {void}
+     */
+    const setCtxColor = (rgbStr) => {
+        graphics.color = rgbStr;
+        // graphics.strokeStyle = { color: rgbStr }
+    };
+    /**
+     * @param {Box2D.b2Vec2[]} vertices
+     * @param {boolean} fill
+     * @returns {void}
+     */
+    const drawPolygon = (vertices, fill) => {
+        // console.log("drawPolygon", vertices[0].y, fill);
+        graphics.drawPoly(vertices, Color4B(255, 0, 0, 50), fill ? 1 : 0);
+        // graphics.drawPoly(vertices[vertices.length - 1].x * pixelsPerMeter, vertices[vertices.length - 1].y * pixelsPerMeter)
+        // vertices.forEach((v) => {
+        //   graphics.lineTo(v.x * pixelsPerMeter, v.y * pixelsPerMeter)
+        // })
+        // graphics.fill()
+    };
+    /**
+     * @param {Box2D.b2Vec2} center
+     * @param {number} radius
+     * @param {Box2D.b2Vec2} axis
+     * @param {boolean} fill
+     * @returns {void}
+     */
+    const drawCircle = (center, radius, axis, fill) => {
+        graphics.drawCircle(center, radius, 0, 64, true, 6, fill);
+    };
+    /**
+     * @param {Box2D.b2Vec2} vert1
+     * @param {Box2D.b2Vec2} vert2
+     * @returns {void}
+     */
+    const drawSegment = (vert1, vert2) => {
+        // console.log("drawSegment", vert1, vert2)
+        graphics.drawSegment(Vec2(vert1.get_x(), vert1.get_y()), Vec2(vert2.get_x(), vert2.get_y()));
+    };
+    /**
+     * @param {Box2D.b2Vec2} vertex
+     * @param {number} sizeMetres
+     * @returns {void}
+     */
+    const drawPoint = (vertex, sizeMetres) => {
+        const sizePixels = sizeMetres / pixelsPerMeter;
+        graphics.drawDot(Vec2(vertex.get_x() - sizePixels / 2, vertex.get_y() - sizePixels / 2), sizePixels);
+    };
+    /**
+     * @param {Box2D.b2Transform} transform
+     * @param {number} sizeMetres
+     * @returns {void}
+     */
+    const drawTransform = (transform) => {
+        const pos = transform.get_p();
+        const rot = transform.get_q();
+        graphics.drawSegment(Vec2(pos.get_x(), pos.get_y()), Vec2(pos.get_x() + rot.GetXAxis().get_x(), pos.get_y() + rot.GetXAxis().get_y()));
+        // graphics.setTransform()
+        // graphics.save()
+        // graphics.translateTransform(pos.get_x(), pos.get_y())
+        // graphics.scaleTransform(0.5, 0.5)
+        // graphics.rotateTransform(rot.GetAngle())
+        // graphics.lineWidth *= 2;
+        // graphics.restore()
+    };
+    /** {@link Box2D.b2Vec2} is a struct of `float x, y` */
+    const sizeOfB2Vec = Float32Array.BYTES_PER_ELEMENT * 2;
+    /**
+     * @param {number} array_p pointer to {@link Box2D.b2Vec2}
+     * @param {number} numElements length of array
+     * @param {number} sizeOfElement size of an instance of the array element
+     * @param {typeof Box2D.b2Vec2} ctor constructor for the array element
+     * @return {Box2D.b2Vec2[]}
+     */
+    const reifyArray = (array_p, numElements, sizeOfElement, ctor) => Array(numElements)
+        .fill(undefined)
+        .map((_, index) => wrapPointer(array_p + index * sizeOfElement, ctor));
+    const debugDraw = Object.assign(new JSDraw(), {
+        /**
+         * @param {number} vert1_p pointer to {@link Box2D.b2Vec2}
+         * @param {number} vert2_p pointer to {@link Box2D.b2Vec2}
+         * @param {number} color_p pointer to {@link Box2D.b2Color}
+         * @returns {void}
+         */
+        DrawSegment(vert1_p, vert2_p, color_p) {
+            const color = wrapPointer(color_p, b2Color);
+            setCtxColor(getRgbStr(color));
+            const vert1 = wrapPointer(vert1_p, b2Vec2);
+            const vert2 = wrapPointer(vert2_p, b2Vec2);
+            drawSegment(vert1, vert2);
+        },
+        /**
+         * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
+         * @param {number} vertexCount
+         * @param {number} color_p pointer to {@link Box2D.b2Color}
+         * @returns {void}
+         */
+        DrawPolygon(vertices_p, vertexCount, color_p) {
+            const color = wrapPointer(color_p, b2Color);
+            setCtxColor(getRgbStr(color));
+            const vertices = reifyArray(vertices_p, vertexCount, sizeOfB2Vec, b2Vec2);
+            drawPolygon(vertices, color);
+            // console.log(`DrawPolygon`, getRgbStr(color).green, vertices[0].y)
+        },
+        /**
+         * @param {number} vertices_p pointer to Array<{@link Box2D.b2Vec2}>
+         * @param {number} vertexCount
+         * @param {number} color_p pointer to {@link Box2D.b2Color}
+         * @returns {void}
+         */
+        DrawSolidPolygon(vertices_p, vertexCount, color_p) {
+            const color = wrapPointer(color_p, b2Color);
+            setCtxColor(getRgbStr(color));
+            const vertices = reifyArray(vertices_p, vertexCount, sizeOfB2Vec, b2Vec2);
+            drawPolygon(vertices, true);
+        },
+        /**
+         * @param {number} center_p pointer to {@link Box2D.b2Vec2}
+         * @param {number} radius
+         * @param {number} color_p pointer to {@link Box2D.b2Color}
+         * @returns {void}
+         */
+        DrawCircle(center_p, radius, color_p) {
+            const color = wrapPointer(color_p, b2Color);
+            setCtxColor(getRgbStr(color));
+            const center = wrapPointer(center_p, b2Vec2);
+            const dummyAxis = new b2Vec2(0, 0);
+            drawCircle(center, radius, dummyAxis, false);
+        },
+        /**
+         * @param {number} center_p pointer to {@link Box2D.b2Vec2}
+         * @param {number} radius
+         * @param {number} axis_p pointer to {@link Box2D.b2Vec2}
+         * @param {number} color_p pointer to {@link Box2D.b2Color}
+         * @returns {void}
+         */
+        DrawSolidCircle(center_p, radius, axis_p, color_p) {
+            const color = wrapPointer(color_p, b2Color);
+            setCtxColor(getRgbStr(color));
+            const center = wrapPointer(center_p, b2Vec2);
+            const axis = wrapPointer(axis_p, b2Vec2);
+            drawCircle(center, radius, axis, true);
+        },
+        /**
+         * @param {number} transform_p pointer to {@link Box2D.b2Transform}
+         * @returns {void}
+         */
+        DrawTransform(transform_p) {
+            const transform = wrapPointer(transform_p, b2Transform);
+            drawTransform(transform);
+        },
+        /**
+         * @param {number} vertex_p pointer to {@link Box2D.b2Vec2}
+         * @param {number} sizeMetres
+         * @param {number} pointer to {@link Box2D.b2Color}
+         * @returns {void}
+         */
+        DrawPoint(vertex_p, sizeMetres, color_p) {
+            const color = wrapPointer(color_p, b2Color);
+            setCtxColor(getRgbStr(color));
+            const vertex = wrapPointer(vertex_p, b2Vec2);
+            drawPoint(vertex, sizeMetres);
+        },
+    });
+    debugDraw.SetFlags(e_shapeBit);
+    return debugDraw;
+};

package/dist/box2d-wasm/index.d.ts

@@ -0,0 +1,6 @@
+import { GameWorld } from '..';
+export * from './PhysicsComponent';
+export * from './PhysicsSprite';
+export * from './PhysicsSystem';
+export declare function setupPhysics(world?: GameWorld): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/box2d-wasm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/box2d-wasm/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAA;AAG9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAE/B,wBAAgB,YAAY,CAAC,KAAK,YAAqB,QAItD"}

package/dist/box2d-wasm/index.js

@@ -0,0 +1,10 @@
+import { GameWorld } from '..';
+import { PhysicsSystem } from './PhysicsSystem';
+export * from './PhysicsComponent';
+export * from './PhysicsSprite';
+export * from './PhysicsSystem';
+export function setupPhysics(world = GameWorld.Instance) {
+    world.systems.add(PhysicsSystem);
+    world.systems.configureOnce(PhysicsSystem);
+    world.listUpdate.push(PhysicsSystem);
+}