@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/objects/furniture/data/JsonFurnitureVisualizationData.js

@@ -0,0 +1,91 @@
+export class JsonFurnitureVisualizationData {
+    constructor(_furniture) {
+        this._furniture = _furniture;
+    }
+    getLayerCount(size) {
+        return this._getVisualization(size).layerCount;
+    }
+    getLayer(size, layerId) {
+        return this._getVisualization(size).layers[layerId.toString()];
+    }
+    getDirections(size) {
+        return Object.keys(this._getVisualization(size).directions).map((direction) => Number(direction));
+    }
+    getAnimationIds(size) {
+        var _a;
+        return Object.keys((_a = this._getVisualization(size).animations) !== null && _a !== void 0 ? _a : {})
+            .map((id) => Number(id))
+            .filter((id) => !Number.isNaN(id))
+            .sort((a, b) => a - b);
+    }
+    getDirectionLayer(size, direction, layerId) {
+        var _a;
+        return (_a = this._getVisualization(size).directions[direction.toString()]) === null || _a === void 0 ? void 0 : _a.layers[layerId.toString()];
+    }
+    getAnimationLayer(size, animationId, id) {
+        var _a;
+        return (_a = this._getVisualization(size).animations[animationId.toString()]) === null || _a === void 0 ? void 0 : _a.layers[id.toString()];
+    }
+    getFrameCountWithoutRepeat(size, animationId) {
+        var _a;
+        let count = 1;
+        Object.values((_a = this._getVisualization(size).animations[animationId.toString()]) !== null && _a !== void 0 ? _a : {}).forEach((layers) => {
+            Object.values(layers !== null && layers !== void 0 ? layers : {}).forEach((layer) => {
+                var _a;
+                const frameCount = (_a = layer === null || layer === void 0 ? void 0 : layer.frames.length) !== null && _a !== void 0 ? _a : 0;
+                const value = frameCount;
+                if (value > count) {
+                    count = value;
+                }
+            });
+        });
+        return count;
+    }
+    getFrameCount(size, animationId) {
+        var _a;
+        let count = 1;
+        Object.values((_a = this._getVisualization(size).animations[animationId.toString()]) !== null && _a !== void 0 ? _a : {}).forEach((layers) => {
+            Object.values(layers !== null && layers !== void 0 ? layers : {}).forEach((layer) => {
+                var _a, _b;
+                const frameCount = (_a = layer === null || layer === void 0 ? void 0 : layer.frames.length) !== null && _a !== void 0 ? _a : 0;
+                const multiplier = (_b = layer === null || layer === void 0 ? void 0 : layer.frameRepeat) !== null && _b !== void 0 ? _b : 1;
+                const value = frameCount * multiplier;
+                if (value > count) {
+                    count = value;
+                }
+            });
+        });
+        return count;
+    }
+    getColor(size, colorId, layerId) {
+        var _a, _b;
+        return (_b = (_a = this._getVisualization(size).colors[colorId.toString()]) === null || _a === void 0 ? void 0 : _a.layers[layerId.toString()]) === null || _b === void 0 ? void 0 : _b.color;
+    }
+    getAnimation(size, animationId) {
+        const animation = this._getVisualization(size).animations[animationId.toString()];
+        if (animation != null) {
+            return {
+                transitionTo: animation.transitionTo,
+                id: animationId,
+            };
+        }
+    }
+    getTransitionForAnimation(size, transitionTo) {
+        const animations = Object.entries(this._getVisualization(size).animations);
+        const animationTransitionTo = animations.find(([id, animation]) => (animation === null || animation === void 0 ? void 0 : animation.transitionTo) === transitionTo);
+        if (animationTransitionTo != null) {
+            const animationId = Number(animationTransitionTo[0]);
+            return {
+                id: animationId,
+                transitionTo,
+            };
+        }
+    }
+    _getVisualization(size) {
+        const visualization = this._furniture[size.toString()];
+        if (visualization == null) {
+            throw new Error("Invalid visualization");
+        }
+        return visualization;
+    }
+}

package/dist-esm/objects/furniture/data/interfaces/IFurnitureAssetsData.js

@@ -0,0 +1 @@
+export {};

package/dist-esm/objects/furniture/data/interfaces/IFurnitureIndexData.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,40 @@
+import * as PIXI from "pixi.js";
+import { filterVertex } from "./filterVertex";
+export class ActiveWiredFilter extends PIXI.Filter {
+    constructor() {
+        super({
+            glProgram: PIXI.GlProgram.from({
+                vertex: 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" },
+                },
+            },
+        });
+    }
+}
+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-esm/objects/furniture/filter/HighlightFilter.js

@@ -0,0 +1,56 @@
+import * as PIXI from "pixi.js";
+import { filterVertex } from "./filterVertex";
+export 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,
+                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];
+    }
+}
+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-esm/objects/furniture/filter/filterVertex.js

@@ -0,0 +1,29 @@
+export const 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-esm/objects/furniture/util/DrawDefinition.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+export 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-esm/objects/furniture/util/getFurniDrawDefinition.js

@@ -0,0 +1,98 @@
+import { getCharFromLayerIndex } from ".";
+export 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 = 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-esm/objects/furniture/util/getFurnitureFetch.js

@@ -0,0 +1,11 @@
+export 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-esm/objects/furniture/util/index.js

@@ -0,0 +1,4 @@
+export * from "./visualization/parseVisualization";
+export function getCharFromLayerIndex(index) {
+    return String.fromCharCode(97 + index);
+}

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

@@ -0,0 +1,46 @@
+import { notNullOrUndefined } from "../../../util/notNullOrUndefined";
+import { getFurniDrawDefinition } from "./getFurniDrawDefinition";
+export 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));
+    };
+    const textures = await loadTextures();
+    return {
+        getDrawDefinition: (direction, animation) => 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-esm/objects/furniture/util/visualization/VisualizationXml.js

@@ -0,0 +1 @@
+export {};

package/dist-esm/objects/furniture/util/visualization/parseAnimations.js

@@ -0,0 +1,32 @@
+export function parseAnimations(visualization, set) {
+    const animations = visualization.animations
+        ? visualization.animations[0].animation
+        : undefined;
+    if (animations != null) {
+        animations.forEach((animation) => {
+            const animationId = animation["$"].id;
+            const animationLayers = animation.animationLayer;
+            const layerToFrames = new Map();
+            let frameCount = 1;
+            animationLayers.forEach((layer) => {
+                const layerId = layer["$"].id;
+                if (layer.frameSequence != null) {
+                    const frameSequenceFrames = layer.frameSequence[0].frame;
+                    const frames = frameSequenceFrames.map((frame) => frame["$"].id);
+                    const frameRepeatString = layer["$"].frameRepeat;
+                    layerToFrames.set(layerId, {
+                        frames,
+                        frameRepeat: frameRepeatString != null ? Number(frameRepeatString) : undefined,
+                    });
+                    if (frames.length > frameCount) {
+                        frameCount = frames.length;
+                    }
+                }
+            });
+            set(animationId, {
+                frameCount: frameCount,
+                layerToFrames,
+            });
+        });
+    }
+}

package/dist-esm/objects/furniture/util/visualization/parseColors.js

@@ -0,0 +1,16 @@
+export function parseColors(visualization, set) {
+    const colors = visualization.colors && visualization.colors[0].color;
+    if (colors != null) {
+        colors.forEach(color => {
+            const id = color["$"].id;
+            const colorLayersMap = new Map();
+            const colorLayers = color.colorLayer;
+            colorLayers.forEach(layer => {
+                const layerId = layer["$"].id;
+                const color = layer["$"].color;
+                colorLayersMap.set(layerId, color);
+            });
+            set(id, colorLayersMap);
+        });
+    }
+}

package/dist-esm/objects/furniture/util/visualization/parseDirections.js

@@ -0,0 +1,24 @@
+export function parseDirections(visualization, set) {
+    const directions = visualization.directions[0].direction;
+    const validDirections = [];
+    for (let i = 0; i < directions.length; i++) {
+        const layerMap = new Map();
+        const directionNumber = Number(directions[i]["$"].id);
+        const directionLayers = directions[i].layer || [];
+        validDirections.push(directionNumber);
+        for (let j = 0; j < directionLayers.length; j++) {
+            const layer = directionLayers[j]["$"];
+            layerMap.set(layer.id, {
+                zIndex: layer != null && layer.z != null ? Number(layer.z) : undefined,
+                tag: undefined,
+                ink: undefined,
+                alpha: undefined,
+                ignoreMouse: undefined,
+            });
+        }
+        set(directionNumber, layerMap);
+    }
+    return {
+        validDirections,
+    };
+}

package/dist-esm/objects/furniture/util/visualization/parseLayers.js

@@ -0,0 +1,16 @@
+export function parseLayers(visualization, set) {
+    if (visualization.layers != null) {
+        const layers = visualization.layers[0].layer;
+        const layersLength = layers == null ? 0 : layers.length;
+        for (let i = 0; i < layersLength; i++) {
+            const layer = layers[i]["$"];
+            set(layer.id, {
+                zIndex: layer != null && layer.z != null ? Number(layer.z) : 0,
+                tag: layer.tag,
+                ink: layer.ink,
+                alpha: layer.alpha != null ? Number(layer.alpha) : undefined,
+                ignoreMouse: layer.ignoreMouse,
+            });
+        }
+    }
+}

package/dist-esm/objects/furniture/util/visualization/parseVisualization.js

@@ -0,0 +1,41 @@
+import { parseAnimations } from "./parseAnimations";
+import { parseColors } from "./parseColors";
+import { parseDirections } from "./parseDirections";
+import { parseLayers } from "./parseLayers";
+export function parseVisualization(xml) {
+    const visualizations = xml["visualizationData"]["graphics"][0]["visualization"];
+    let parsedValidDirections = [];
+    for (let i = 0; i < visualizations.length; i++) {
+        const visualization = visualizations[i];
+        if (visualization["$"]["size"] == "64") {
+            const layerMap = new Map();
+            const colorMap = new Map();
+            const animationMap = new Map();
+            const directionMap = new Map();
+            const { validDirections } = parseDirections(visualization, (direction, layerMap) => directionMap.set(direction, layerMap));
+            parsedValidDirections = validDirections;
+            parseAnimations(visualization, (id, data) => animationMap.set(id, data));
+            parseColors(visualization, (id, colorLayersMap) => colorMap.set(id, colorLayersMap));
+            parseLayers(visualization, (id, layer) => layerMap.set(id, layer));
+            return {
+                layerCount: Number(visualization["$"]["layerCount"]),
+                getColor: (colorId, layer) => { var _a; return (_a = colorMap === null || colorMap === void 0 ? void 0 : colorMap.get(colorId)) === null || _a === void 0 ? void 0 : _a.get(layer); },
+                getAnimation: (animationId, layerId) => {
+                    var _a, _b;
+                    const frameInfo = (_b = (_a = animationMap
+                        .get(animationId)) === null || _a === void 0 ? void 0 : _a.layerToFrames) === null || _b === void 0 ? void 0 : _b.get(layerId);
+                    return frameInfo;
+                },
+                getFrameCount: (animationId) => { var _a; return (_a = animationMap.get(animationId)) === null || _a === void 0 ? void 0 : _a.frameCount; },
+                getLayer: (layerId) => layerMap.get(layerId),
+                getDirectionLayerOverride: (direction, layerId) => { var _a; return (_a = directionMap.get(direction)) === null || _a === void 0 ? void 0 : _a.get(layerId); },
+                getAnimationDatas: () => Array.from(animationMap).map(([animationId, data]) => ({
+                    id: animationId,
+                    data,
+                })),
+                directions: parsedValidDirections,
+            };
+        }
+    }
+    throw new Error("No visualization found");
+}