🆙 the latest updates to Renderer

packages/api/src/asset/IAssetManager.ts

@@ -12,6 +12,7 @@ export interface IAssetManager
     getAsset(name: string): IGraphicAsset;
     getCollection(name: string): IGraphicAssetCollection;
     createCollection(data: IAssetData, spritesheet: Spritesheet): IGraphicAssetCollection;
+    loadTextureFromUrl(url: string, name?: string): Promise<Texture>
     downloadAssets(urls: string[]): Promise<boolean>;
     downloadAsset(url: string): Promise<boolean>;
     readonly collections: Map<string, IGraphicAssetCollection>;

packages/api/src/nitro/room/IRoomEngine.ts

@@ -14,7 +14,7 @@ export interface IRoomEngine
     setActiveRoomId(roomId: number): void;
     createRoomInstance(roomId: number, roomMap: IRoomMapData): void;
     getRoomInstanceDisplay(roomId: number, id: number, width: number, height: number, scale: number): Container;
-    setRoomInstanceRenderingCanvasScale(roomId: number, canvasId: number, scale: number, point?: Point, offsetPoint?: Point, override?: boolean, asDelta?: boolean): void;
+    setRoomInstanceRenderingCanvasScale(roomId: number, canvasId: number, level: number, point?: Point, offsetPoint?: Point, isFlipForced?: boolean): void;
     setRoomInstanceRenderingCanvasMask(roomId: number, canvasId: number, flag: boolean): void;
     getRoomInstanceRenderingCanvas(roomId: number, canvasId?: number): IRoomRenderingCanvas;
     getRoomInstanceRenderingCanvasOffset(roomId: number, canvasId?: number): Point;

packages/api/src/room/renderer/IRoomRenderingCanvas.ts

@@ -9,7 +9,7 @@ export interface IRoomRenderingCanvas
     dispose(): void;
     initialize(width: number, height: number): void;
     setMask(flag: boolean): void;
-    setScale(scale: number, point?: Point, offsetPoint?: Point, override?: boolean, asDelta?: boolean): void;
+    setScale(scale: number, point?: Point, offsetPoint?: Point, isFlipForced?: boolean): void;
     render(time: number, update?: boolean): void;
     update(): void;
     setMouseListener(listener: IRoomCanvasMouseListener): void;

packages/assets/src/AssetManager.ts

@@ -74,6 +74,33 @@ export class AssetManager implements IAssetManager
         return collection;
     }
 
+    public async loadTextureFromUrl(url: string, name: string = null): Promise<Texture>
+    {
+        if(!url || !url.length) return null;
+
+        let texture = this.getTexture(name);
+
+        if(!texture) texture = this.getTexture(url);
+
+        if(texture) return texture;
+
+        try
+        {
+            texture = await Assets.load<Texture>(url);
+
+            if(!texture) return null;
+
+            this.setTexture(name ?? url, texture);
+
+            return texture;
+        }
+
+        catch (err)
+        {
+            NitroLogger.error(err);
+        }
+    }
+
     public async downloadAssets(urls: string[]): Promise<boolean>
     {
         if(!urls || !urls.length) return Promise.resolve(true);

packages/avatar/src/AvatarImage.ts

@@ -221,7 +221,8 @@ export class AvatarImage implements IAvatarImage, IAvatarEffectListener
                     point.x += avatarCanvas.regPoint.x;
                     point.y += avatarCanvas.regPoint.y;
 
-                    partContainer.position.set(point.x, point.y);
+                    partContainer.x = Math.floor(point.x);
+                    partContainer.y = Math.floor(point.y);
 
                     container.addChild(partContainer);
                 }
@@ -271,8 +272,6 @@ export class AvatarImage implements IAvatarImage, IAvatarEffectListener
 
         if(!avatarCanvas) return null;
 
-        const container = this.buildAvatarContainer(avatarCanvas, setType);
-
         if(this._activeTexture && ((this._activeTexture.width !== avatarCanvas.width) || (this._activeTexture.height !== avatarCanvas.height)))
         {
             GetTexturePool().putTexture(this._activeTexture);
@@ -284,6 +283,8 @@ export class AvatarImage implements IAvatarImage, IAvatarEffectListener
 
         if(!this._activeTexture) return null;
 
+        const container = this.buildAvatarContainer(avatarCanvas, setType);
+
         GetRenderer().render({
             target: this._activeTexture,
             container: container,
@@ -323,6 +324,7 @@ export class AvatarImage implements IAvatarImage, IAvatarEffectListener
         return this.buildAvatarContainer(avatarCanvas, setType);
     }
 
+    // TODO this needs to be added still
     public applyPalette(texture: RenderTexture, reds: number[] = [], greens: number[] = [], blues: number[] = []): RenderTexture
     {
         const textureCanvas = TextureUtils.generateCanvas(texture);

packages/events/src/room/RoomZoomEvent.ts

@@ -5,16 +5,14 @@ export class RoomZoomEvent extends RoomEngineEvent
     public static ROOM_ZOOM: string = 'REE_ROOM_ZOOM';
 
     private _level: number;
-    private _forceFlip: boolean;
+    private _isFlipForced: boolean;
-    private _asDelta: boolean;
 
-    constructor(roomId: number, level: number, forceFlip: boolean = false, asDelta: boolean = false)
+    constructor(roomId: number, level: number, isFlipForced: boolean = false)
     {
         super(RoomZoomEvent.ROOM_ZOOM, roomId);
 
         this._level = level;
-        this._forceFlip = forceFlip;
+        this._isFlipForced = isFlipForced;
-        this._asDelta = asDelta;
     }
 
     public get level(): number
@@ -22,13 +20,8 @@ export class RoomZoomEvent extends RoomEngineEvent
         return this._level;
     }
 
-    public get forceFlip(): boolean
+    public get isFlipForced(): boolean
     {
-        return this._forceFlip;
+        return this._isFlipForced;
-    }
-
-    public get asDelta(): boolean
-    {
-        return this._asDelta;
     }
 }

packages/room/src/RoomEngine.ts

@@ -356,17 +356,20 @@ export class RoomEngine implements IRoomEngine, IRoomCreator, IRoomEngineService
         if(roomCanvas) roomCanvas.setMask(flag);
     }
 
-    public setRoomInstanceRenderingCanvasScale(roomId: number, canvasId: number, scale: number, point: Point = null, offsetPoint: Point = null, override: boolean = false, asDelta: boolean = false): void
+    public setRoomInstanceRenderingCanvasScale(roomId: number, canvasId: number, level: number, point: Point = null, offsetPoint: Point = null, isFlipForced: boolean = false, flag: boolean = false): void
     {
+        if(!GetConfiguration().getValue('room.zoom.enabled', true)) return;
+
+        if(!flag) level = ((isFlipForced) ? -1 : ((level) < 1) ? 0.5 : Math.floor(level));
+
         const roomCanvas = this.getRoomInstanceRenderingCanvas(roomId, canvasId);
 
-        if(roomCanvas)
+        if(!roomCanvas) return;
-        {
+
-            roomCanvas.setScale(scale, point, offsetPoint, override, asDelta);
+        roomCanvas.setScale(level, point, offsetPoint, isFlipForced);
 
         GetEventDispatcher().dispatchEvent(new RoomEngineEvent(RoomEngineEvent.ROOM_ZOOMED, roomId));
     }
-    }
 
     public getRoomInstanceRenderingCanvas(roomId: number, canvasId: number = -1): IRoomRenderingCanvas
     {

packages/room/src/object/visualization/furniture/FurnitureGuildIsometricBadgeVisualization.ts

@@ -73,7 +73,8 @@ export class FurnitureGuildIsometricBadgeVisualization extends IsometricImageFur
 
         sprite.setFromMatrix(matrix);
 
-        sprite.position.set(0);
+        sprite.x = 0;
+        sprite.y = 0;
 
         return TextureUtils.generateTexture(sprite);
 

packages/room/src/object/visualization/furniture/FurnitureVisualizationData.ts

@@ -1,5 +1,6 @@
 import { IAssetData, IAssetVisualizationData, IObjectVisualizationData } from '@nitrots/api';
 import { BLEND_MODES } from 'pixi.js';
+import { RoomGeometry } from '../../../utils';
 import { ColorData, LayerData, SizeData } from '../data';
 
 export class FurnitureVisualizationData implements IObjectVisualizationData
@@ -105,11 +106,33 @@ export class FurnitureVisualizationData implements IObjectVisualizationData
             this._sizes.push(size);
         }
 
+        this.removeInvalidSizes();
+
         this._sizes.sort();
 
         return true;
     }
 
+    private removeInvalidSizes(): void
+    {
+        if(!this._sizes || !this._sizes.length) return;
+
+        const zoomedIn = this._sizeDatas.get(RoomGeometry.SCALE_ZOOMED_IN);
+        const zoomedOut = this._sizeDatas.get(RoomGeometry.SCALE_ZOOMED_OUT);
+
+        if(zoomedIn && zoomedOut)
+        {
+            if(zoomedIn.layerCount !== zoomedOut.layerCount)
+            {
+                this._sizeDatas.delete(RoomGeometry.SCALE_ZOOMED_OUT);
+
+                const index = this._sizes.indexOf(RoomGeometry.SCALE_ZOOMED_OUT);
+
+                if(index >= 0) this._sizes.splice(index, 1);
+            }
+        }
+    }
+
     protected processVisualElement(sizeData: SizeData, key: string, data: any): boolean
     {
         if(!sizeData || !key || !data) return false;

packages/room/src/object/visualization/furniture/IsometricImageFurniVisualization.ts

@@ -105,7 +105,8 @@ export class IsometricImageFurniVisualization extends FurnitureAnimatedVisualiza
             const offsetX = ((background.width - sprite.width) / 2);
             const offsetY = ((background.height - sprite.height) / 2);
 
-            sprite.position.set(offsetX, offsetY);
+            sprite.x = Math.floor(offsetX);
+            sprite.y = Math.floor(offsetY);
 
             container.addChild(background, sprite);
 

packages/room/src/object/visualization/room/RoomPlane.ts

@@ -12,7 +12,10 @@ export class RoomPlane implements IRoomPlane
 {
     public static HORIZONTAL_ANGLE_DEFAULT: number = 45;
     public static VERTICAL_ANGLE_DEFAULT: number = 30;
-    public static PLANE_GEOMETRY: IRoomGeometry = new RoomGeometry(64, new Vector3d(RoomPlane.HORIZONTAL_ANGLE_DEFAULT, RoomPlane.VERTICAL_ANGLE_DEFAULT), new Vector3d(-10, 0, 0));
+    public static PLANE_GEOMETRY: { [index: number]: IRoomGeometry } = {
+        '32': new RoomGeometry(32, new Vector3d(RoomPlane.HORIZONTAL_ANGLE_DEFAULT, RoomPlane.VERTICAL_ANGLE_DEFAULT), new Vector3d(-10, 0, 0)),
+        '64': new RoomGeometry(64, new Vector3d(RoomPlane.HORIZONTAL_ANGLE_DEFAULT, RoomPlane.VERTICAL_ANGLE_DEFAULT), new Vector3d(-10, 0, 0))
+    };
     private static LANDSCAPE_COLOR: number = 0x0082F0;
 
     public static TYPE_UNDEFINED: number = 0;
@@ -195,6 +198,7 @@ export class RoomPlane implements IRoomPlane
 
             Randomizer.setSeed(this._randomSeed);
 
+            const planeGeometry = RoomPlane.PLANE_GEOMETRY[geometry.scale];
             let width = (this._leftSide.length * geometry.scale);
             let height = (this._rightSide.length * geometry.scale);
             const normal = geometry.getCoordinatePosition(this._normal);
@@ -206,7 +210,7 @@ export class RoomPlane implements IRoomPlane
                 const roomCollection = GetAssetManager().getCollection('room');
                 const planeVisualizationData = roomCollection?.data?.roomVisualization?.[dataType];
                 const plane = planeVisualizationData?.planes?.find(plane => (plane.id === planeId));
-                const planeVisualization = (dataType === 'landscapeData') ? plane?.animatedVisualization?.[0] : plane?.visualizations?.[0];
+                const planeVisualization = ((dataType === 'landscapeData') ? plane?.animatedVisualization : plane?.visualizations)?.find(visualization => (visualization.size === planeGeometry.scale)) ?? null;
                 const planeLayer = planeVisualization?.allLayers?.[0] as IAssetPlaneVisualizationLayer;
                 const planeMaterialId = planeLayer?.materialId;
                 const planeColor = planeLayer?.color;
@@ -222,9 +226,9 @@ export class RoomPlane implements IRoomPlane
             switch(this._type)
             {
                 case RoomPlane.TYPE_FLOOR: {
-                    const _local_10 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, 0));
+                    const _local_10 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 0));
-                    const _local_11 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, (height / RoomPlane.PLANE_GEOMETRY.scale), 0));
+                    const _local_11 = planeGeometry.getScreenPoint(new Vector3d(0, (height / planeGeometry.scale), 0));
-                    const _local_12 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d((width / RoomPlane.PLANE_GEOMETRY.scale), 0, 0));
+                    const _local_12 = planeGeometry.getScreenPoint(new Vector3d((width / planeGeometry.scale), 0, 0));
 
                     let x = 0;
                     let y = 0;
@@ -234,7 +238,7 @@ export class RoomPlane implements IRoomPlane
                         width = Math.round(Math.abs((_local_10.x - _local_12.x)));
                         height = Math.round(Math.abs((_local_10.x - _local_11.x)));
 
-                        const _local_15 = (_local_10.x - RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(1, 0, 0)).x);
+                        const _local_15 = (_local_10.x - planeGeometry.getScreenPoint(new Vector3d(1, 0, 0)).x);
 
                         x = (this._textureOffsetX * Math.trunc(Math.abs(_local_15)));
                         y = (this._textureOffsetY * Math.trunc(Math.abs(_local_15)));
@@ -261,9 +265,9 @@ export class RoomPlane implements IRoomPlane
                     break;
                 }
                 case RoomPlane.TYPE_WALL: {
-                    const _local_8 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, 0));
+                    const _local_8 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 0));
-                    const _local_9 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, (height / RoomPlane.PLANE_GEOMETRY.scale)));
+                    const _local_9 = planeGeometry.getScreenPoint(new Vector3d(0, 0, (height / planeGeometry.scale)));
-                    const _local_10 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, (width / RoomPlane.PLANE_GEOMETRY.scale), 0));
+                    const _local_10 = planeGeometry.getScreenPoint(new Vector3d(0, (width / planeGeometry.scale), 0));
 
                     if(_local_8 && _local_9 && _local_10)
                     {
@@ -285,19 +289,18 @@ export class RoomPlane implements IRoomPlane
                     break;
                 }
                 case RoomPlane.TYPE_LANDSCAPE: {
-                    const _local_13 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, 0));
+                    const _local_13 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 0));
-                    const _local_14 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, 1));
+                    const _local_14 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 1));
-                    const _local_15 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 1, 0));
+                    const _local_15 = planeGeometry.getScreenPoint(new Vector3d(0, 1, 0));
 
                     if(_local_13 && _local_14 && _local_15)
                     {
-                        width = Math.round(Math.abs((((_local_13.x - _local_15.x) * width) / RoomPlane.PLANE_GEOMETRY.scale)));
+                        width = Math.round(Math.abs((((_local_13.x - _local_15.x) * width) / planeGeometry.scale)));
-                        height = Math.round(Math.abs((((_local_13.y - _local_14.y) * height) / RoomPlane.PLANE_GEOMETRY.scale)));
+                        height = Math.round(Math.abs((((_local_13.y - _local_14.y) * height) / planeGeometry.scale)));
                     }
 
                     const renderMaxX = Math.trunc(this._textureMaxX * Math.abs((_local_13.x - _local_15.x)));
                     const renderMaxY = Math.trunc(this._textureMaxY * Math.abs((_local_13.y - _local_14.y)));
-
                     const renderOffsetX = Math.trunc(this._textureOffsetX * Math.abs((_local_13.x - _local_15.x)));
                     const renderOffsetY = Math.trunc(this._textureOffsetY * Math.abs((_local_13.y - _local_14.y)));
 

packages/room/src/renderer/RoomSpriteCanvas.ts

@@ -234,7 +234,7 @@ export class RoomSpriteCanvas implements IRoomRenderingCanvas
         }
     }
 
-    public setScale(scale: number, point: Point = null, offsetPoint: Point = null): void
+    public setScale(scale: number, point: Point = null, offsetPoint: Point = null, isFlipForced: boolean = false): void
     {
         if(!this._master || !this._display) return;
 
@@ -266,7 +266,8 @@ export class RoomSpriteCanvas implements IRoomRenderingCanvas
 
         if((this._display.x !== this._screenOffsetX) || (this._display.y !== this._screenOffsetY))
         {
-            this._display.position.set(this._screenOffsetX, this._screenOffsetY);
+            this._display.x = Math.floor(this._screenOffsetX);
+            this._display.y = Math.floor(this._screenOffsetY);
 
             update = true;
         }
@@ -562,8 +563,8 @@ export class RoomSpriteCanvas implements IRoomRenderingCanvas
             this.updateEnterRoomEffect(extendedSprite, objectSprite);
         }
 
-        if(extendedSprite.x !== sprite.x) extendedSprite.x = sprite.x;
+        extendedSprite.x = Math.round(sprite.x);
-        if(extendedSprite.y !== sprite.y) extendedSprite.y = sprite.y;
+        extendedSprite.y = Math.round(sprite.y);
 
         extendedSprite.offsetX = objectSprite.offsetX;
         extendedSprite.offsetY = objectSprite.offsetY;