@makefully/platypus 4.1.4 → 4.1.6

package/src/shapes/castFromObject.js

@@ -0,0 +1,53 @@
+/* global platypus */
+import Capsule from './Capsule';
+import Circle from './Circle';
+import Ellipse from './Ellipse';
+import Polygon from './Polygon';
+import Polyline from './Polyline';
+import Rectangle from './Rectangle';
+import RoundedRectangle from './RoundedRectangle';
+import Segment from './Segment';
+import Point from './Point';
+
+const
+    SHAPES = {
+        capsule: Capsule,
+        circle: Circle,
+        ellipse: Ellipse,
+        polygon: Polygon,
+        polyline: Polyline,
+        rectangle: Rectangle,
+        roundedRectangle: RoundedRectangle,
+        segment: Segment,
+        point: Point
+    };
+
+export default function castFromObject (shapeData, prioritizedShapeList = ['roundedRectangle', 'rectangle', 'capsule', 'ellipse', 'segment', 'polygon', 'polyline', 'circle', 'point']) {
+    const
+        {type} = shapeData;
+
+    if (type && prioritizedShapeList.indexOf(type) >= 0) {
+        const
+            Shape = SHAPES[type];
+
+        if (Shape?.validateDefinition(shapeData)) {
+            return new Shape(shapeData);
+        }
+    } else {
+        const
+            {length} = prioritizedShapeList;
+            
+        for (let i = 0; i < length; i++) {
+            const
+                Shape = SHAPES[prioritizedShapeList[i]];
+
+            if (Shape?.validateDefinition(shapeData)) {
+                return new Shape(shapeData);
+            }
+        }
+    }
+
+    platypus.debug.warn('Unable to create a shape matching provided data.', shapeData);
+
+    return null;
+}

package/src/shapes/castFromPixiGraphics.js

@@ -0,0 +1,6 @@
+/* global platypus */
+
+export default function castFromPixiGraphics () {
+    platypus.debug.warn(`Unable to cast from Pixi Graphics.`);
+    return null;
+}

package/src/shapes/castFromPixiShape.js

@@ -0,0 +1,89 @@
+import castFromObject from "./castFromObject";
+
+/* global platypus */
+const
+    castTo = {
+        circle: (shape, {scale = 1}) => {
+            const
+                {radius, type, x, y} = shape;
+                
+            return {
+                radius: radius * scale,
+                type,
+                x: x * scale,
+                y: y * scale
+            };
+        },
+        ellipse: (shape, {scale = 1}) => {
+            const
+                {halfHeight, halfWidth, type, x, y} = shape;
+                
+            return {
+                height: halfHeight * 2 * scale,
+                type,
+                width: halfWidth * 2 * scale,
+                x: x * scale,
+                y: y * scale
+            };
+        },
+        point: (shape, {scale = 1}) => {
+            const
+                {x, y} = shape;
+                
+            return {
+                type: 'point',
+                x: x * scale,
+                y: y * scale
+            };
+        },
+        polygon: (shape, {scale = 1}) => {
+            const
+                {closePath, points} = shape;
+                
+            return {
+                type: closePath ? 'polygon' : 'polyline',
+                points: points.map(({x, y}) => ({
+                    x: x * scale,
+                    y: y * scale
+                }))
+            };
+        },
+        rectangle: (shape, {scale = 1}) => {
+            const
+                {height, type, width, x, y} = shape;
+
+            return {
+                height: height * scale,
+                type,
+                width: width * scale,
+                x: x * scale,
+                y: y * scale
+            };
+        },
+        roundedRectangle: (shape, {scale = 1}) => {
+            const
+                {height, radius, type, width, x, y} = shape;
+
+            return {
+                height: height * scale,
+                radius: radius * scale,
+                type,
+                width: width * scale,
+                x: x * scale,
+                y: y * scale
+            };
+        }
+    };
+
+export default function castFromPixiShape (shape, options) {
+    const
+        {type} = shape,
+        cast = typeof type === 'string' ? castTo[type] : castTo.point;
+
+    if (cast) {
+        return castFromObject(cast(shape, options));
+    } else {
+        platypus.debug.warn(`Unable to cast shape of type "${type}" from Box2D.`, shape);
+        return null;
+    }
+}

package/src/shapes/castToBox2D.js

@@ -0,0 +1,190 @@
+import adjustedXY from "./adjustedXY";
+
+/* global platypus */
+const
+    formatChainSD = (shapeDefinition) => {
+        const
+            {b2DefaultChainDef} = platypus.game.box2d;
+
+        if (shapeDefinition instanceof b2DefaultChainDef) {
+            return shapeDefinition;
+        } else {
+            const
+                {
+                    enableSensorEvents = false,
+                    filter,
+                    isLoop = false,
+                    materials,
+                    points
+                } = shapeDefinition,
+                csd = new b2DefaultChainDef();
+
+            if (filter) {
+                csd.filter.categoryBits = filter.categoryBits ?? 0;
+                csd.filter.groupIndex = filter.groupIndex ?? 0;
+                csd.filter.maskBits = filter.maskBits ?? 0xffff;
+            }
+
+            csd.SetMaterials(materials);
+            csd.SetPoints(points);
+
+            csd.enableSensorEvents = enableSensorEvents;
+            csd.isLoop = isLoop;
+            
+            return csd;
+        }
+    },
+    formatSD = (shapeDefinition) => {
+        const
+            {b2DefaultShapeDef} = platypus.game.box2d;
+
+        if (shapeDefinition instanceof b2DefaultShapeDef) {
+            return shapeDefinition;
+        } else {
+            const
+                {
+                    density = 1,
+                    enableContactEvents = false,
+                    enableHitEvents = false,
+                    enablePreSolveEvents = false,
+                    enableSensorEvents = false,
+                    filter,
+                    invokeContactCreation = false,
+                    isSensor = false,
+                    material,
+                    updateBodyMass = true
+                } = shapeDefinition,
+                sd = new b2DefaultShapeDef();
+
+            if (filter) {
+                sd.filter.categoryBits = filter.categoryBits ?? 0;
+                sd.filter.groupIndex = filter.groupIndex ?? 0;
+                sd.filter.maskBits = filter.maskBits ?? 0xffff;
+            }
+
+            if (material) {
+                sd.material.customColor = material.customColor ?? 0;
+                sd.material.friction = material.friction ?? 0.5;
+                sd.material.restitution = material.restitution ?? 0.2;
+                sd.material.rollingResistance = material.rollingResistance ?? 0;
+                sd.material.tangentSpeed = material.tangentSpeed ?? 0;
+                sd.material.userMaterialId = material.userMaterialId ?? 0;
+            }
+
+            sd.density = density;
+            sd.enableContactEvents = enableContactEvents;
+            sd.enableHitEvents = enableHitEvents;
+            sd.enablePreSolveEvents = enablePreSolveEvents;
+            sd.enableSensorEvents = enableSensorEvents;
+            sd.invokeContactCreation = invokeContactCreation;
+            sd.isSensor = isSensor;
+            sd.updateBodyMass = updateBodyMass;
+
+            return sd;
+        }
+    },
+    createCapsule = (shape, options) => {
+        const
+            {bodyId, scale = 1, shapeDefinition} = options,
+            {b2Capsule, b2CreateCapsuleShape} = platypus.game.box2d,
+            {radius, a, b} = shape,
+            {x: ax, y: ay} = adjustedXY(a, options),
+            {x: bx, y: by} = adjustedXY(b, options),
+            capsule = new b2Capsule();
+
+        capsule.radius = radius * scale;
+        capsule.center1.Set(ax, ay);
+        capsule.center2.Set(bx, by);
+
+        return b2CreateCapsuleShape(bodyId, formatSD(shapeDefinition), capsule);
+    },
+    createPoint = (shape, options) => {
+        const
+            v = new platypus.game.box2d.b2Vec2(),
+            {x, y} = adjustedXY(shape, options);
+
+        v.x = x;
+        v.y = y;
+    
+        return v;
+    },
+    createPolygon = (shape, options) => {
+        const
+            {chain = false, shapeDefinition} = options;
+
+        if (chain) {
+            return createPolyline(shape, {
+                ...options,
+                shapeDefinition: {
+                    ...shapeDefinition,
+                    isLoop: true
+                }
+            });
+        } else {
+            const
+                {bodyId, local = true, radius = 0, scale = 1, shapeDefinition} = options,
+                {b2CreatePolygonShape, b2ComputeHull, b2MakePolygon} = platypus.game.box2d,
+                polygons = shape.split(3, 8); // break down polygon to chunks equal to or smaller than 8 vertices and make sure these chunks are convex.
+                
+            return polygons.map(({points}) => b2CreatePolygonShape(bodyId, formatSD(shapeDefinition), b2MakePolygon(b2ComputeHull(points.map((point) => createPoint(point, {local, scale})), points.length), radius)));
+        }
+    },
+    createPolyline = ({points}, {bodyId, local = true, scale = 1, shapeDefinition}) => {
+        const
+            {b2CreateChain} = platypus.game.box2d;
+            
+        return b2CreateChain(bodyId, formatChainSD({
+            ...shapeDefinition,
+            points: points.map((point) => createPoint(point, {local, scale}))
+        }));
+    },
+    castFrom = {
+        capsule: createCapsule,
+        circle: (shape, options) => {
+            const
+                {radius} = shape,
+                {bodyId, scale = 1, shapeDefinition} = options,
+                {b2Circle, b2CreateCircleShape} = platypus.game.box2d,
+                {x, y} = adjustedXY(shape, options),
+                circle = new b2Circle();
+
+            circle.radius = radius * scale;
+            circle.center.Set(x, y);
+
+            return b2CreateCircleShape(bodyId, formatSD(shapeDefinition), circle);
+        },
+        ellipse: (shape, ...args) => {
+            return createCapsule(shape.toCapsule(), ...args);
+        },
+        point: createPoint,
+        polygon: createPolygon,
+        polyline: createPolyline,
+        rectangle: createPolygon,
+        roundedRectangle: createPolygon,
+        segment: ({a, b}, options) => {
+            const
+                s = new platypus.game.box2d.b2Segment(),
+                {x: ax, y: ay} = adjustedXY(a, options),
+                {x: bx, y: by} = adjustedXY(b, options);
+            
+            s.point1.x = ax;
+            s.point1.y = ay;
+            s.point2.x = bx;
+            s.point2.y = by;
+        
+            return s;
+        }
+    };
+
+export default function castToBox2D (shape, options = {}) {
+    const
+        {type} = shape,
+        cast = castFrom[type];
+
+    if (cast) {
+        return cast(shape, options);
+    } else {
+        platypus.debug.warn(`Unable to cast shape of type "${type}" to Box2D.`, shape);
+        return null;
+    }
+}

package/src/shapes/castToPixiGraphics.js

@@ -0,0 +1,100 @@
+/* global platypus */
+import {Graphics} from 'pixi.js';
+import adjustedXY from "./adjustedXY";
+
+const
+    finish = (gfx, {fill, stroke}) => {
+        if (typeof fill === 'number') {
+            gfx.fill(fill);
+        }
+        if (typeof stroke === 'number') {
+            gfx.stroke(stroke);
+        }
+        return gfx;
+    },
+    getGraphics = ({graphics}) => graphics ?? new Graphics(),
+    castFrom = {
+        circle: (shape, options) => {
+            const
+                gfx = getGraphics(options),
+                {radius} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+
+            gfx.circle(x, y, radius * scale);
+            
+            return finish(gfx, options);
+        },
+        ellipse: (shape, options) => {
+            const
+                gfx = getGraphics(options),
+                {halfHeight, halfWidth} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+                
+            gfx.ellipse(x, y, halfWidth * scale, halfHeight * scale);
+
+            return finish(gfx, options);
+        },
+        point: (shape, options) => {
+            const
+                gfx = getGraphics(options),
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+
+            gfx.circle(x, y, scale);
+            
+            return finish(gfx, options);
+        },
+        polygon: (shape, options) => {
+            const
+                gfx = getGraphics(options);
+
+            gfx.poly(shape.points.map((point) => adjustedXY(point, options)), true);
+
+            return finish(gfx, options);
+        },
+        polyline: (shape, options) => {
+            const
+                gfx = getGraphics(options);
+
+            gfx.poly(shape.points.map((point) => adjustedXY(point, options)), false);
+
+            return finish(gfx, options);
+        },
+        rectangle: (shape, options) => {
+            const
+                gfx = getGraphics(options),
+                {height, width} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+
+            gfx.rect(x, y, width * scale, height * scale);
+
+            return finish(gfx, options);
+        },
+        roundedRectangle: (shape, options) => {
+            const
+                gfx = getGraphics(options),
+                {height, radius, width} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+
+            gfx.filletRect(x, y, width * scale, height * scale, -radius * scale);
+
+            return finish(gfx, options);
+        }
+    };
+
+export default function castToPixiGraphics (shape, options = {}) {
+    const
+        {type} = shape,
+        cast = castFrom[type];
+
+    if (cast) {
+        return cast(shape, options);
+    } else {
+        platypus.debug.warn(`Unable to cast shape of type "${type}" to Pixi Graphics.`, shape);
+        return null;
+    }
+}

package/src/shapes/castToPixiShape.js

@@ -0,0 +1,61 @@
+/* global platypus */
+import {Circle, Ellipse, Point, Polygon, Rectangle, RoundedRectangle} from 'pixi.js';
+import adjustedXY from "./adjustedXY";
+
+const
+    castFrom = {
+        circle: (shape, options) => {
+            const
+                {radius} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+                
+            return new Circle(x, y, radius * scale);
+        },
+        ellipse: (shape, options) => {
+            const
+                {halfHeight, halfWidth} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+                
+            return new Ellipse(x, y, halfWidth * scale, halfHeight * scale);
+        },
+        point: (shape, options) => {
+            const
+                {x, y} = adjustedXY(shape, options);
+
+            return new Point(x, y);
+        },
+        polygon: (shape, {local = true, scale = 1}) => {
+            return new Polygon(shape.toArray1D(local).map((c) => c * scale));
+        },
+        rectangle: (shape, options) => {
+            const
+                {height, width} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+
+            return new Rectangle(x, y, width * scale, height * scale);
+        },
+        roundedRectangle: (shape, options) => {
+            const
+                {height, radius, width} = shape,
+                {scale = 1} = options,
+                {x, y} = adjustedXY(shape, options);
+
+            return new RoundedRectangle(x, y, width * scale, height * scale, radius * scale);
+        }
+    };
+
+export default function castToPixiShape (shape, options = {}) {
+    const
+        {type} = shape,
+        cast = castFrom[type];
+
+    if (cast) {
+        return cast(shape, options);
+    } else {
+        platypus.debug.warn(`Unable to cast shape of type "${type}" to Pixi Shape.`, shape);
+        return null;
+    }
+}