duckietm/Nitro-Cool-UI-Renderer
1
0
Fork 0
mirror of https://github.com/duckietm/Nitro-Cool-UI-Renderer.git synced 2025-06-21 15:06:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

🆙 the latest updates to Renderer

Browse Source
This commit is contained in:
duckietm 2024-07-15 10:23:54 +02:00
parent bd09ea8b25
commit 1e4f45a107
12 changed files with 100 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
packages/api/src/asset/IAssetManager.ts
View File

@ -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>;

2
packages/api/src/nitro/room/IRoomEngine.ts
View File

@ -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;

2
packages/api/src/room/renderer/IRoomRenderingCanvas.ts
View File

@ -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;

27
packages/assets/src/AssetManager.ts
View File

@ -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);

8
packages/avatar/src/AvatarImage.ts
View File

@ -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);

17
packages/events/src/room/RoomZoomEvent.ts
View File

@ -5,16 +5,14 @@ export class RoomZoomEvent extends RoomEngineEvent
public static ROOM_ZOOM: string = 'REE_ROOM_ZOOM';
private _level: number;
private _forceFlip: boolean;
private _asDelta: boolean;
private _isFlipForced: 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._asDelta = asDelta;
this._isFlipForced = isFlipForced;
}
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;
}
public get asDelta(): boolean
{
return this._asDelta;
return this._isFlipForced;
}
}

15
packages/room/src/RoomEngine.ts
View File

@ -356,16 +356,19 @@ 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)
{
roomCanvas.setScale(scale, point, offsetPoint, override, asDelta);
if(!roomCanvas) return;
GetEventDispatcher().dispatchEvent(new RoomEngineEvent(RoomEngineEvent.ROOM_ZOOMED, roomId));
}
roomCanvas.setScale(level, point, offsetPoint, isFlipForced);
GetEventDispatcher().dispatchEvent(new RoomEngineEvent(RoomEngineEvent.ROOM_ZOOMED, roomId));
}
public getRoomInstanceRenderingCanvas(roomId: number, canvasId: number = -1): IRoomRenderingCanvas

3
packages/room/src/object/visualization/furniture/FurnitureGuildIsometricBadgeVisualization.ts
View File

@ -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);

23
packages/room/src/object/visualization/furniture/FurnitureVisualizationData.ts
View File

@ -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;

3
packages/room/src/object/visualization/furniture/IsometricImageFurniVisualization.ts
View File

@ -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);

33
packages/room/src/object/visualization/room/RoomPlane.ts
View File

@ -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_11 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, (height / RoomPlane.PLANE_GEOMETRY.scale), 0));
const _local_12 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d((width / RoomPlane.PLANE_GEOMETRY.scale), 0, 0));
const _local_10 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 0));
const _local_11 = planeGeometry.getScreenPoint(new Vector3d(0, (height / planeGeometry.scale), 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_9 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, (height / RoomPlane.PLANE_GEOMETRY.scale)));
const _local_10 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, (width / RoomPlane.PLANE_GEOMETRY.scale), 0));
const _local_8 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 0));
const _local_9 = planeGeometry.getScreenPoint(new Vector3d(0, 0, (height / planeGeometry.scale)));
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_14 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 0, 1));
const _local_15 = RoomPlane.PLANE_GEOMETRY.getScreenPoint(new Vector3d(0, 1, 0));
const _local_13 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 0));
const _local_14 = planeGeometry.getScreenPoint(new Vector3d(0, 0, 1));
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)));
height = Math.round(Math.abs((((_local_13.y - _local_14.y) * height) / 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) / 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)));

9
packages/room/src/renderer/RoomSpriteCanvas.ts
View File

@ -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;
if(extendedSprite.y !== sprite.y) extendedSprite.y = sprite.y;
extendedSprite.x = Math.round(sprite.x);
extendedSprite.y = Math.round(sprite.y);
extendedSprite.offsetX = objectSprite.offsetX;
extendedSprite.offsetY = objectSprite.offsetY;