@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/data/interfaces/IFurnitureLogicData.d.ts

@@ -0,0 +1,13 @@
+export interface IFurnitureLogicData {
+    getLogic(): FurnitureLogic | undefined;
+}
+export interface FurnitureLogic {
+    type: string;
+    dimensions: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    directions: number[];
+    particleSystemSize?: number;
+}

package/dist/objects/furniture/data/interfaces/IFurnitureLogicData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/data/interfaces/IFurnitureVisualizationData.d.ts

@@ -0,0 +1,37 @@
+export interface IFurnitureVisualizationData {
+    getLayerCount(size: number): number;
+    getLayer(size: number, layerId: number): FurnitureLayer | undefined;
+    getDirections(size: number): number[];
+    getAnimationIds(size: number): number[];
+    getDirectionLayer(size: number, direction: number, layerId: number): FurnitureDirectionLayer | undefined;
+    getAnimationLayer(size: number, animationId: number, id: number): FurnitureAnimationLayer | undefined;
+    getFrameCountWithoutRepeat(size: number, animationId: number): number | undefined;
+    getFrameCount(size: number, animationId: number): number | undefined;
+    getColor(size: number, colorId: number, layerId: number): string | undefined;
+    getAnimation(size: number, animationId: number): FurnitureAnimation | undefined;
+    getTransitionForAnimation(size: number, animationId: number): FurnitureAnimation | undefined;
+}
+export interface FurnitureAnimation {
+    id: number;
+    transitionTo?: number;
+}
+export interface FurnitureLayer {
+    id: number;
+    z: number;
+    tag?: string;
+    ignoreMouse?: boolean;
+    alpha?: number;
+    ink?: string;
+}
+export interface FurnitureDirectionLayer {
+    x?: number;
+    y?: number;
+    z?: number;
+}
+export interface FurnitureAnimationLayer {
+    id: number;
+    frames: number[];
+    frameRepeat?: number;
+    random?: boolean;
+    loopCount?: number;
+}

package/dist/objects/furniture/data/interfaces/IFurnitureVisualizationData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/filter/ActiveWiredFilter.d.ts

@@ -0,0 +1,4 @@
+import * as PIXI from "pixi.js";
+export declare class ActiveWiredFilter extends PIXI.Filter {
+    constructor();
+}

package/dist/objects/furniture/filter/ActiveWiredFilter.js

@@ -0,0 +1,77 @@
+"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.ActiveWiredFilter = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const filterVertex_1 = require("./filterVertex");
+class ActiveWiredFilter extends PIXI.Filter {
+    constructor() {
+        super({
+            glProgram: PIXI.GlProgram.from({
+                vertex: filterVertex_1.filterVertex,
+                fragment,
+            }),
+            resources: {
+                wiredUniforms: {
+                    uTintColor: {
+                        value: new Float32Array([0.4, 0.75, 0.95]),
+                        type: "vec3<f32>",
+                    },
+                    uTintStrength: { value: 0.45, type: "f32" },
+                    uAlphaMultiplier: { value: 0.82, type: "f32" },
+                },
+            },
+        });
+    }
+}
+exports.ActiveWiredFilter = ActiveWiredFilter;
+const fragment = `
+in vec2 vTextureCoord;
+out vec4 finalColor;
+
+uniform sampler2D uTexture;
+uniform vec3 uTintColor;
+uniform float uTintStrength;
+uniform float uAlphaMultiplier;
+
+void main(void) {
+    vec4 color = texture(uTexture, vTextureCoord);
+    if (color.a > 0.0) {
+        color.rgb = mix(color.rgb, uTintColor, uTintStrength);
+        color.a *= uAlphaMultiplier;
+    }
+    finalColor = color;
+}
+`;

package/dist/objects/furniture/filter/HighlightFilter.d.ts

@@ -0,0 +1,6 @@
+import * as PIXI from "pixi.js";
+export declare class HighlightFilter extends PIXI.Filter {
+    constructor(backgroundColor: number, borderColor: number, opacity?: number);
+    set opacity(value: number);
+    get opacity(): number;
+}

package/dist/objects/furniture/filter/HighlightFilter.js

@@ -0,0 +1,93 @@
+"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.HighlightFilter = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const filterVertex_1 = require("./filterVertex");
+class HighlightFilter extends PIXI.Filter {
+    constructor(backgroundColor, borderColor, opacity = 0.5) {
+        const bg = new PIXI.Color(backgroundColor).toArray();
+        const border = new PIXI.Color(borderColor).toArray();
+        super({
+            glProgram: PIXI.GlProgram.from({
+                vertex: filterVertex_1.filterVertex,
+                fragment,
+            }),
+            resources: {
+                highlightUniforms: {
+                    uBackgroundColor: {
+                        value: new Float32Array([bg[0], bg[1], bg[2], opacity]),
+                        type: "vec4<f32>",
+                    },
+                    uBorderColor: {
+                        value: new Float32Array([border[0], border[1], border[2], 1.0]),
+                        type: "vec4<f32>",
+                    },
+                },
+            },
+        });
+    }
+    set opacity(value) {
+        this.resources.highlightUniforms.uniforms.uBackgroundColor[3] = value;
+    }
+    get opacity() {
+        return this.resources.highlightUniforms.uniforms.uBackgroundColor[3];
+    }
+}
+exports.HighlightFilter = HighlightFilter;
+const fragment = `
+in vec2 vTextureCoord;
+out vec4 finalColor;
+
+uniform sampler2D uTexture;
+uniform vec4 uBackgroundColor;
+uniform vec4 uBorderColor;
+
+void main(void) {
+    vec4 currentColor = texture(uTexture, vTextureCoord);
+
+    if (currentColor.a > 0.0) {
+        if (currentColor.r == 0.0 && currentColor.g == 0.0 && currentColor.b == 0.0) {
+            finalColor = uBorderColor;
+        } else {
+            vec4 modifiedBackgroundColor = vec4(uBackgroundColor.rgb * uBackgroundColor.a, uBackgroundColor.a);
+            finalColor = mix(currentColor, modifiedBackgroundColor, 0.7);
+            finalColor.a = max(currentColor.a, modifiedBackgroundColor.a);
+        }
+    } else {
+        finalColor = vec4(0.0, 0.0, 0.0, 0.0);
+    }
+}
+`;

package/dist/objects/furniture/filter/filterVertex.d.ts

@@ -0,0 +1 @@
+export declare const filterVertex = "\nin vec2 aPosition;\nout vec2 vTextureCoord;\n\nuniform vec4 uInputSize;\nuniform vec4 uOutputFrame;\nuniform vec4 uOutputTexture;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;\n\n    position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;\n    position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;\n\n    return vec4(position, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aPosition * (uOutputFrame.zw * uInputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";

package/dist/objects/furniture/filter/filterVertex.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterVertex = void 0;
+exports.filterVertex = `
+in vec2 aPosition;
+out vec2 vTextureCoord;
+
+uniform vec4 uInputSize;
+uniform vec4 uOutputFrame;
+uniform vec4 uOutputTexture;
+
+vec4 filterVertexPosition( void )
+{
+    vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;
+
+    position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;
+    position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;
+
+    return vec4(position, 0.0, 1.0);
+}
+
+vec2 filterTextureCoord( void )
+{
+    return aPosition * (uOutputFrame.zw * uInputSize.zw);
+}
+
+void main(void)
+{
+    gl_Position = filterVertexPosition();
+    vTextureCoord = filterTextureCoord();
+}
+`;

package/dist/objects/furniture/util/DrawDefinition.d.ts

@@ -0,0 +1,18 @@
+import { FurnitureAsset } from "../data/interfaces/IFurnitureAssetsData";
+import { FurnitureLayer } from "../data/interfaces/IFurnitureVisualizationData";
+export type BaseFurniDrawPart = {
+    layerIndex: number;
+    z?: number;
+    shadow: boolean;
+    frameRepeat: number;
+    layer: FurnitureLayer | undefined;
+    tint?: string;
+    mask?: boolean;
+    loopCount?: number;
+};
+export type FurniDrawPart = {
+    assets: FurnitureAsset[];
+} & BaseFurniDrawPart;
+export interface FurniDrawDefinition {
+    parts: FurniDrawPart[];
+}

package/dist/objects/furniture/util/DrawDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/util/IFurnitureEventHandlers.d.ts

@@ -0,0 +1,9 @@
+import { IEventManagerEvent } from "../../events/interfaces/IEventManagerEvent";
+export interface IFurnitureEventHandlers {
+    onClick?: (event: IEventManagerEvent) => void;
+    onDoubleClick?: (event: IEventManagerEvent) => void;
+    onPointerDown?: (event: IEventManagerEvent) => void;
+    onPointerUp?: (event: IEventManagerEvent) => void;
+    onPointerOver?: (event: IEventManagerEvent) => void;
+    onPointerOut?: (event: IEventManagerEvent) => void;
+}

package/dist/objects/furniture/util/IFurnitureEventHandlers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/util/getDirectionForFurniture.d.ts

@@ -0,0 +1 @@
+export declare function getDirectionForFurniture(direction: number, validDirections: number[]): number;

package/dist/objects/furniture/util/getDirectionForFurniture.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirectionForFurniture = getDirectionForFurniture;
+function getDirectionForFurniture(direction, validDirections) {
+    if (validDirections.length < 1)
+        return 0;
+    let fallbackDirection = validDirections[0];
+    for (let i = 0; i < validDirections.length; i++) {
+        const validDirection = validDirections[i];
+        if (validDirection === direction)
+            return direction;
+        if (validDirection > direction) {
+            return fallbackDirection;
+        }
+        fallbackDirection = validDirection;
+    }
+    return fallbackDirection;
+}

package/dist/objects/furniture/util/getFurniDrawDefinition.d.ts

@@ -0,0 +1,14 @@
+import { FurniDrawDefinition } from "./DrawDefinition";
+import { IFurnitureVisualizationData } from "../data/interfaces/IFurnitureVisualizationData";
+import { IFurnitureAssetsData } from "../data/interfaces/IFurnitureAssetsData";
+interface FurniDrawDefinitionOptions {
+    type: string;
+    direction: number;
+    animation?: string;
+}
+interface FurniDrawDefinitionDependencies {
+    visualizationData: IFurnitureVisualizationData;
+    assetsData: IFurnitureAssetsData;
+}
+export declare function getFurniDrawDefinition({ type: typeWithColor, direction, animation }: FurniDrawDefinitionOptions, { visualizationData, assetsData }: FurniDrawDefinitionDependencies): FurniDrawDefinition;
+export {};

package/dist/objects/furniture/util/getFurniDrawDefinition.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFurniDrawDefinition = getFurniDrawDefinition;
+const _1 = require(".");
+function getFurniDrawDefinition({ type: typeWithColor, direction, animation }, { visualizationData, assetsData }) {
+    var _a;
+    const typeSplitted = typeWithColor.split("*");
+    const type = typeSplitted[0];
+    // If color is not  set, we fallback to the `0` color for the item.
+    const color = (_a = typeSplitted[1]) !== null && _a !== void 0 ? _a : "0";
+    const size = 64;
+    const parts = [];
+    const animationNumber = animation != null ? Number(animation) : undefined;
+    const layerCount = visualizationData.getLayerCount(size);
+    const getAssetName = (char, frame) => `${type}_${size}_${char}_${direction}_${frame}`;
+    const shadow = assetsData.getAsset(getAssetName("sd", 0));
+    if (shadow != null) {
+        parts.push({
+            assets: [shadow],
+            frameRepeat: 1,
+            shadow: true,
+            layer: undefined,
+            layerIndex: -1,
+        });
+    }
+    const mask = assetsData.getAsset(`${type}_${size}_${direction}_mask`);
+    if (mask != null) {
+        parts.push({
+            assets: [mask],
+            frameRepeat: 1,
+            layer: undefined,
+            shadow: false,
+            mask: true,
+            layerIndex: -2,
+        });
+    }
+    for (let layerIndex = 0; layerIndex < layerCount; layerIndex++) {
+        const directionLayer = visualizationData.getDirectionLayer(size, direction, layerIndex);
+        const layer = visualizationData.getLayer(size, layerIndex);
+        const char = (0, _1.getCharFromLayerIndex)(layerIndex);
+        const animationLayer = animationNumber != null
+            ? visualizationData.getAnimationLayer(size, animationNumber, layerIndex)
+            : undefined;
+        const colorLayer = color != null
+            ? visualizationData.getColor(size, Number(color), layerIndex)
+            : undefined;
+        parts.push(getDrawPart({
+            layer,
+            directionLayer,
+            animation: animationLayer,
+            assetsData: assetsData,
+            color: colorLayer,
+            getAssetName: (frame) => getAssetName(char, frame),
+            layerIndex,
+        }));
+    }
+    return {
+        parts,
+    };
+}
+function getDrawPart({ layerIndex, layer, animation, directionLayer, assetsData, color, getAssetName, }) {
+    var _a, _b, _c, _d, _e;
+    const z = (_b = (_a = directionLayer === null || directionLayer === void 0 ? void 0 : directionLayer.z) !== null && _a !== void 0 ? _a : layer === null || layer === void 0 ? void 0 : layer.z) !== null && _b !== void 0 ? _b : 0;
+    const x = (_c = directionLayer === null || directionLayer === void 0 ? void 0 : directionLayer.x) !== null && _c !== void 0 ? _c : 0;
+    const y = (_d = directionLayer === null || directionLayer === void 0 ? void 0 : directionLayer.y) !== null && _d !== void 0 ? _d : 0;
+    const baseAsset = assetsData.getAsset(getAssetName(0));
+    let assets = undefined;
+    if (animation != null) {
+        const repeat = 1;
+        assets = animation.frames
+            .flatMap((frameNumber) => new Array(repeat).fill(frameNumber))
+            .map((frameNumber) => {
+            var _a;
+            const asset = (_a = assetsData.getAsset(getAssetName(frameNumber))) !== null && _a !== void 0 ? _a : baseAsset;
+            if (asset == null)
+                return { x: 0, y: 0, flipH: false, name: "unknown", valid: true };
+            return {
+                ...asset,
+                x: asset.x + (asset.flipH ? x : -x),
+                y: asset.y - y,
+            };
+        });
+    }
+    if ((assets == null || assets.length === 0) && baseAsset != null) {
+        assets = [baseAsset];
+    }
+    if (assets == null) {
+        assets = [];
+    }
+    return {
+        mask: false,
+        shadow: false,
+        frameRepeat: (_e = animation === null || animation === void 0 ? void 0 : animation.frameRepeat) !== null && _e !== void 0 ? _e : 1,
+        layer,
+        z,
+        tint: color,
+        assets,
+        loopCount: animation === null || animation === void 0 ? void 0 : animation.loopCount,
+        layerIndex,
+    };
+}

package/dist/objects/furniture/util/getFurnitureFetch.d.ts

@@ -0,0 +1,3 @@
+import { FurnitureFetch } from "../../../interfaces/IFurnitureLoader";
+import { FurnitureFetchInfo } from "../FurnitureFetchInfo";
+export declare function getFurnitureFetch(data: FurnitureFetchInfo, placementType: "wall" | "floor"): FurnitureFetch;

package/dist/objects/furniture/util/getFurnitureFetch.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFurnitureFetch = getFurnitureFetch;
+function getFurnitureFetch(data, placementType) {
+    if (data.id != null && data.type != null)
+        throw new Error("Both `id` and `type` specified. Please supply only one of the two.");
+    if (data.id != null) {
+        return { kind: "id", id: data.id, placementType };
+    }
+    if (data.type != null) {
+        return { kind: "type", type: data.type };
+    }
+    throw new Error("No `id` or `type` provided for the furniture.");
+}

package/dist/objects/furniture/util/index.d.ts

@@ -0,0 +1,4 @@
+export type { FurniDrawPart as DrawPart, } from "./DrawDefinition";
+export type { FurniDrawDefinition as DrawDefinition } from "./DrawDefinition";
+export * from "./visualization/parseVisualization";
+export declare function getCharFromLayerIndex(index: number): string;

package/dist/objects/furniture/util/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCharFromLayerIndex = getCharFromLayerIndex;
+__exportStar(require("./visualization/parseVisualization"), exports);
+function getCharFromLayerIndex(index) {
+    return String.fromCharCode(97 + index);
+}

package/dist/objects/furniture/util/loadFurni.d.ts

@@ -0,0 +1,20 @@
+import { HitTexture } from "../../hitdetection/HitTexture";
+import { FurnitureLogic } from "../data/interfaces/IFurnitureLogicData";
+import { IFurnitureVisualizationData } from "../data/interfaces/IFurnitureVisualizationData";
+import { FurnitureExtraData } from "../FurnitureExtraData";
+import { IFurnitureAssetBundle } from "../IFurnitureAssetBundle";
+import { FurniDrawDefinition } from "./DrawDefinition";
+export type GetFurniDrawDefinition = (direction: number, animation?: string) => FurniDrawDefinition;
+export type Hitmap = (x: number, y: number, transform: {
+    x: number;
+    y: number;
+}) => boolean;
+export type LoadFurniResult = {
+    getDrawDefinition: GetFurniDrawDefinition;
+    getTexture: (name: string) => HitTexture | undefined;
+    getExtraData: () => FurnitureExtraData;
+    logicData: FurnitureLogic | undefined;
+    directions: number[];
+    visualizationData: IFurnitureVisualizationData;
+};
+export declare function loadFurni(typeWithColor: string, bundle: IFurnitureAssetBundle): Promise<LoadFurniResult>;

package/dist/objects/furniture/util/loadFurni.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFurni = loadFurni;
+const notNullOrUndefined_1 = require("../../../util/notNullOrUndefined");
+const getFurniDrawDefinition_1 = require("./getFurniDrawDefinition");
+async function loadFurni(typeWithColor, bundle) {
+    const assetsData = await bundle.getAssets();
+    const indexData = await bundle.getIndex();
+    const visualizationData = await bundle.getVisualization();
+    const logicData = await bundle.getLogic();
+    const validDirections = visualizationData.getDirections(64);
+    const sortedDirections = [...validDirections].sort((a, b) => a - b);
+    const assetMap = assetsData.getAssets();
+    const loadTextures = async () => {
+        const assetsToLoad = Array.from(assetMap).filter((asset) => asset.source == null || asset.source === asset.name);
+        const loadedTextures = await Promise.all(assetsToLoad.map(async (asset) => {
+            try {
+                const image = await bundle.getTexture(asset.name);
+                return [asset.name, image];
+            }
+            catch (e) {
+                console.warn(`Failed to load furniture asset: ${asset.name}`, e);
+                return null;
+            }
+        }));
+        return new Map(loadedTextures.filter(notNullOrUndefined_1.notNullOrUndefined));
+    };
+    const textures = await loadTextures();
+    return {
+        getDrawDefinition: (direction, animation) => (0, getFurniDrawDefinition_1.getFurniDrawDefinition)({
+            type: typeWithColor,
+            direction,
+            animation,
+        }, {
+            assetsData,
+            visualizationData,
+        }),
+        getTexture: (name) => {
+            const texture = textures.get(name);
+            return texture;
+        },
+        getExtraData: () => {
+            return indexData;
+        },
+        logicData: logicData.getLogic(),
+        visualizationData,
+        directions: sortedDirections,
+    };
+}

package/dist/objects/furniture/util/visualization/VisualizationXml.d.ts

@@ -0,0 +1,73 @@
+export type VisualizationXml = {
+    visualizationData: {
+        graphics: {
+            visualization: VisualizationXmlVisualization[];
+        }[];
+    };
+};
+export type VisualizationXmlVisualization = {
+    $: {
+        size: string;
+        layerCount: string;
+    };
+    layers: {
+        layer: {
+            $: {
+                id: string;
+                z: string | undefined;
+                ink: string | undefined;
+                tag: string | undefined;
+                ignoreMouse: string | undefined;
+                alpha: string | undefined;
+            };
+        }[];
+    }[] | undefined;
+    directions: {
+        direction: {
+            $: {
+                id: string;
+            };
+            layer: {
+                $: {
+                    id: string;
+                    z: string | undefined;
+                    ink: string | undefined;
+                    tag: string | undefined;
+                };
+            }[] | undefined;
+        }[];
+    }[];
+    colors: {
+        color: {
+            $: {
+                id: string;
+            };
+            colorLayer: {
+                $: {
+                    id: string;
+                    color: string;
+                };
+            }[];
+        }[];
+    }[] | undefined;
+    animations: {
+        animation: {
+            $: {
+                id: string;
+            };
+            animationLayer: {
+                $: {
+                    id: string;
+                    frameRepeat: string | undefined;
+                };
+                frameSequence: {
+                    frame: {
+                        $: {
+                            id: string;
+                        };
+                    }[];
+                }[];
+            }[];
+        }[];
+    }[] | undefined;
+};

package/dist/objects/furniture/util/visualization/VisualizationXml.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/furniture/util/visualization/parseAnimations.d.ts

@@ -0,0 +1,10 @@
+import { VisualizationXmlVisualization } from "./VisualizationXml";
+export declare function parseAnimations(visualization: VisualizationXmlVisualization, set: (id: string, animation: AnimationData) => void): void;
+export type FramesData = {
+    frames: string[];
+    frameRepeat?: number;
+};
+export type AnimationData = {
+    frameCount: number;
+    layerToFrames: Map<string, FramesData>;
+};