@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/visualization/FurnitureGuildCustomizedVisualization.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureGuildCustomizedVisualization = void 0;
+const getIntFromHex_1 = require("../../../util/getIntFromHex");
+const AnimatedFurnitureVisualization_1 = require("./AnimatedFurnitureVisualization");
+const FurnitureVisualization_1 = require("./FurnitureVisualization");
+class FurnitureGuildCustomizedVisualization extends FurnitureVisualization_1.FurnitureVisualization {
+    constructor(options = {}) {
+        super();
+        this._base = new AnimatedFurnitureVisualization_1.AnimatedFurnitureVisualization();
+        this._refreshModifier = false;
+        this.primaryColor = this._normalizeColor(options.primaryColor);
+        this.secondaryColor = this._normalizeColor(options.secondaryColor);
+    }
+    get primaryColor() {
+        return this._primaryColor;
+    }
+    set primaryColor(value) {
+        this._primaryColor = value;
+        this._refreshModifier = true;
+    }
+    get secondaryColor() {
+        return this._secondaryColor;
+    }
+    set secondaryColor(value) {
+        this._secondaryColor = value;
+        this._refreshModifier = true;
+    }
+    isAnimated() {
+        return true;
+    }
+    update() {
+        this._base.update();
+    }
+    setView(view) {
+        super.setView(view);
+        this._base.setView(view);
+    }
+    destroy() {
+        this._base.destroy();
+    }
+    updateFrame(frame) {
+        if (this._refreshModifier) {
+            this._refreshModifier = false;
+            this._updateModifier();
+        }
+        this._base.updateFrame(frame);
+    }
+    updateDirection(direction) {
+        this._base.updateDirection(direction);
+    }
+    updateAnimation(animation) {
+        this._base.updateAnimation(animation);
+    }
+    _updateModifier() {
+        this._base.modifier = (part) => {
+            return this._modifyPart(part);
+        };
+    }
+    _normalizeColor(color) {
+        if (color == null || color.length === 0) {
+            return undefined;
+        }
+        if (color[0] === "#") {
+            return color.slice(1);
+        }
+        return color;
+    }
+    _modifyPart(part) {
+        switch (part.tag) {
+            case FurnitureGuildCustomizedVisualization.PRIMARY_COLOR_TAG:
+                if (this._primaryColor != null) {
+                    part.setColor((0, getIntFromHex_1.getIntFromHex)(this._primaryColor));
+                }
+                break;
+            case FurnitureGuildCustomizedVisualization.SECONDARY_COLOR_TAG:
+                if (this._secondaryColor != null) {
+                    part.setColor((0, getIntFromHex_1.getIntFromHex)(this._secondaryColor));
+                }
+                break;
+        }
+        return part;
+    }
+}
+exports.FurnitureGuildCustomizedVisualization = FurnitureGuildCustomizedVisualization;
+FurnitureGuildCustomizedVisualization.PRIMARY_COLOR_TAG = "COLOR1";
+FurnitureGuildCustomizedVisualization.SECONDARY_COLOR_TAG = "COLOR2";

package/dist/objects/furniture/visualization/FurnitureVisualization.d.ts

@@ -0,0 +1,16 @@
+import { IFurnitureVisualization } from "../IFurnitureVisualization";
+import { IFurnitureVisualizationView } from "../IFurnitureVisualizationView";
+export declare abstract class FurnitureVisualization implements IFurnitureVisualization {
+    protected _view: IFurnitureVisualizationView | undefined;
+    protected _previousView: IFurnitureVisualizationView | undefined;
+    protected get view(): IFurnitureVisualizationView;
+    protected get previousView(): IFurnitureVisualizationView | undefined;
+    protected get mounted(): boolean;
+    setView(view: IFurnitureVisualizationView): void;
+    isAnimated(animation?: string): boolean;
+    abstract update(): void;
+    abstract destroy(): void;
+    abstract updateFrame(frame: number): void;
+    abstract updateDirection(direction: number): void;
+    abstract updateAnimation(animation: string): void;
+}

package/dist/objects/furniture/visualization/FurnitureVisualization.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureVisualization = void 0;
+class FurnitureVisualization {
+    get view() {
+        if (this._view == null)
+            throw new Error("No view mounted");
+        return this._view;
+    }
+    get previousView() {
+        return this._previousView;
+    }
+    get mounted() {
+        return this._view != null;
+    }
+    setView(view) {
+        this._previousView = this._view;
+        this._view = view;
+    }
+    isAnimated(animation = "0") {
+        return false;
+    }
+}
+exports.FurnitureVisualization = FurnitureVisualization;

package/dist/objects/hitdetection/ClickHandler.d.ts

@@ -0,0 +1,25 @@
+import { IEventManagerEvent } from "../events/interfaces/IEventManagerEvent";
+import { HitEventHandler } from "./HitSprite";
+export declare class ClickHandler {
+    private _doubleClickInfo?;
+    private _map;
+    private _onClick;
+    private _onDoubleClick;
+    private _onPointerDown;
+    private _onPointerUp;
+    get onClick(): HitEventHandler | undefined;
+    set onClick(value: HitEventHandler | undefined);
+    get onDoubleClick(): HitEventHandler | undefined;
+    set onDoubleClick(value: HitEventHandler | undefined);
+    get onPointerDown(): HitEventHandler | undefined;
+    set onPointerDown(value: HitEventHandler | undefined);
+    get onPointerUp(): HitEventHandler | undefined;
+    set onPointerUp(value: HitEventHandler | undefined);
+    handleClick(event: IEventManagerEvent): void;
+    handlePointerDown(event: IEventManagerEvent): void;
+    handlePointerUp(event: IEventManagerEvent): void;
+    private _performDoubleClick;
+    private _resetDoubleClick;
+    private _startDoubleClick;
+    reset(): void;
+}

package/dist/objects/hitdetection/ClickHandler.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClickHandler = void 0;
+class ClickHandler {
+    constructor() {
+        this._map = new Map();
+    }
+    get onClick() {
+        return this._onClick;
+    }
+    set onClick(value) {
+        this._onClick = value;
+    }
+    get onDoubleClick() {
+        return this._onDoubleClick;
+    }
+    set onDoubleClick(value) {
+        this._onDoubleClick = value;
+    }
+    get onPointerDown() {
+        return this._onPointerDown;
+    }
+    set onPointerDown(value) {
+        this._onPointerDown = value;
+    }
+    get onPointerUp() {
+        return this._onPointerUp;
+    }
+    set onPointerUp(value) {
+        this._onPointerUp = value;
+    }
+    handleClick(event) {
+        if (this._doubleClickInfo == null) {
+            this.onClick && this.onClick(event);
+            if (this.onDoubleClick != null) {
+                this._startDoubleClick(event);
+            }
+        }
+        else {
+            event.stopPropagation();
+            this._performDoubleClick(event);
+        }
+    }
+    handlePointerDown(event) {
+        this.onPointerDown && this.onPointerDown(event);
+    }
+    handlePointerUp(event) {
+        this.onPointerUp && this.onPointerUp(event);
+    }
+    _performDoubleClick(event) {
+        if (this._doubleClickInfo == null)
+            return;
+        this.onDoubleClick &&
+            this.onDoubleClick(this._doubleClickInfo.initialEvent);
+        setTimeout(() => {
+            this._resetDoubleClick();
+        });
+    }
+    _resetDoubleClick() {
+        if (this._doubleClickInfo == null)
+            return;
+        clearTimeout(this._doubleClickInfo.timeout);
+        this._doubleClickInfo = undefined;
+    }
+    _startDoubleClick(event) {
+        this._doubleClickInfo = {
+            initialEvent: event,
+            timeout: window.setTimeout(() => this._resetDoubleClick(), 350),
+        };
+    }
+    reset() {
+        if (this._doubleClickInfo != null) {
+            clearTimeout(this._doubleClickInfo.timeout);
+            this._doubleClickInfo = undefined;
+        }
+        this._map.clear();
+    }
+}
+exports.ClickHandler = ClickHandler;

package/dist/objects/hitdetection/HitSprite.d.ts

@@ -0,0 +1,65 @@
+import * as PIXI from "pixi.js";
+import { Observable } from "rxjs";
+import { EventEmitter } from "../events/EventEmitter";
+import { IEventGroup } from "../events/interfaces/IEventGroup";
+import { IEventManager } from "../events/interfaces/IEventManager";
+import { IEventManagerEvent } from "../events/interfaces/IEventManagerEvent";
+import { IEventTarget } from "../events/interfaces/IEventTarget";
+import { Hitmap } from "../furniture/util/loadFurni";
+import { Rectangle } from "../room/IRoomRectangle";
+import { HitTexture } from "./HitTexture";
+export type HitEventHandler = (event: IEventManagerEvent) => void;
+export declare class HitSprite extends PIXI.Sprite implements IEventTarget {
+    private _group;
+    private _hitTexture;
+    private _tag;
+    private _mirrored;
+    private _ignore;
+    private _ignoreMouse;
+    private _eventManager;
+    private _rectangleSubject;
+    private _eventEmitter;
+    private _getHitmap;
+    get events(): EventEmitter<HitSpriteEventMap>;
+    constructor({ eventManager, mirrored, getHitmap, tag, group, }: {
+        eventManager: IEventManager;
+        getHitmap?: () => Hitmap;
+        mirrored?: boolean;
+        tag?: string;
+        group: IEventGroup;
+    });
+    getGroup(): IEventGroup;
+    getRectangleObservable(): Observable<Rectangle | undefined>;
+    getEventZOrder(): number;
+    triggerPointerTargetChanged(event: IEventManagerEvent): void;
+    triggerClick(event: IEventManagerEvent): void;
+    triggerPointerDown(event: IEventManagerEvent): void;
+    triggerPointerUp(event: IEventManagerEvent): void;
+    triggerPointerOver(event: IEventManagerEvent): void;
+    triggerPointerOut(event: IEventManagerEvent): void;
+    createDebugSprite(): PIXI.TilingSprite | undefined;
+    get ignoreMouse(): boolean;
+    set ignoreMouse(value: boolean);
+    get group(): IEventGroup;
+    get ignore(): boolean;
+    set ignore(value: boolean);
+    get mirrored(): boolean;
+    set mirrored(value: boolean);
+    get hitTexture(): HitTexture | undefined;
+    set hitTexture(value: HitTexture | undefined);
+    getHitDetectionZIndex(): number;
+    destroy(): void;
+    getHitBox(): Rectangle;
+    private _getGlobalScale;
+    hits(x: number, y: number): boolean;
+    private _lastRect;
+    private _emitRectangle;
+}
+export type HitSpriteEventMap = {
+    click: IEventManagerEvent;
+    pointerup: IEventManagerEvent;
+    pointerdown: IEventManagerEvent;
+    pointerover: IEventManagerEvent;
+    pointerout: IEventManagerEvent;
+    pointertargetchanged: IEventManagerEvent;
+};

package/dist/objects/hitdetection/HitSprite.js

@@ -0,0 +1,223 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitSprite = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const rxjs_1 = require("rxjs");
+const EventEmitter_1 = require("../events/EventEmitter");
+class HitSprite extends PIXI.Sprite {
+    get events() {
+        return this._eventEmitter;
+    }
+    constructor({ eventManager, mirrored = false, getHitmap, tag, group, }) {
+        super();
+        this._ignore = false;
+        this._ignoreMouse = false;
+        this._rectangleSubject = new rxjs_1.BehaviorSubject(undefined);
+        this._eventEmitter = new EventEmitter_1.EventEmitter();
+        this._emitRectangle = () => {
+            var _a, _b;
+            let width = this.texture.width;
+            let height = this.texture.height;
+            let x = this.worldTransform.tx - (this._mirrored ? width : 0);
+            let y = this.worldTransform.ty;
+            const m = (_b = (_a = this._eventManager).getCoordinateRootMatrix) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (m != null) {
+                x = (x - m.tx) / m.a;
+                y = (y - m.ty) / m.d;
+            }
+            const last = this._lastRect;
+            if (last != null &&
+                last.x === x &&
+                last.y === y &&
+                last.width === width &&
+                last.height === height) {
+                return;
+            }
+            this._lastRect = { x, y, width, height };
+            this._rectangleSubject.next(this._lastRect);
+        };
+        this._group = group;
+        this._mirrored = mirrored;
+        this._getHitmap = getHitmap;
+        this._tag = tag;
+        this.mirrored = this._mirrored;
+        this._eventManager = eventManager;
+        this.onRender = this._emitRectangle;
+        eventManager.register(this);
+    }
+    getGroup() {
+        return this._group;
+    }
+    getRectangleObservable() {
+        return this._rectangleSubject;
+    }
+    getEventZOrder() {
+        return this.zIndex;
+    }
+    triggerPointerTargetChanged(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointertargetchanged", event);
+    }
+    triggerClick(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("click", event);
+        event.stopPropagation();
+    }
+    triggerPointerDown(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerdown", event);
+    }
+    triggerPointerUp(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerup", event);
+    }
+    triggerPointerOver(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerover", event);
+    }
+    triggerPointerOut(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerout", event);
+    }
+    createDebugSprite() {
+        if (this._hitTexture == null)
+            return;
+        const hitMap = this._hitTexture.getHitMap();
+        if (hitMap == null)
+            return;
+        const sprite = new PIXI.TilingSprite({
+            texture: PIXI.Texture.WHITE,
+            width: this._hitTexture.texture.width,
+            height: this._hitTexture.texture.height,
+        });
+        sprite.alpha = 0.1;
+        sprite.x = this.getGlobalPosition().x;
+        sprite.y = this.getGlobalPosition().y;
+        return sprite;
+    }
+    get ignoreMouse() {
+        return this._ignoreMouse;
+    }
+    set ignoreMouse(value) {
+        this._ignoreMouse = value;
+    }
+    get group() {
+        return this._group;
+    }
+    get ignore() {
+        return this._ignore;
+    }
+    set ignore(value) {
+        this._ignore = value;
+    }
+    get mirrored() {
+        return this._mirrored;
+    }
+    set mirrored(value) {
+        this._mirrored = value;
+        this.scale.x = this._mirrored ? -1 : 1;
+    }
+    get hitTexture() {
+        return this._hitTexture;
+    }
+    set hitTexture(value) {
+        if (value != null) {
+            this.texture = value.texture;
+            this._hitTexture = value;
+            this._getHitmap = () => (x, y, transform) => value.hits(x, y, transform, {
+                mirrorHorizonally: this._mirrored,
+            });
+        }
+    }
+    getHitDetectionZIndex() {
+        return this.zIndex;
+    }
+    destroy() {
+        super.destroy();
+        this._eventManager.remove(this);
+    }
+    getHitBox() {
+        const pos = this.getGlobalPosition();
+        const { x: scaleX, y: scaleY } = this._getGlobalScale();
+        const width = this.texture.width * scaleX;
+        const height = this.texture.height * scaleY;
+        if (this._mirrored) {
+            return {
+                x: pos.x - width,
+                y: pos.y,
+                width,
+                height,
+            };
+        }
+        return {
+            x: pos.x,
+            y: pos.y,
+            width,
+            height,
+        };
+    }
+    _getGlobalScale() {
+        const transform = this.worldTransform;
+        return {
+            x: Math.sqrt(transform.a * transform.a + transform.b * transform.b) || 1,
+            y: Math.sqrt(transform.c * transform.c + transform.d * transform.d) || 1,
+        };
+    }
+    hits(x, y) {
+        if (this._getHitmap == null)
+            return false;
+        if (this.ignore)
+            return false;
+        if (this.ignoreMouse)
+            return false;
+        const hitBox = this.getHitBox();
+        const inBoundsX = hitBox.x <= x && x <= hitBox.x + hitBox.width;
+        const inBoundsY = hitBox.y <= y && y <= hitBox.y + hitBox.height;
+        if (inBoundsX && inBoundsY) {
+            const hits = this._getHitmap();
+            const pos = this.getGlobalPosition();
+            const scale = this._getGlobalScale();
+            return hits(x, y, {
+                x: pos.x,
+                y: pos.y,
+                scaleX: scale.x,
+                scaleY: scale.y,
+            });
+        }
+        return false;
+    }
+}
+exports.HitSprite = HitSprite;

package/dist/objects/hitdetection/HitTexture.d.ts

@@ -0,0 +1,21 @@
+import * as PIXI from "pixi.js";
+export declare class HitTexture {
+    private _texture;
+    private _cachedHitmap;
+    get texture(): PIXI.Texture<PIXI.TextureSource<any>>;
+    constructor(texture: PIXI.Texture);
+    static fromSpriteSheet(spritesheet: PIXI.Spritesheet, name: string): Promise<HitTexture>;
+    static fromHitmap(hitmap: Uint32Array, width: number, height: number): HitTexture;
+    static fromBlob(blob: Blob): Promise<HitTexture>;
+    static fromUrl(imageUrl: string): Promise<HitTexture>;
+    getHitMap(): Uint32Array<ArrayBufferLike>;
+    hits(x: number, y: number, transform: {
+        x: number;
+        y: number;
+        scaleX?: number;
+        scaleY?: number;
+    }, options?: {
+        mirrorHorizonally?: boolean;
+    }): boolean;
+    private _getHitMap;
+}

package/dist/objects/hitdetection/HitTexture.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitTexture = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const applyTextureProperties_1 = require("../../util/applyTextureProperties");
+const loadImageFromBlob_1 = require("../../util/loadImageFromBlob");
+class HitTexture {
+    get texture() {
+        return this._texture;
+    }
+    constructor(texture) {
+        this._texture = texture;
+        (0, applyTextureProperties_1.applyTextureProperties)(this._texture);
+    }
+    static async fromSpriteSheet(spritesheet, name) {
+        const texture = spritesheet.textures[name];
+        if (texture == null) {
+            throw new Error(`Texture "${name}" not found in spritesheet`);
+        }
+        return new HitTexture(texture);
+    }
+    static fromHitmap(hitmap, width, height) {
+        const source = {
+            resource: { width, height },
+            resolution: 1,
+            pixelWidth: width,
+            scaleMode: "nearest",
+        };
+        const texture = {
+            source,
+            orig: { x: 0, y: 0 },
+            frame: { x: 0, y: 0, width, height },
+        };
+        const instance = new HitTexture(texture);
+        instance._cachedHitmap = hitmap;
+        return instance;
+    }
+    static async fromBlob(blob) {
+        const url = await (0, loadImageFromBlob_1.loadImageFromBlob)(blob);
+        return HitTexture.fromUrl(url);
+    }
+    static async fromUrl(imageUrl) {
+        const image = new Image();
+        // We set the crossOrigin here so the image element
+        // can fetch and display images hosted on another origin.
+        // Thanks to @danielsolartech for reporting.
+        // TODO: Add option to configure this somewhere?
+        image.crossOrigin = "anonymous";
+        image.src = imageUrl;
+        await new Promise((resolve, reject) => {
+            image.onload = () => {
+                resolve({ width: image.width, height: image.height });
+            };
+            image.onerror = (value) => reject(value);
+        });
+        const texture = PIXI.Texture.from(image);
+        return new HitTexture(texture);
+    }
+    getHitMap() {
+        return this._getHitMap();
+    }
+    hits(x, y, transform, options = { mirrorHorizonally: false }) {
+        var _a, _b;
+        const scaleX = (_a = transform.scaleX) !== null && _a !== void 0 ? _a : 1;
+        const scaleY = (_b = transform.scaleY) !== null && _b !== void 0 ? _b : 1;
+        if (options.mirrorHorizonally) {
+            x = -(x - transform.x) / scaleX;
+        }
+        else {
+            x = (x - transform.x) / scaleX;
+        }
+        y = (y - transform.y) / scaleY;
+        const frame = this._texture.frame;
+        const width = Math.max(1, Math.round(frame.width));
+        const height = Math.max(1, Math.round(frame.height));
+        const dx = Math.round(x);
+        const dy = Math.round(y);
+        if (dx < 0 || dy < 0 || dx >= width || dy >= height)
+            return false;
+        const hitmap = this._getHitMap();
+        const ind = dx + dy * width;
+        const ind1 = ind % 32;
+        const ind2 = (ind / 32) | 0;
+        return (hitmap[ind2] & (1 << ind1)) !== 0;
+    }
+    _getHitMap() {
+        var _a;
+        if (this._cachedHitmap == null) {
+            this._cachedHitmap = generateHitMap(this._texture);
+        }
+        return (_a = this._cachedHitmap) !== null && _a !== void 0 ? _a : new Uint32Array();
+    }
+}
+exports.HitTexture = HitTexture;
+function generateHitMap(texture) {
+    const source = texture.source.resource;
+    if (source == null)
+        return new Uint32Array();
+    const frame = texture.frame;
+    const w = Math.max(1, Math.round(frame.width));
+    const h = Math.max(1, Math.round(frame.height));
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    const context = canvas.getContext("2d", { willReadFrequently: true });
+    if (context == null)
+        throw new Error("Invalid context 2d");
+    context.drawImage(source, Math.round(frame.x), Math.round(frame.y), w, h, 0, 0, w, h);
+    const threshold = 25;
+    const imageData = context.getImageData(0, 0, w, h);
+    const hitmap = new Uint32Array(Math.ceil((w * h) / 32));
+    for (let i = 0; i < w * h; i++) {
+        const ind1 = i % 32;
+        const ind2 = (i / 32) | 0;
+        if (imageData.data[i * 4 + 3] >= threshold) {
+            hitmap[ind2] = hitmap[ind2] | (1 << ind1);
+        }
+    }
+    return hitmap;
+}