dacha 0.15.2 → 0.16.0

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.js

@@ -1,38 +1,31 @@
 import { Vector2 } from '../../../../../engine/math-lib';
-import { ActorCollection } from '../../../../../engine/actor';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
 import { Collision } from '../../../../events';
 import { RIGID_BODY_TYPE } from '../../consts';
 export class ConstraintSolver {
-    actorCollection;
     scene;
     processedPairs;
     mtvMap;
     constructor(options) {
-        this.actorCollection = new ActorCollection(options.scene, {
-            components: [
-                RigidBody,
-                Transform,
-            ],
-        });
         this.scene = options.scene;
-        this.processedPairs = {};
-        this.mtvMap = {};
+        this.processedPairs = new Map();
+        this.mtvMap = new Map();
         this.scene.addEventListener(Collision, this.handleCollision);
     }
     destroy() {
         this.scene.removeEventListener(Collision, this.handleCollision);
     }
     handleCollision = (event) => {
-        const { actor1, actor2, mtv1, mtv2, } = event;
-        const id1 = actor1.id;
-        const id2 = actor2.id;
-        if (this.processedPairs[id2] && this.processedPairs[id2][id1]) {
+        const { actor1, actor2, mtv1, mtv2 } = event;
+        if (this.processedPairs.has(actor2) &&
+            this.processedPairs.get(actor2).has(actor1)) {
             return;
         }
-        this.processedPairs[id1] ??= {};
-        this.processedPairs[id1][id2] = true;
+        if (!this.processedPairs.has(actor1)) {
+            this.processedPairs.set(actor1, new Set());
+        }
+        this.processedPairs.get(actor1).add(actor2);
         if (!this.validateCollision(actor1, actor2)) {
             return;
         }
@@ -44,64 +37,58 @@ export class ConstraintSolver {
         if (!rigidBody1 || !rigidBody2) {
             return false;
         }
-        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC && rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
+        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC &&
+            rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
             return false;
         }
-        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC || rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
+        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC ||
+            rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
             return !rigidBody1.ghost && !rigidBody2.ghost;
         }
-        return !rigidBody1.ghost && !rigidBody1.isPermeable
-            && !rigidBody2.ghost && !rigidBody2.isPermeable;
+        return (!rigidBody1.ghost &&
+            !rigidBody1.isPermeable &&
+            !rigidBody2.ghost &&
+            !rigidBody2.isPermeable);
     }
-    setMtv(id, mtvX, mtvY, type) {
-        this.mtvMap[id] = this.mtvMap[id] || {};
-        if (!this.mtvMap[id][type]) {
-            this.mtvMap[id][type] = new Vector2(mtvX, mtvY);
+    setMtv(actor, mtvX, mtvY, type) {
+        if (!this.mtvMap.has(actor)) {
+            this.mtvMap.set(actor, {});
+        }
+        const mtvs = this.mtvMap.get(actor);
+        if (!mtvs?.[type]) {
+            mtvs[type] = new Vector2(mtvX, mtvY);
             return;
         }
-        const settingStrategy = {
-            static: () => {
-                this.mtvMap[id][type].x = Math.abs(mtvX) > Math.abs(this.mtvMap[id][type].x)
-                    ? mtvX
-                    : this.mtvMap[id][type].x;
-                this.mtvMap[id][type].y = Math.abs(mtvY) > Math.abs(this.mtvMap[id][type].y)
-                    ? mtvY
-                    : this.mtvMap[id][type].y;
-            },
-            dynamic: () => {
-                this.mtvMap[id][type].x += mtvX;
-                this.mtvMap[id][type].y += mtvY;
-            },
-        };
-        settingStrategy[type]();
+        switch (type) {
+            case 'static':
+                mtvs[type].x =
+                    Math.abs(mtvX) > Math.abs(mtvs[type].x) ? mtvX : mtvs[type].x;
+                mtvs[type].y =
+                    Math.abs(mtvY) > Math.abs(mtvs[type].y) ? mtvY : mtvs[type].y;
+                break;
+            case 'dynamic':
+                mtvs[type].x += mtvX;
+                mtvs[type].y += mtvY;
+        }
     }
     resolveCollision(actor1, actor2, mtv1, mtv2) {
-        const id1 = actor1.id;
-        const id2 = actor2.id;
         const rigidBody1 = actor1.getComponent(RigidBody);
         const rigidBody2 = actor2.getComponent(RigidBody);
         if (rigidBody1.type === RIGID_BODY_TYPE.STATIC) {
-            this.setMtv(id2, mtv2.x, mtv2.y, rigidBody1.type);
+            this.setMtv(actor2, mtv2.x, mtv2.y, rigidBody1.type);
         }
         else if (rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
-            this.setMtv(id1, mtv1.x, mtv1.y, rigidBody2.type);
+            this.setMtv(actor1, mtv1.x, mtv1.y, rigidBody2.type);
         }
         else {
-            this.setMtv(id1, mtv1.x / 2, mtv1.y / 2, rigidBody2.type);
-            this.setMtv(id2, mtv2.x / 2, mtv2.y / 2, rigidBody1.type);
+            this.setMtv(actor1, mtv1.x / 2, mtv1.y / 2, rigidBody2.type);
+            this.setMtv(actor2, mtv2.x / 2, mtv2.y / 2, rigidBody1.type);
         }
     }
     update() {
-        Object.keys(this.mtvMap).forEach((id) => {
-            const actor = this.actorCollection.getById(id);
+        for (const [actor, entry] of this.mtvMap) {
             const transform = actor.getComponent(Transform);
-            const mtvs = Object.keys(this.mtvMap[id]);
-            if (mtvs.length === 1) {
-                transform.offsetX += this.mtvMap[id][mtvs[0]].x;
-                transform.offsetY += this.mtvMap[id][mtvs[0]].y;
-                return;
-            }
-            const { static: staticMtv, dynamic: dynamicMtv } = this.mtvMap[id];
+            const { static: staticMtv, dynamic: dynamicMtv } = entry;
             /*
              * TODO:: Enable this part when it will be possible to run
              * phycics pipeline several times per single game loop iteration
@@ -112,10 +99,10 @@ export class ConstraintSolver {
             // transform.offsetY += Math.sign(staticMtv.y) === Math.sign(dynamicMtv.y)
             //   ? staticMtv.y + dynamicMtv.y
             //   : staticMtv.y || dynamicMtv.y;
-            transform.offsetX += staticMtv.x + dynamicMtv.x;
-            transform.offsetY += staticMtv.y + dynamicMtv.y;
-        });
-        this.processedPairs = {};
-        this.mtvMap = {};
+            transform.offsetX += (staticMtv?.x ?? 0) + (dynamicMtv?.x ?? 0);
+            transform.offsetY += (staticMtv?.y ?? 0) + (dynamicMtv?.y ?? 0);
+        }
+        this.processedPairs.clear();
+        this.mtvMap.clear();
     }
 }

package/build/contrib/systems/physics-system/subsystems/physics/index.d.ts

@@ -1,7 +1,7 @@
 import type { SceneSystemOptions, UpdateOptions } from '../../../../../engine/system';
 export declare class PhysicsSubsystem {
     private scene;
-    private actorCollection;
+    private actorQuery;
     private gravity;
     private actorVectors;
     constructor(options: SceneSystemOptions);

package/build/contrib/systems/physics-system/subsystems/physics/index.js

@@ -1,8 +1,8 @@
 import { Vector2 } from '../../../../../engine/math-lib';
-import { ActorCollection } from '../../../../../engine/actor';
+import { ActorQuery } from '../../../../../engine/actor';
 import { RigidBody } from '../../../../components/rigid-body';
 import { Transform } from '../../../../components/transform';
-import { AddForce, AddImpulse, StopMovement, } from '../../../../events';
+import { AddForce, AddImpulse, StopMovement } from '../../../../events';
 import { RemoveActor } from '../../../../../engine/events';
 const DIRECTION_VECTOR = {
     UP: new Vector2(0, -1),
@@ -12,27 +12,22 @@ const DIRECTION_VECTOR = {
 };
 export class PhysicsSubsystem {
     scene;
-    actorCollection;
+    actorQuery;
     gravity;
     actorVectors;
     constructor(options) {
-        const { gravity, scene, } = options;
+        const { gravity, scene } = options;
         this.scene = scene;
-        this.actorCollection = new ActorCollection(scene, {
-            components: [
-                RigidBody,
-                Transform,
-            ],
-        });
+        this.actorQuery = new ActorQuery({ scene, filter: [RigidBody, Transform] });
         this.gravity = gravity;
         this.actorVectors = {};
-        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
         this.scene.addEventListener(StopMovement, this.handleStopMovement);
         this.scene.addEventListener(AddForce, this.handleAddForce);
         this.scene.addEventListener(AddImpulse, this.handleAddImpulse);
     }
     destroy() {
-        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
         this.scene.removeEventListener(StopMovement, this.handleStopMovement);
         this.scene.removeEventListener(AddForce, this.handleAddForce);
         this.scene.removeEventListener(AddImpulse, this.handleAddImpulse);
@@ -85,7 +80,8 @@ export class PhysicsSubsystem {
         const slowdown = velocity.clone();
         slowdown.multiplyNumber(slowdownValue * normalizationMultiplier);
         velocity.add(slowdown);
-        if (Math.sign(velocity.x) !== velocitySignX && Math.sign(velocity.y) !== velocitySignY) {
+        if (Math.sign(velocity.x) !== velocitySignX &&
+            Math.sign(velocity.y) !== velocitySignY) {
             velocity.multiplyNumber(0);
         }
     }
@@ -102,7 +98,7 @@ export class PhysicsSubsystem {
         const { deltaTime } = options;
         const deltaTimeInMsec = deltaTime;
         const deltaTimeInSeconds = deltaTimeInMsec / 1000;
-        this.actorCollection.forEach((actor) => {
+        this.actorQuery.getActors().forEach((actor) => {
             const rigidBody = actor.getComponent(RigidBody);
             const transform = actor.getComponent(Transform);
             const { mass } = rigidBody;

package/build/contrib/systems/renderer/builders/bitmap-text-builder/index.d.ts

@@ -0,0 +1,8 @@
+import { BitmapText as PixiBitmapText } from 'pixi.js';
+import type { Builder } from '../builder';
+import type { Actor } from '../../../../../engine/actor';
+export declare class BitmapTextBuilder implements Builder {
+    destroy(actor: Actor): void;
+    buildView(actor: Actor): PixiBitmapText | undefined;
+    updateView(actor: Actor): void;
+}

package/build/contrib/systems/renderer/builders/bitmap-text-builder/index.js

@@ -0,0 +1,115 @@
+import { BitmapText as PixiBitmapText, Bounds, Assets } from 'pixi.js';
+import { BLEND_MODE_MAPPING } from '../../consts';
+import { Transform } from '../../../../components/transform';
+import { BitmapText } from '../../../../components/bitmap-text';
+import { floatEquals } from '../utils';
+import { filterUnsupportedChars } from './utils';
+export class BitmapTextBuilder {
+    destroy(actor) {
+        const text = actor.getComponent(BitmapText);
+        text.renderData?.view.destroy();
+        text.renderData = undefined;
+    }
+    buildView(actor) {
+        const text = actor.getComponent(BitmapText);
+        if (!text) {
+            return undefined;
+        }
+        const { offsetX, offsetY } = actor.getComponent(Transform);
+        const view = new PixiBitmapText({
+            anchor: 0.5,
+            style: {
+                fontFamily: 'sans-serif',
+            },
+        });
+        text.renderData = { view };
+        view.__dacha = {
+            actor,
+            builderKey: BitmapText.componentName,
+            viewComponent: text,
+            bounds: new Bounds(offsetX, offsetY, offsetX, offsetY),
+            meta: {},
+            didChange: false,
+        };
+        return view;
+    }
+    updateView(actor) {
+        const transform = actor.getComponent(Transform);
+        const text = actor.getComponent(BitmapText);
+        if (!text) {
+            return undefined;
+        }
+        const view = text.renderData.view;
+        const meta = view.__dacha.meta;
+        view.__dacha.didChange = false;
+        if (text.disabled !== meta.disabled) {
+            view.visible = !text.disabled;
+            meta.disabled = text.disabled;
+            view.__dacha.didChange = true;
+        }
+        if (text.blending !== meta.blending) {
+            view.blendMode = BLEND_MODE_MAPPING[text.blending];
+            meta.blending = text.blending;
+            view.__dacha.didChange = true;
+        }
+        if (text.opacity !== meta.opacity) {
+            view.alpha = text.opacity;
+            meta.opacity = text.opacity;
+            view.__dacha.didChange = true;
+        }
+        // @ts-expect-error, comment: In order to avoid warning spam if value is missing
+        const font = Assets.cache._cache.get(text.font);
+        if (font && font.fontFamily !== meta.fontFamily) {
+            view.style.fontFamily = font.fontFamily;
+            meta.fontFamily = font.fontFamily;
+            view.__dacha.didChange = true;
+        }
+        if (text.text !== meta.text) {
+            const filteredText = font
+                ? filterUnsupportedChars(text.text, font)
+                : text.text;
+            if (filteredText.length !== text.text.length) {
+                console.warn(`Font contains unsupported characters: "${text.text}". Displaying filtered text instead.`);
+            }
+            view.text = filteredText;
+            meta.text = text.text;
+            view.__dacha.didChange = true;
+        }
+        if (text.fontSize !== meta.fontSize) {
+            view.style.fontSize = text.fontSize;
+            meta.fontSize = text.fontSize;
+            view.__dacha.didChange = true;
+        }
+        if (text.align !== meta.align) {
+            view.style.align = text.align;
+            meta.align = text.align;
+            view.__dacha.didChange = true;
+        }
+        if (text.color !== meta.color) {
+            view.style.fill = text.color;
+            meta.color = text.color;
+            view.__dacha.didChange = true;
+        }
+        const angle = transform.rotation;
+        if (angle !== meta.angle) {
+            view.angle = angle;
+            meta.angle = angle;
+            view.__dacha.didChange = true;
+        }
+        const { offsetX, offsetY } = transform;
+        if (!floatEquals(offsetX, meta.offsetX) ||
+            !floatEquals(offsetY, meta.offsetY)) {
+            view.position.set(offsetX, offsetY);
+            meta.offsetX = offsetX;
+            meta.offsetY = offsetY;
+            view.__dacha.didChange = true;
+        }
+        const { scaleX, scaleY } = transform;
+        if (scaleX !== meta.scaleX || scaleY !== meta.scaleY) {
+            view.scale.set(scaleX, scaleY);
+            meta.scaleX = scaleX;
+            meta.scaleY = scaleY;
+            view.__dacha.didChange = true;
+        }
+    }
+}

package/build/contrib/systems/renderer/builders/bitmap-text-builder/utils.d.ts

@@ -0,0 +1,2 @@
+import type { BitmapFont } from 'pixi.js';
+export declare const filterUnsupportedChars: (text: string, font: BitmapFont) => string;

package/build/contrib/systems/renderer/builders/bitmap-text-builder/utils.js

@@ -0,0 +1,7 @@
+const SPECIAL_SYMBOLS = new Set(['\n', '\r', '\t']);
+export const filterUnsupportedChars = (text, font) => {
+    return text
+        .split('')
+        .filter((char) => font.chars[char] || SPECIAL_SYMBOLS.has(char))
+        .join('');
+};

package/build/contrib/systems/renderer/builders/builder.d.ts

@@ -0,0 +1,7 @@
+import type { ViewContainer } from 'pixi.js';
+import type { Actor } from '../../../../engine/actor';
+export interface Builder {
+    destroy(actor: Actor): void;
+    buildView(actor: Actor): ViewContainer | undefined;
+    updateView(actor: Actor): void;
+}

package/build/contrib/systems/renderer/builders/index.d.ts

@@ -0,0 +1,5 @@
+export { SpriteBuilder } from './sprite-builder';
+export { ShapeBuilder } from './shape-builder';
+export { PixiViewBuilder } from './pixi-view-builder';
+export { BitmapTextBuilder } from './bitmap-text-builder';
+export type { Builder } from './builder';

package/build/contrib/systems/renderer/builders/index.js

@@ -0,0 +1,4 @@
+export { SpriteBuilder } from './sprite-builder';
+export { ShapeBuilder } from './shape-builder';
+export { PixiViewBuilder } from './pixi-view-builder';
+export { BitmapTextBuilder } from './bitmap-text-builder';

package/build/contrib/systems/renderer/builders/pixi-view-builder/index.d.ts

@@ -0,0 +1,8 @@
+import { type ViewContainer } from 'pixi.js';
+import type { Builder } from '../builder';
+import type { Actor } from '../../../../../engine/actor';
+export declare class PixiViewBuilder implements Builder {
+    destroy(actor: Actor): void;
+    buildView(actor: Actor): ViewContainer | undefined;
+    updateView(): void;
+}

package/build/contrib/systems/renderer/builders/pixi-view-builder/index.js

@@ -0,0 +1,31 @@
+import { Bounds } from 'pixi.js';
+import { Transform } from '../../../../components/transform';
+import { PixiView } from '../../../../components/pixi-view';
+export class PixiViewBuilder {
+    destroy(actor) {
+        const pixiView = actor.getComponent(PixiView);
+        pixiView.renderData?.view.destroy();
+        pixiView.renderData = undefined;
+    }
+    buildView(actor) {
+        const pixiView = actor.getComponent(PixiView);
+        if (!pixiView) {
+            return undefined;
+        }
+        const { offsetX, offsetY } = actor.getComponent(Transform);
+        const view = pixiView.createView();
+        pixiView.renderData = { view };
+        view.__dacha = {
+            actor,
+            builderKey: PixiView.componentName,
+            viewComponent: pixiView,
+            bounds: new Bounds(offsetX, offsetY, offsetX, offsetY),
+            meta: {},
+            didChange: false,
+        };
+        return view;
+    }
+    updateView() {
+        // nothing to do
+    }
+}

package/build/contrib/systems/renderer/builders/shape-builder/index.d.ts

@@ -0,0 +1,12 @@
+import { Graphics } from 'pixi.js';
+import type { Builder } from '../builder';
+import type { Actor } from '../../../../../engine/actor';
+export declare class ShapeBuilder implements Builder {
+    private graphicsContextMap;
+    constructor();
+    destroy(actor: Actor): void;
+    buildView(actor: Actor): Graphics | undefined;
+    updateView(actor: Actor): void;
+    private updateGraphicsContext;
+    private getGraphicsContext;
+}

package/build/contrib/systems/renderer/builders/shape-builder/index.js

@@ -0,0 +1,128 @@
+import { Graphics, Bounds } from 'pixi.js';
+import { BLEND_MODE_MAPPING } from '../../consts';
+import { Transform } from '../../../../components/transform';
+import { Shape } from '../../../../components/shape';
+import { CacheStore } from '../../../../../engine/data-lib';
+import { floatEquals } from '../utils';
+import { getGraphicsContext, getGraphicsContextKey } from './utils';
+export class ShapeBuilder {
+    graphicsContextMap;
+    constructor() {
+        this.graphicsContextMap = new CacheStore();
+    }
+    destroy(actor) {
+        const shape = actor.getComponent(Shape);
+        const graphicsContextKey = shape.renderData?.graphicsContextKey;
+        if (graphicsContextKey) {
+            this.graphicsContextMap.release(graphicsContextKey, true);
+        }
+        shape.renderData?.view.destroy();
+        shape.renderData = undefined;
+    }
+    buildView(actor) {
+        const shape = actor.getComponent(Shape);
+        if (!shape) {
+            return undefined;
+        }
+        const { offsetX, offsetY } = actor.getComponent(Transform);
+        const view = new Graphics();
+        shape.renderData = { view };
+        view.__dacha = {
+            actor,
+            builderKey: Shape.componentName,
+            viewComponent: shape,
+            bounds: new Bounds(offsetX, offsetY, offsetX, offsetY),
+            meta: {},
+            didChange: false,
+        };
+        return view;
+    }
+    updateView(actor) {
+        const transform = actor.getComponent(Transform);
+        const shape = actor.getComponent(Shape);
+        if (!shape) {
+            return undefined;
+        }
+        const view = shape.renderData.view;
+        const meta = view.__dacha.meta;
+        view.__dacha.didChange = false;
+        if (shape.disabled !== meta.disabled) {
+            view.visible = !shape.disabled;
+            meta.disabled = shape.disabled;
+            view.__dacha.didChange = true;
+        }
+        if (shape.blending !== meta.blending) {
+            view.blendMode = BLEND_MODE_MAPPING[shape.blending];
+            meta.blending = shape.blending;
+            view.__dacha.didChange = true;
+        }
+        if (shape.opacity !== meta.opacity) {
+            view.alpha = shape.opacity;
+            meta.opacity = shape.opacity;
+            view.__dacha.didChange = true;
+        }
+        const angle = transform.rotation;
+        if (angle !== meta.angle) {
+            view.angle = angle;
+            meta.angle = angle;
+            view.__dacha.didChange = true;
+        }
+        const { offsetX, offsetY } = transform;
+        if (!floatEquals(offsetX, meta.offsetX) ||
+            !floatEquals(offsetY, meta.offsetY)) {
+            view.position.set(offsetX, offsetY);
+            meta.offsetX = offsetX;
+            meta.offsetY = offsetY;
+            view.__dacha.didChange = true;
+        }
+        if (shape.type !== meta.type ||
+            shape.strokeWidth !== meta.strokeWidth ||
+            shape.strokeColor !== meta.strokeColor ||
+            shape.fill !== meta.fill ||
+            shape.width !== meta.width ||
+            shape.height !== meta.height ||
+            shape.radius !== meta.radius ||
+            shape.radiusX !== meta.radiusX ||
+            shape.radiusY !== meta.radiusY) {
+            view.label = shape.type;
+            this.updateGraphicsContext(shape);
+            meta.type = shape.type;
+            meta.strokeWidth = shape.strokeWidth;
+            meta.strokeColor = shape.strokeColor;
+            meta.fill = shape.fill;
+            meta.width = shape.width;
+            meta.height = shape.height;
+            meta.radius = shape.radius;
+            meta.radiusX = shape.radiusX;
+            meta.radiusY = shape.radiusY;
+            view.__dacha.didChange = true;
+        }
+        const graphicsContext = this.getGraphicsContext(shape);
+        view.context = graphicsContext;
+        const { scaleX, scaleY } = transform;
+        if (scaleX !== meta.scaleX || scaleY !== meta.scaleY) {
+            view.scale.set(scaleX, scaleY);
+            meta.scaleX = scaleX;
+            meta.scaleY = scaleY;
+            view.__dacha.didChange = true;
+        }
+    }
+    updateGraphicsContext(shape) {
+        const oldGraphicsContextKey = shape.renderData.graphicsContextKey;
+        if (oldGraphicsContextKey) {
+            this.graphicsContextMap.release(oldGraphicsContextKey, true);
+        }
+        shape.renderData.graphicsContextKey = getGraphicsContextKey(shape);
+        const graphicsContextKey = shape.renderData.graphicsContextKey;
+        if (this.graphicsContextMap.has(graphicsContextKey)) {
+            this.graphicsContextMap.retain(graphicsContextKey);
+            return;
+        }
+        const graphicsContext = getGraphicsContext(shape);
+        this.graphicsContextMap.add(graphicsContextKey, graphicsContext);
+        this.graphicsContextMap.retain(graphicsContextKey);
+    }
+    getGraphicsContext(shape) {
+        return this.graphicsContextMap.get(shape.renderData.graphicsContextKey);
+    }
+}

package/build/contrib/systems/renderer/builders/shape-builder/utils.d.ts

@@ -0,0 +1,4 @@
+import { GraphicsContext } from 'pixi.js';
+import { Shape } from '../../../../components/shape';
+export declare const getGraphicsContext: (shape: Shape) => GraphicsContext;
+export declare const getGraphicsContextKey: (shape: Shape) => string;

package/build/contrib/systems/renderer/builders/shape-builder/utils.js

@@ -0,0 +1,85 @@
+import { GraphicsContext } from 'pixi.js';
+export const getGraphicsContext = (shape) => {
+    switch (shape.type) {
+        case 'rectangle': {
+            const { width, height, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            const rectangle = new GraphicsContext()
+                .rect(-width / 2, -height / 2, width, height)
+                .stroke({
+                width: strokeWidth,
+                alignment: strokeAlignment,
+                color: strokeColor,
+                pixelLine,
+            });
+            if (fill) {
+                rectangle.fill(fill);
+            }
+            return rectangle;
+        }
+        case 'roundRectangle': {
+            const { width, height, radius, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            const rectangle = new GraphicsContext()
+                .roundRect(-width / 2, -height / 2, width, height, radius)
+                .stroke({
+                width: strokeWidth,
+                alignment: strokeAlignment,
+                color: strokeColor,
+                pixelLine,
+            });
+            if (fill) {
+                rectangle.fill(fill);
+            }
+            return rectangle;
+        }
+        case 'circle': {
+            const { radius, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            const circle = new GraphicsContext()
+                .circle(0, 0, radius)
+                .stroke({
+                width: strokeWidth,
+                alignment: strokeAlignment,
+                color: strokeColor,
+                pixelLine,
+            });
+            if (fill) {
+                circle.fill(fill);
+            }
+            return circle;
+        }
+        case 'ellipse': {
+            const { radiusX, radiusY, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            const ellipse = new GraphicsContext()
+                .ellipse(0, 0, radiusX, radiusY)
+                .stroke({
+                width: strokeWidth,
+                alignment: strokeAlignment,
+                color: strokeColor,
+                pixelLine,
+            });
+            if (fill) {
+                ellipse.fill(fill);
+            }
+            return ellipse;
+        }
+    }
+};
+export const getGraphicsContextKey = (shape) => {
+    switch (shape.type) {
+        case 'rectangle': {
+            const { type, width, height, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            return `${type}_${width}_${height}_${strokeWidth}_${strokeColor}_${strokeAlignment}_${fill}_${pixelLine}`;
+        }
+        case 'roundRectangle': {
+            const { type, width, height, radius, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            return `${type}_${width}_${height}_${radius}_${strokeWidth}_${strokeColor}_${strokeAlignment}_${fill}_${pixelLine}`;
+        }
+        case 'circle': {
+            const { type, radius, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            return `${type}_${radius}_${strokeWidth}_${strokeColor}_${strokeAlignment}_${fill}_${pixelLine}`;
+        }
+        case 'ellipse': {
+            const { type, radiusX, radiusY, strokeWidth, strokeColor, strokeAlignment, fill, pixelLine, } = shape;
+            return `${type}_${radiusX}_${radiusY}_${strokeWidth}_${strokeColor}_${strokeAlignment}_${fill}_${pixelLine}`;
+        }
+    }
+};