nitro/nitro-renderer
1
0
Fork 0
mirror of https://github.com/billsonnn/nitro-renderer.git synced 2024-11-26 09:20:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Still buggy but better landscapes

Browse Source
This commit is contained in:
Bill 2023-01-13 02:48:35 -05:00
parent 103a128508
commit ce82ff9930
18 changed files with 168 additions and 386 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
src/nitro/room/object/visualization/room/RoomPlane.ts
View File

@ -2,7 +2,7 @@ import { Renderer, RenderTexture, Resource, Texture } from '@pixi/core';
import { Matrix, Point } from '@pixi/math'; import { Matrix, Point } from '@pixi/math';
import { Sprite } from '@pixi/sprite'; import { Sprite } from '@pixi/sprite';
import { IRoomGeometry, IRoomPlane, IVector3D, Vector3d } from '../../../../../api'; import { IRoomGeometry, IRoomPlane, IVector3D, Vector3d } from '../../../../../api';
import { PixiApplicationProxy, RoomTextureCache } from '../../../../../pixi-proxy'; import { PixiApplicationProxy, PlaneTextureCache } from '../../../../../pixi-proxy';
import { ColorConverter } from '../../../../../room'; import { ColorConverter } from '../../../../../room';
import { PlaneMaskManager } from './mask'; import { PlaneMaskManager } from './mask';
import { PlaneDrawingData } from './PlaneDrawingData'; import { PlaneDrawingData } from './PlaneDrawingData';
@ -20,7 +20,7 @@ export class RoomPlane implements IRoomPlane
public static TYPE_LANDSCAPE: number = 3; public static TYPE_LANDSCAPE: number = 3;
private static _uniqueIdCounter: number = 1; private static _uniqueIdCounter: number = 1;
private _textureCache: RoomTextureCache; private _textureCache: PlaneTextureCache;
private _disposed: boolean; private _disposed: boolean;
private _randomSeed: number; private _randomSeed: number;
private _origin: Vector3d; private _origin: Vector3d;
@ -45,7 +45,6 @@ export class RoomPlane implements IRoomPlane
private _textureOffsetY: number; private _textureOffsetY: number;
private _textureMaxX: number; private _textureMaxX: number;
private _textureMaxY: number; private _textureMaxY: number;
private _textures: Map<string, PlaneBitmapData>;
private _activeTexture: PlaneBitmapData; private _activeTexture: PlaneBitmapData;
private _useMask: boolean; private _useMask: boolean;
private _bitmapMasks: RoomPlaneBitmapMask[]; private _bitmapMasks: RoomPlaneBitmapMask[];
@ -63,7 +62,7 @@ export class RoomPlane implements IRoomPlane
private _height: number = 0; private _height: number = 0;
private _canBeVisible: boolean; private _canBeVisible: boolean;
constructor(textureCache: RoomTextureCache, origin: IVector3D, location: IVector3D, leftSide: IVector3D, rightSide: IVector3D, type: number, usesMask: boolean, secondaryNormals: IVector3D[], randomSeed: number, textureOffsetX: number = 0, textureOffsetY: number = 0, textureMaxX: number = 0, textureMaxY: number = 0) constructor(textureCache: PlaneTextureCache, origin: IVector3D, location: IVector3D, leftSide: IVector3D, rightSide: IVector3D, type: number, usesMask: boolean, secondaryNormals: IVector3D[], randomSeed: number, textureOffsetX: number = 0, textureOffsetY: number = 0, textureMaxX: number = 0, textureMaxY: number = 0)
{ {
this._textureCache = textureCache; this._textureCache = textureCache;
this._secondaryNormals = []; this._secondaryNormals = [];
@ -115,7 +114,6 @@ export class RoomPlane implements IRoomPlane
this._color = 0; this._color = 0;
this._rasterizer = null; this._rasterizer = null;
this._canBeVisible = true; this._canBeVisible = true;
this._textures = new Map();
this._cornerA = new Vector3d(); this._cornerA = new Vector3d();
this._cornerB = new Vector3d(); this._cornerB = new Vector3d();
this._cornerC = new Vector3d(); this._cornerC = new Vector3d();
@ -256,20 +254,6 @@ export class RoomPlane implements IRoomPlane
this._bitmapData = null; this._bitmapData = null;
} }
if(this._textures)
{
for(const bitmap of this._textures.values())
{
if(!bitmap) continue;
if(bitmap.texture) bitmap.texture.destroy();
bitmap.dispose();
}
this._textures = null;
}
this._activeTexture = null; this._activeTexture = null;
this._location = null; this._location = null;
this._origin = null; this._origin = null;
@ -305,37 +289,8 @@ export class RoomPlane implements IRoomPlane
return k; return k;
} }
private cacheTexture(k: string, _arg_2: PlaneBitmapData): boolean
{
const existing = this._textures.get(k);
if(existing)
{
this._textures.delete(k);
existing.dispose();
}
this._activeTexture = _arg_2;
this._textures.set(k, _arg_2);
return true;
}
private resetTextureCache(k: RenderTexture = null): void private resetTextureCache(k: RenderTexture = null): void
{ {
if(this._textures && this._textures.size)
{
for(const bitmap of this._textures.values())
{
if(!bitmap) continue;
bitmap.dispose();
}
this._textures.clear();
}
this._activeTexture = null; this._activeTexture = null;
} }
@ -350,12 +305,7 @@ export class RoomPlane implements IRoomPlane
{ {
if(!k) return false; if(!k) return false;
let planeBitmap = this._activeTexture; const planeBitmap = this._activeTexture;
if(!planeBitmap)
{
planeBitmap = this._textures.get(this.getTextureIdentifier(k.scale));
}
this.updateMaskChangeStatus(); this.updateMaskChangeStatus();
@ -377,48 +327,16 @@ export class RoomPlane implements IRoomPlane
const height = this._rightSide.length * geometry.scale; const height = this._rightSide.length * geometry.scale;
const normal = geometry.getCoordinatePosition(this._normal); const normal = geometry.getCoordinatePosition(this._normal);
if(this._activeTexture) bitmapData = this._rasterizer.render(this._uniqueId.toString(), this._textureCache, null, this._id, width, height, geometry.scale, normal, this._hasTexture, this._textureOffsetX, this._textureOffsetY, this._textureMaxX, this._textureMaxY, timeSinceStartMs);
{
bitmapData = this._activeTexture;
}
else
{
bitmapData = this._textures.get(identifier);
}
let texture: RenderTexture = null;
if(bitmapData) texture = bitmapData.texture;
if(this._rasterizer)
{
bitmapData = this._rasterizer.render(this._uniqueId.toString(), this._textureCache, texture, this._id, width, height, geometry.scale, normal, this._hasTexture, this._textureOffsetX, this._textureOffsetY, this._textureMaxX, this._textureMaxY, timeSinceStartMs);
if(bitmapData && texture && (bitmapData?.texture !== texture)) texture.destroy(true);
}
else
{
const renderTexture = this._textureCache.createAndFillRenderTexture(width, height);
bitmapData = new PlaneBitmapData(renderTexture, -1);
}
if(bitmapData) if(bitmapData)
{ {
this.updateMask(bitmapData.texture, geometry); this.updateMask(bitmapData.texture, geometry);
this.cacheTexture(identifier, bitmapData);
} }
} }
else else
{ {
if(this._activeTexture) if(this._activeTexture) bitmapData = this._activeTexture;
{
bitmapData = this._activeTexture;
}
else
{
bitmapData = this._textures.get(this.getTextureIdentifier(geometry.scale));
}
} }
if(bitmapData) if(bitmapData)
@ -976,5 +894,6 @@ export class RoomPlane implements IRoomPlane
gl.bindTexture(gl.TEXTURE_2D, canvaGLTexture); gl.bindTexture(gl.TEXTURE_2D, canvaGLTexture);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, canvas.width, canvas.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, canvasPixels); gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, canvas.width, canvas.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, canvasPixels);
gl.bindTexture(gl.TEXTURE_2D, null);
} }
} }

26
src/nitro/room/object/visualization/room/RoomVisualization.ts
View File

@ -1,6 +1,6 @@
import { Rectangle } from '@pixi/math'; import { Rectangle } from '@pixi/math';
import { AlphaTolerance, IObjectVisualizationData, IPlaneVisualization, IRoomGeometry, IRoomObjectModel, IRoomObjectSprite, IRoomPlane, RoomObjectSpriteType, RoomObjectVariable, Vector3d } from '../../../../../api'; import { AlphaTolerance, IObjectVisualizationData, IPlaneVisualization, IRoomGeometry, IRoomObjectModel, IRoomObjectSprite, IRoomPlane, RoomObjectSpriteType, RoomObjectVariable, Vector3d } from '../../../../../api';
import { RoomTextureCache } from '../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../pixi-proxy';
import { RoomObjectSpriteVisualization } from '../../../../../room'; import { RoomObjectSpriteVisualization } from '../../../../../room';
import { ToInt32 } from '../../../../utils'; import { ToInt32 } from '../../../../utils';
import { RoomMapData } from '../../RoomMapData'; import { RoomMapData } from '../../RoomMapData';
@ -57,7 +57,7 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
private _assetUpdateCounter: number; private _assetUpdateCounter: number;
private _maskData: RoomMapMaskData; private _maskData: RoomMapMaskData;
private _isPlaneSet: boolean; private _isPlaneSet: boolean;
private _textureCache: RoomTextureCache; private _textureCache: PlaneTextureCache;
constructor() constructor()
{ {
@ -93,7 +93,7 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
this._assetUpdateCounter = 0; this._assetUpdateCounter = 0;
this._maskData = null; this._maskData = null;
this._isPlaneSet = false; this._isPlaneSet = false;
this._textureCache = new RoomTextureCache(); this._textureCache = new PlaneTextureCache();
this._typeVisibility[RoomPlane.TYPE_UNDEFINED] = false; this._typeVisibility[RoomPlane.TYPE_UNDEFINED] = false;
this._typeVisibility[RoomPlane.TYPE_FLOOR] = true; this._typeVisibility[RoomPlane.TYPE_FLOOR] = true;
@ -147,7 +147,6 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
if(this._textureCache) if(this._textureCache)
{ {
console.log('clear it');
this._textureCache.clearCache(); this._textureCache.clearCache();
} }
} }
@ -183,7 +182,10 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
if(((time < (this._lastUpdateTime + this._updateIntervalTime)) && (!geometryUpdate)) && (!needsUpdate)) return; if(((time < (this._lastUpdateTime + this._updateIntervalTime)) && (!geometryUpdate)) && (!needsUpdate)) return;
if(this.updatePlaneTexturesAndVisibilities(objectModel)) needsUpdate = true; if(this.updatePlaneTexturesAndVisibilities(objectModel))
{
needsUpdate = true;
}
if(this.updatePlanes(geometry, geometryUpdate, time)) needsUpdate = true; if(this.updatePlanes(geometry, geometryUpdate, time)) needsUpdate = true;
@ -339,15 +341,11 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
const wallType = model.getValue<string>(RoomObjectVariable.ROOM_WALL_TYPE); const wallType = model.getValue<string>(RoomObjectVariable.ROOM_WALL_TYPE);
const landscapeType = model.getValue<string>(RoomObjectVariable.ROOM_LANDSCAPE_TYPE); const landscapeType = model.getValue<string>(RoomObjectVariable.ROOM_LANDSCAPE_TYPE);
this.updatePlaneTypes(floorType, wallType, landscapeType);
const floorVisibility = (model.getValue<number>(RoomObjectVariable.ROOM_FLOOR_VISIBILITY) === 1); const floorVisibility = (model.getValue<number>(RoomObjectVariable.ROOM_FLOOR_VISIBILITY) === 1);
const wallVisibility = (model.getValue<number>(RoomObjectVariable.ROOM_WALL_VISIBILITY) === 1); const wallVisibility = (model.getValue<number>(RoomObjectVariable.ROOM_WALL_VISIBILITY) === 1);
const landscapeVisibility = (model.getValue<number>(RoomObjectVariable.ROOM_LANDSCAPE_VISIBILITY) === 1); const landscapeVisibility = (model.getValue<number>(RoomObjectVariable.ROOM_LANDSCAPE_VISIBILITY) === 1);
this.updatePlaneVisibility(floorVisibility, wallVisibility, landscapeVisibility); return (this.updatePlaneTypes(floorType, wallType, landscapeType) || this.updatePlaneVisibility(floorVisibility, wallVisibility, landscapeVisibility));
return true;
} }
private clearPlanes(): void private clearPlanes(): void
@ -691,9 +689,9 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
return true; return true;
} }
private updatePlaneVisibility(k: boolean, _arg_2: boolean, _arg_3: boolean): void private updatePlaneVisibility(k: boolean, _arg_2: boolean, _arg_3: boolean): boolean
{ {
if((k === this._typeVisibility[RoomPlane.TYPE_FLOOR]) && (_arg_2 === this._typeVisibility[RoomPlane.TYPE_WALL]) && (_arg_3 === this._typeVisibility[RoomPlane.TYPE_LANDSCAPE])) return; if((k === this._typeVisibility[RoomPlane.TYPE_FLOOR]) && (_arg_2 === this._typeVisibility[RoomPlane.TYPE_WALL]) && (_arg_3 === this._typeVisibility[RoomPlane.TYPE_LANDSCAPE])) return false;
this._typeVisibility[RoomPlane.TYPE_FLOOR] = k; this._typeVisibility[RoomPlane.TYPE_FLOOR] = k;
this._typeVisibility[RoomPlane.TYPE_WALL] = _arg_2; this._typeVisibility[RoomPlane.TYPE_WALL] = _arg_2;
@ -701,11 +699,13 @@ export class RoomVisualization extends RoomObjectSpriteVisualization implements
this._visiblePlanes = []; this._visiblePlanes = [];
this._visiblePlaneSpriteNumbers = []; this._visiblePlaneSpriteNumbers = [];
return true;
} }
protected updatePlanes(geometry: IRoomGeometry, geometryUpdate: boolean, timeSinceStartMs: number): boolean protected updatePlanes(geometry: IRoomGeometry, geometryUpdate: boolean, timeSinceStartMs: number): boolean
{ {
if(!geometry || !this.object) return; if(!geometry || !this.object) return false;
this._assetUpdateCounter++; this._assetUpdateCounter++;

4
src/nitro/room/object/visualization/room/rasterizer/IPlaneRasterizer.ts
View File

@ -1,13 +1,13 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IVector3D } from '../../../../../../api'; import { IVector3D } from '../../../../../../api';
import { RoomTextureCache } from '../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../pixi-proxy';
import { PlaneBitmapData } from '../utils'; import { PlaneBitmapData } from '../utils';
import { PlaneVisualizationLayer } from './basic'; import { PlaneVisualizationLayer } from './basic';
export interface IPlaneRasterizer export interface IPlaneRasterizer
{ {
initializeDimensions(_arg_1: number, _arg_2: number): boolean; initializeDimensions(_arg_1: number, _arg_2: number): boolean;
render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX?: number, offsetY?: number, maxX?: number, maxY?: number, timeSinceStartMs?: number): PlaneBitmapData; render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX?: number, offsetY?: number, maxX?: number, maxY?: number, timeSinceStartMs?: number): PlaneBitmapData;
getTextureIdentifier(_arg_1: number, _arg_2: IVector3D): string; getTextureIdentifier(_arg_1: number, _arg_2: IVector3D): string;
getLayers(_arg_1: string): PlaneVisualizationLayer[]; getLayers(_arg_1: string): PlaneVisualizationLayer[];
reinitialize(): void; reinitialize(): void;

4
src/nitro/room/object/visualization/room/rasterizer/animated/LandscapePlane.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IVector3D, Vector3d } from '../../../../../../../api'; import { IVector3D, Vector3d } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { Plane } from '../basic'; import { Plane } from '../basic';
export class LandscapePlane extends Plane export class LandscapePlane extends Plane
@ -34,7 +34,7 @@ export class LandscapePlane extends Plane
} }
} }
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number, maxX: number, maxY: number, timeSinceStartMs: number): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number, maxX: number, maxY: number, timeSinceStartMs: number): RenderTexture
{ {
const visualization = this.getPlaneVisualization(scale); const visualization = this.getPlaneVisualization(scale);

39
src/nitro/room/object/visualization/room/rasterizer/animated/LandscapeRasterizer.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IAssetPlane, IAssetPlaneVisualizationAnimatedLayer, IAssetPlaneVisualizationLayer, IVector3D, Vector3d } from '../../../../../../../api'; import { IAssetPlane, IAssetPlaneVisualizationAnimatedLayer, IAssetPlaneVisualizationLayer, IVector3D } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { PlaneBitmapData, Randomizer } from '../../utils'; import { PlaneBitmapData, Randomizer } from '../../utils';
import { PlaneMaterial, PlaneRasterizer, PlaneVisualizationLayer } from '../basic'; import { PlaneMaterial, PlaneRasterizer, PlaneVisualizationLayer } from '../basic';
import { LandscapePlane } from './LandscapePlane'; import { LandscapePlane } from './LandscapePlane';
@ -184,7 +184,7 @@ export class LandscapeRasterizer extends PlaneRasterizer
return _local_3; return _local_3;
} }
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData
{ {
let plane = this.getPlane(id) as LandscapePlane; let plane = this.getPlane(id) as LandscapePlane;
@ -194,39 +194,6 @@ export class LandscapeRasterizer extends PlaneRasterizer
if(canvas) textureCache.clearRenderTexture(canvas); if(canvas) textureCache.clearRenderTexture(canvas);
if(!LandscapeRasterizer.LANDSCAPES_ENABLED)
{
const visualization = plane.getPlaneVisualization(scale);
if(!visualization || !visualization.geometry) return null;
const _local_13 = visualization.geometry.getScreenPoint(new Vector3d(0, 0, 0));
const _local_14 = visualization.geometry.getScreenPoint(new Vector3d(0, 0, 1));
const _local_15 = visualization.geometry.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) / visualization.geometry.scale)));
height = Math.round(Math.abs((((_local_13.y - _local_14.y) * height) / visualization.geometry.scale)));
}
if(!this._cachedBitmap || (this._cachedBitmap.width !== width ) || (this._cachedBitmap.height !== height))
{
if(this._cachedBitmap)
{
this._cachedBitmap.destroy(true);
this._cachedBitmap = null;
}
this._cachedBitmap = textureCache.createAndFillRenderTexture(width, height, LandscapeRasterizer.LANDSCAPE_DEFAULT_COLOR);
}
return new PlaneBitmapData(this._cachedBitmap, -1);
}
if(canvas) textureCache.clearRenderTexture(canvas);
let graphic = plane.render(planeId,textureCache, canvas, width, height, scale, normal, useTexture, offsetX, offsetY, maxX, maxY, timeSinceStartMs); let graphic = plane.render(planeId,textureCache, canvas, width, height, scale, normal, useTexture, offsetX, offsetY, maxX, maxY, timeSinceStartMs);
if(graphic && (graphic !== canvas)) if(graphic && (graphic !== canvas))

8
src/nitro/room/object/visualization/room/rasterizer/animated/PlaneVisualizationAnimationLayer.ts
View File

@ -1,7 +1,7 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { Sprite } from '@pixi/sprite'; import { Sprite } from '@pixi/sprite';
import { IDisposable, IGraphicAssetCollection, IVector3D } from '../../../../../../../api'; import { IDisposable, IGraphicAssetCollection, IVector3D } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { AnimationItem } from './AnimationItem'; import { AnimationItem } from './AnimationItem';
export class PlaneVisualizationAnimationLayer implements IDisposable export class PlaneVisualizationAnimationLayer implements IDisposable
@ -70,9 +70,9 @@ export class PlaneVisualizationAnimationLayer implements IDisposable
} }
} }
public render(textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, offsetX: number, offsetY: number, maxX: number, maxY: number, dimensionX: number, dimensionY: number, timeSinceStartMs: number): RenderTexture public render(textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, offsetX: number, offsetY: number, maxX: number, maxY: number, dimensionX: number, dimensionY: number, timeSinceStartMs: number): RenderTexture
{ {
if(!canvas || (canvas.width !== width) || (canvas.height !== height)) /* if(!canvas || (canvas.width !== width) || (canvas.height !== height))
{ {
if(!this._bitmapData || (this._bitmapData.width !== width) || (this._bitmapData.height !== height)) if(!this._bitmapData || (this._bitmapData.width !== width) || (this._bitmapData.height !== height))
{ {
@ -86,7 +86,7 @@ export class PlaneVisualizationAnimationLayer implements IDisposable
} }
canvas = this._bitmapData; canvas = this._bitmapData;
} } */
if(((maxX > 0) && (maxY > 0))) if(((maxX > 0) && (maxY > 0)))
{ {

4
src/nitro/room/object/visualization/room/rasterizer/basic/FloorPlane.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IVector3D, Vector3d } from '../../../../../../../api'; import { IVector3D, Vector3d } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { Plane } from './Plane'; import { Plane } from './Plane';
export class FloorPlane extends Plane export class FloorPlane extends Plane
@ -9,7 +9,7 @@ export class FloorPlane extends Plane
public static HORIZONTAL_ANGLE_DEFAULT: number = 45; public static HORIZONTAL_ANGLE_DEFAULT: number = 45;
public static VERTICAL_ANGLE_DEFAULT: number = 30; public static VERTICAL_ANGLE_DEFAULT: number = 30;
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number): RenderTexture
{ {
const visualization = this.getPlaneVisualization(scale); const visualization = this.getPlaneVisualization(scale);

4
src/nitro/room/object/visualization/room/rasterizer/basic/FloorRasterizer.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IAssetPlane, IVector3D } from '../../../../../../../api'; import { IAssetPlane, IVector3D } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { PlaneBitmapData } from '../../utils'; import { PlaneBitmapData } from '../../utils';
import { FloorPlane } from './FloorPlane'; import { FloorPlane } from './FloorPlane';
import { PlaneRasterizer } from './PlaneRasterizer'; import { PlaneRasterizer } from './PlaneRasterizer';
@ -36,7 +36,7 @@ export class FloorRasterizer extends PlaneRasterizer
} }
} }
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData
{ {
let plane = this.getPlane(id) as FloorPlane; let plane = this.getPlane(id) as FloorPlane;

6
src/nitro/room/object/visualization/room/rasterizer/basic/PlaneMaterial.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IVector3D } from '../../../../../../../api'; import { IVector3D } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { PlaneMaterialCellMatrix } from './PlaneMaterialCellMatrix'; import { PlaneMaterialCellMatrix } from './PlaneMaterialCellMatrix';
export class PlaneMaterial export class PlaneMaterial
@ -77,7 +77,7 @@ export class PlaneMaterial
return null; return null;
} }
public render(textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number, topAlign: boolean): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number, topAlign: boolean): RenderTexture
{ {
if(width < 1) width = 1; if(width < 1) width = 1;
@ -89,6 +89,6 @@ export class PlaneMaterial
this._isCached = true; this._isCached = true;
return cellMatrix.render(textureCache, canvas, width, height, normal, useTexture, offsetX, offsetY, topAlign); return cellMatrix.render(planeId, textureCache, canvas, width, height, normal, useTexture, offsetX, offsetY, topAlign);
} }
} }

39
src/nitro/room/object/visualization/room/rasterizer/basic/PlaneMaterialCellColumn.ts
View File

@ -1,7 +1,6 @@
import { RenderTexture, Texture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { Sprite } from '@pixi/sprite';
import { IVector3D, Vector3d } from '../../../../../../../api'; import { IVector3D, Vector3d } from '../../../../../../../api';
import { RoomTextureCache, TextureUtils } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache, TextureUtils } from '../../../../../../../pixi-proxy';
import { PlaneMaterialCell } from './PlaneMaterialCell'; import { PlaneMaterialCell } from './PlaneMaterialCell';
export class PlaneMaterialCellColumn export class PlaneMaterialCellColumn
@ -125,7 +124,7 @@ export class PlaneMaterialCellColumn
this._isCached = false; this._isCached = false;
} }
public render(textureCache: RoomTextureCache, height: number, normal: IVector3D, offsetX: number, offsetY: number): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, height: number, normal: IVector3D, offsetX: number, offsetY: number): RenderTexture
{ {
if(this._repeatMode === PlaneMaterialCellColumn.REPEAT_MODE_NONE) height = this.getCellsHeight(this._cells, normal); if(this._repeatMode === PlaneMaterialCellColumn.REPEAT_MODE_NONE) height = this.getCellsHeight(this._cells, normal);
@ -141,46 +140,20 @@ export class PlaneMaterialCellColumn
} }
else else
{ {
if(this._cachedBitmapData.height === height) this._cachedBitmapData = null;
{
textureCache.clearRenderTexture(this._cachedBitmapData);
}
else
{
this._cachedBitmapData.destroy(true);
this._cachedBitmapData = null;
}
} }
} }
} }
else else
{ {
if(this._cachedBitmapData) this._cachedBitmapData = null;
{
if(this._cachedBitmapData.height === height)
{
const sprite = new Sprite(Texture.EMPTY);
sprite.width = this._cachedBitmapData.width;
sprite.height = height;
textureCache.writeToRenderTexture(sprite, this._cachedBitmapData);
}
else
{
this._cachedBitmapData.destroy(true);
this._cachedBitmapData = null;
}
}
} }
this._isCached = true; this._isCached = true;
if(!this._cachedBitmapData) if(!this._cachedBitmapData)
{ {
this._cachedBitmapData = textureCache.createRenderTexture(this._width, height); this._cachedBitmapData = textureCache.createRenderTexture(this._width, height, `${ planeId }:column`);
} }
this._cachedBitmapNormal.assign(normal); this._cachedBitmapNormal.assign(normal);

53
src/nitro/room/object/visualization/room/rasterizer/basic/PlaneMaterialCellMatrix.ts
View File

@ -1,8 +1,8 @@
import { RenderTexture, Texture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { Point, Rectangle } from '@pixi/math'; import { Point, Rectangle } from '@pixi/math';
import { Sprite } from '@pixi/sprite'; import { Sprite } from '@pixi/sprite';
import { IVector3D, NitroLogger, Vector3d } from '../../../../../../../api'; import { IVector3D, NitroLogger, Vector3d } from '../../../../../../../api';
import { RoomTextureCache, TextureUtils } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache, TextureUtils } from '../../../../../../../pixi-proxy';
import { Randomizer } from '../../utils'; import { Randomizer } from '../../utils';
import { PlaneMaterialCell } from './PlaneMaterialCell'; import { PlaneMaterialCell } from './PlaneMaterialCell';
import { PlaneMaterialCellColumn } from './PlaneMaterialCellColumn'; import { PlaneMaterialCellColumn } from './PlaneMaterialCellColumn';
@ -34,7 +34,6 @@ export class PlaneMaterialCellMatrix
private _normalMaxX: number = 1; private _normalMaxX: number = 1;
private _normalMinY: number = -1; private _normalMinY: number = -1;
private _normalMaxY: number = 1; private _normalMaxY: number = 1;
private _texturePool: Map<string, RenderTexture>;
constructor(totalColumns: number, repeatMode: number = 1, align: number = 1, normalMinX: number = -1, normalMaxX: number = 1, normalMinY: number = -1, normalMaxY: number = 1) constructor(totalColumns: number, repeatMode: number = 1, align: number = 1, normalMinX: number = -1, normalMaxX: number = 1, normalMinY: number = -1, normalMaxY: number = 1)
{ {
@ -57,7 +56,6 @@ export class PlaneMaterialCellMatrix
this._normalMaxX = normalMaxX; this._normalMaxX = normalMaxX;
this._normalMinY = normalMinY; this._normalMinY = normalMinY;
this._normalMaxY = normalMaxY; this._normalMaxY = normalMaxY;
this._texturePool = new Map();
if(this._repeatMode === PlaneMaterialCellMatrix.REPEAT_MODE_RANDOM) this._isStatic = false; if(this._repeatMode === PlaneMaterialCellMatrix.REPEAT_MODE_RANDOM) this._isStatic = false;
} }
@ -139,13 +137,6 @@ export class PlaneMaterialCellMatrix
} }
} }
if(this._texturePool && this._texturePool.size)
{
this._texturePool.forEach(texture => texture.destroy(true));
this._texturePool.clear();
}
this._isCached = false; this._isCached = false;
} }
@ -165,14 +156,12 @@ export class PlaneMaterialCellMatrix
return true; return true;
} }
public render(textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number, topAlign: boolean): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number, topAlign: boolean): RenderTexture
{ {
if(width < 1) width = 1; if(width < 1) width = 1;
if(height < 1) height = 1; if(height < 1) height = 1;
if(!canvas || (canvas.width !== width) || (canvas.height !== height)) canvas = null;
if(!this._cachedBitmapNormal) this._cachedBitmapNormal = new Vector3d(); if(!this._cachedBitmapNormal) this._cachedBitmapNormal = new Vector3d();
if(this.isStatic) if(this.isStatic)
@ -208,30 +197,13 @@ export class PlaneMaterialCellMatrix
if(!this._cachedBitmapData) if(!this._cachedBitmapData)
{ {
this._cachedBitmapData = this._texturePool.get(`${width}:${height}`); this._cachedBitmapData = textureCache.createAndFillRenderTexture(width, height, `${ planeId }:matrix`);
if(!this._cachedBitmapData)
{
this._cachedBitmapData = textureCache.createAndFillRenderTexture(width, height);
this._texturePool.set(`${width}:${height}`, this._cachedBitmapData);
}
else
{
textureCache.clearAndFillRenderTexture(this._cachedBitmapData);
}
} }
else else
{ {
textureCache.clearAndFillRenderTexture(this._cachedBitmapData); textureCache.clearAndFillRenderTexture(this._cachedBitmapData);
} }
if(canvas)
{
this.copyCachedBitmapOnCanvas(canvas, height, offsetY, topAlign);
return canvas;
}
return this._cachedBitmapData; return this._cachedBitmapData;
} }
@ -240,18 +212,9 @@ export class PlaneMaterialCellMatrix
{ {
this._cachedBitmapHeight = height; this._cachedBitmapHeight = height;
this._cachedBitmapData = this._texturePool.get(`${width}:${height}`); this._cachedBitmapData = textureCache.createRenderTexture(width, height, `${ planeId }:matrix`);
if(!this._cachedBitmapData) textureCache.clearRenderTexture(this._cachedBitmapData);
{
this._cachedBitmapData = textureCache.createRenderTexture(width, height);
this._texturePool.set(`${width}:${height}`, this._cachedBitmapData);
}
else
{
textureCache.clearRenderTexture(this._cachedBitmapData);
}
} }
const columns: RenderTexture[] = []; const columns: RenderTexture[] = [];
@ -264,7 +227,7 @@ export class PlaneMaterialCellMatrix
if(column) if(column)
{ {
const columnBitmapData = column.render(textureCache, height, normal, offsetX, offsetY); const columnBitmapData = column.render(planeId, textureCache, height, normal, offsetX, offsetY);
if(columnBitmapData) columns.push(columnBitmapData); if(columnBitmapData) columns.push(columnBitmapData);
} }
@ -336,7 +299,7 @@ export class PlaneMaterialCellMatrix
bounds = new Rectangle(0, (this._cachedBitmapData.height - this._cachedBitmapHeight), this._cachedBitmapData.width, this._cachedBitmapHeight); bounds = new Rectangle(0, (this._cachedBitmapData.height - this._cachedBitmapHeight), this._cachedBitmapData.width, this._cachedBitmapHeight);
} }
const texture = new Texture(this._cachedBitmapData.baseTexture, bounds); const texture = new RenderTexture(this._cachedBitmapData.baseTexture, bounds);
const sprite = new Sprite(texture); const sprite = new Sprite(texture);
sprite.position.set(0, offsetY); sprite.position.set(0, offsetY);

4
src/nitro/room/object/visualization/room/rasterizer/basic/PlaneRasterizer.ts
View File

@ -1,7 +1,7 @@
import { RenderTexture, Resource, Texture } from '@pixi/core'; import { RenderTexture, Resource, Texture } from '@pixi/core';
import { Point } from '@pixi/math'; import { Point } from '@pixi/math';
import { IAssetPlaneMaterial, IAssetPlaneMaterialCellColumn, IAssetPlaneTexture, IAssetPlaneVisualization, IAssetPlaneVisualizationData, IAssetPlaneVisualizationLayer, IGraphicAsset, IGraphicAssetCollection, IRoomGeometry, IVector3D, Vector3d } from '../../../../../../../api'; import { IAssetPlaneMaterial, IAssetPlaneMaterialCellColumn, IAssetPlaneTexture, IAssetPlaneVisualization, IAssetPlaneVisualizationData, IAssetPlaneVisualizationLayer, IGraphicAsset, IGraphicAssetCollection, IRoomGeometry, IVector3D, Vector3d } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { Rasterizer, RoomGeometry } from '../../../../../../../room'; import { Rasterizer, RoomGeometry } from '../../../../../../../room';
import { PlaneBitmapData } from '../../utils'; import { PlaneBitmapData } from '../../utils';
import { IPlaneRasterizer } from '../IPlaneRasterizer'; import { IPlaneRasterizer } from '../IPlaneRasterizer';
@ -585,7 +585,7 @@ export class PlaneRasterizer implements IPlaneRasterizer
} }
} }
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, id: string, width: number, height: number, size: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, id: string, width: number, height: number, size: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData
{ {
return null; return null;
} }

66
src/nitro/room/object/visualization/room/rasterizer/basic/PlaneVisualization.ts
View File

@ -1,7 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { Sprite } from '@pixi/sprite';
import { IDisposable, IGraphicAssetCollection, IRoomGeometry, IVector3D, Vector3d } from '../../../../../../../api'; import { IDisposable, IGraphicAssetCollection, IRoomGeometry, IVector3D, Vector3d } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { PlaneVisualizationAnimationLayer } from '../animated'; import { PlaneVisualizationAnimationLayer } from '../animated';
import { PlaneMaterial } from './PlaneMaterial'; import { PlaneMaterial } from './PlaneMaterial';
import { PlaneVisualizationLayer } from './PlaneVisualizationLayer'; import { PlaneVisualizationLayer } from './PlaneVisualizationLayer';
@ -14,7 +13,6 @@ export class PlaneVisualization
private _cachedBitmapNormal: Vector3d; private _cachedBitmapNormal: Vector3d;
private _isCached: boolean; private _isCached: boolean;
private _hasAnimationLayers: boolean; private _hasAnimationLayers: boolean;
private _texturePool: Map<string, RenderTexture>;
constructor(size: number, totalLayers: number, geometry: IRoomGeometry) constructor(size: number, totalLayers: number, geometry: IRoomGeometry)
{ {
@ -24,7 +22,6 @@ export class PlaneVisualization
this._cachedBitmapNormal = new Vector3d(); this._cachedBitmapNormal = new Vector3d();
this._isCached = false; this._isCached = false;
this._hasAnimationLayers = false; this._hasAnimationLayers = false;
this._texturePool = new Map();
if(totalLayers < 0) totalLayers = 0; if(totalLayers < 0) totalLayers = 0;
@ -102,13 +99,6 @@ export class PlaneVisualization
} }
} }
if(this._texturePool && this._texturePool.size)
{
this._texturePool.forEach(texture => texture.destroy(true));
this._texturePool.clear();
}
this._isCached = false; this._isCached = false;
} }
@ -148,7 +138,7 @@ export class PlaneVisualization
return this._layers as PlaneVisualizationLayer[]; return this._layers as PlaneVisualizationLayer[];
} }
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, dimensionX: number = 0, dimensionY: number = 0, timeSinceStartMs: number = 0): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, dimensionX: number = 0, dimensionY: number = 0, timeSinceStartMs: number = 0): RenderTexture
{ {
if(width < 1) width = 1; if(width < 1) width = 1;
@ -156,7 +146,7 @@ export class PlaneVisualization
if((!canvas || (canvas.width !== width)) || (canvas.height !== height)) canvas = null; if((!canvas || (canvas.width !== width)) || (canvas.height !== height)) canvas = null;
if(this._cachedBitmapData) /* if(this._cachedBitmapData)
{ {
if((this._cachedBitmapData.width === width) && (this._cachedBitmapData.height === height) && (Vector3d.isEqual(this._cachedBitmapNormal, normal))) if((this._cachedBitmapData.width === width) && (this._cachedBitmapData.height === height) && (Vector3d.isEqual(this._cachedBitmapNormal, normal)))
{ {
@ -176,46 +166,11 @@ export class PlaneVisualization
{ {
this._cachedBitmapData = null; this._cachedBitmapData = null;
} }
} } */
this._isCached = true; this._isCached = true;
if(!this._cachedBitmapData) this._cachedBitmapData = textureCache.createAndFillRenderTexture(width, height, planeId);
{
let cache = this._texturePool.get(planeId);
let swapCache = this._texturePool.get(planeId + '-swap');
if(!swapCache)
{
swapCache = textureCache.createAndFillRenderTexture(width, height);
this._texturePool.set(planeId + '-swap', swapCache);
}
else
{
if(cache)
{
[ cache, swapCache ] = [ swapCache, cache ];
}
}
if(!cache)
{
cache = textureCache.createAndFillRenderTexture(width, height);
this._texturePool.set(planeId, cache);
}
this._cachedBitmapData = swapCache;
textureCache.clearAndFillRenderTexture(this._cachedBitmapData);
}
else
{
textureCache.clearAndFillRenderTexture(this._cachedBitmapData);
}
if(!canvas) canvas = this._cachedBitmapData;
this._cachedBitmapNormal.assign(normal); this._cachedBitmapNormal.assign(normal);
@ -227,23 +182,16 @@ export class PlaneVisualization
if(layer instanceof PlaneVisualizationLayer) if(layer instanceof PlaneVisualizationLayer)
{ {
layer.render(textureCache, canvas, width, height, normal, useTexture, offsetX, offsetY); layer.render(planeId, textureCache, this._cachedBitmapData, width, height, normal, useTexture, offsetX, offsetY);
} }
else if(layer instanceof PlaneVisualizationAnimationLayer) else if(layer instanceof PlaneVisualizationAnimationLayer)
{ {
layer.render(textureCache, canvas, width, height, normal, offsetX, offsetY, maxX, maxY, dimensionX, dimensionY, timeSinceStartMs); layer.render(textureCache, this._cachedBitmapData, width, height, normal, offsetX, offsetY, maxX, maxY, dimensionX, dimensionY, timeSinceStartMs);
} }
} }
} }
if(canvas && (canvas !== this._cachedBitmapData))
{
textureCache.writeToRenderTexture(new Sprite(canvas), this._cachedBitmapData, false);
return canvas;
}
return this._cachedBitmapData; return this._cachedBitmapData;
} }
} }

58
src/nitro/room/object/visualization/room/rasterizer/basic/PlaneVisualizationLayer.ts
View File

@ -1,7 +1,7 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { Sprite } from '@pixi/sprite'; import { Sprite } from '@pixi/sprite';
import { IVector3D } from '../../../../../../../api'; import { IVector3D } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { PlaneMaterial } from './PlaneMaterial'; import { PlaneMaterial } from './PlaneMaterial';
export class PlaneVisualizationLayer export class PlaneVisualizationLayer
@ -61,65 +61,25 @@ export class PlaneVisualizationLayer
} }
} }
public render(textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, normal: IVector3D, useTexture: boolean, offsetX: number, offsetY: number): RenderTexture
{ {
if(!canvas || (canvas.width !== width) || (canvas.height !== height)) canvas = null;
const r = (this._color >> 16); const r = (this._color >> 16);
const g = ((this._color >> 8) & 0xFF); const g = ((this._color >> 8) & 0xFF);
const b = (this._color & 0xFF); const b = (this._color & 0xFF);
const hasColor = ((r < 0xFF) || (g < 0xFF) || (b < 0xFF));
let hasColor = false; const bitmapData = this._material.render(planeId, textureCache, hasColor ? null : canvas, width, height, normal, useTexture, offsetX, (offsetY + this.offset), (this.align === PlaneVisualizationLayer.ALIGN_TOP));
if(((r < 0xFF) || (g < 0xFF))|| (b < 0xFF)) hasColor = true; if(bitmapData && hasColor)
let bitmapData: RenderTexture = null;
if(this._material)
{ {
bitmapData = this._material.render(textureCache, hasColor ? null : canvas, width, height, normal, useTexture, offsetX, (offsetY + this.offset), (this.align === PlaneVisualizationLayer.ALIGN_TOP)); const sprite = new Sprite(bitmapData);
if(bitmapData && (bitmapData !== canvas)) if(hasColor) sprite.tint = this._color;
{
if(this._bitmapData) this._bitmapData.destroy();
this._bitmapData = new RenderTexture(bitmapData.baseTexture); textureCache.writeToRenderTexture(sprite, canvas, false);
bitmapData = this._bitmapData;
}
if(bitmapData && hasColor)
{
const sprite = new Sprite(bitmapData);
sprite.tint = this._color;
textureCache.writeToRenderTexture(sprite, canvas, false);
bitmapData = canvas;
}
}
else
{
if(!canvas)
{
if(this._bitmapData && (this._bitmapData.width === width) && (this._bitmapData.height === height)) return this._bitmapData;
if(this._bitmapData) this._bitmapData.destroy();
this._bitmapData = textureCache.createAndFillRenderTexture(width, height, this._color);
bitmapData = this._bitmapData;
}
else
{
textureCache.clearAndFillRenderTexture(canvas, this._color);
bitmapData = canvas;
}
} }
return bitmapData; return canvas;
} }
public getMaterial(): PlaneMaterial public getMaterial(): PlaneMaterial

4
src/nitro/room/object/visualization/room/rasterizer/basic/WallPlane.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IVector3D, Vector3d } from '../../../../../../../api'; import { IVector3D, Vector3d } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { Plane } from './Plane'; import { Plane } from './Plane';
export class WallPlane extends Plane export class WallPlane extends Plane
@ -9,7 +9,7 @@ export class WallPlane extends Plane
public static HORIZONTAL_ANGLE_DEFAULT: number = 45; public static HORIZONTAL_ANGLE_DEFAULT: number = 45;
public static VERTICAL_ANGLE_DEFAULT: number = 30; public static VERTICAL_ANGLE_DEFAULT: number = 30;
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, width: number, height: number, size: number, normal: IVector3D, useTexture: boolean): RenderTexture public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, width: number, height: number, size: number, normal: IVector3D, useTexture: boolean): RenderTexture
{ {
const visualization = this.getPlaneVisualization(size); const visualization = this.getPlaneVisualization(size);

4
src/nitro/room/object/visualization/room/rasterizer/basic/WallRasterizer.ts
View File

@ -1,6 +1,6 @@
import { RenderTexture } from '@pixi/core'; import { RenderTexture } from '@pixi/core';
import { IAssetPlane, IVector3D } from '../../../../../../../api'; import { IAssetPlane, IVector3D } from '../../../../../../../api';
import { RoomTextureCache } from '../../../../../../../pixi-proxy'; import { PlaneTextureCache } from '../../../../../../../pixi-proxy';
import { PlaneBitmapData } from '../../utils'; import { PlaneBitmapData } from '../../utils';
import { PlaneRasterizer } from './PlaneRasterizer'; import { PlaneRasterizer } from './PlaneRasterizer';
import { WallPlane } from './WallPlane'; import { WallPlane } from './WallPlane';
@ -36,7 +36,7 @@ export class WallRasterizer extends PlaneRasterizer
} }
} }
public render(planeId: string, textureCache: RoomTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData public render(planeId: string, textureCache: PlaneTextureCache, canvas: RenderTexture, id: string, width: number, height: number, scale: number, normal: IVector3D, useTexture: boolean, offsetX: number = 0, offsetY: number = 0, maxX: number = 0, maxY: number = 0, timeSinceStartMs: number = 0): PlaneBitmapData
{ {
let plane = this.getPlane(id) as WallPlane; let plane = this.getPlane(id) as WallPlane;

58
src/nitro/room/utils/LegacyWallGeometry.ts
View File

@ -112,30 +112,28 @@ export class LegacyWallGeometry implements ILegacyWallGeometry
return heightMap[x]; return heightMap[x];
} }
public getLocation(k: number, _arg_2: number, _arg_3: number, _arg_4: number, _arg_5: string): IVector3D public getLocation(width: number, height: number, localX: number, localY: number, direction: string): IVector3D
{ {
let _local_12: number;
let _local_6: number;
let _local_7: number; let _local_7: number;
if(((k == 0) && (_arg_2 == 0))) if(((width == 0) && (height == 0)))
{ {
k = this._width; width = this._width;
_arg_2 = this._height; height = this._height;
_local_12 = Math.round((this.scale / 10)); const _local_12 = Math.round((this.scale / 10));
if(_arg_5 == LegacyWallGeometry.R) if(direction == LegacyWallGeometry.R)
{ {
_local_7 = (this._width - 1); let _local_7 = (this._width - 1);
while(_local_7 >= 0) while(_local_7 >= 0)
{ {
_local_6 = 1; let _local_6 = 1;
while(_local_6 < this._height) while(_local_6 < this._height)
{ {
if(this.getHeight(_local_7, _local_6) <= this._floorHeight) if(this.getHeight(_local_7, _local_6) <= this._floorHeight)
{ {
if((_local_6 - 1) < _arg_2) if((_local_6 - 1) < height)
{ {
k = _local_7; width = _local_7;
_arg_2 = (_local_6 - 1); height = (_local_6 - 1);
} }
break; break;
} }
@ -143,23 +141,23 @@ export class LegacyWallGeometry implements ILegacyWallGeometry
} }
_local_7--; _local_7--;
} }
_arg_4 = (_arg_4 + ((this.scale / 4) - (_local_12 / 2))); localY = (localY + ((this.scale / 4) - (_local_12 / 2)));
_arg_3 = (_arg_3 + (this.scale / 2)); localX = (localX + (this.scale / 2));
} }
else else
{ {
_local_6 = (this._height - 1); let _local_6 = (this._height - 1);
while(_local_6 >= 0) while(_local_6 >= 0)
{ {
_local_7 = 1; let _local_7 = 1;
while(_local_7 < this._width) while(_local_7 < this._width)
{ {
if(this.getHeight(_local_7, _local_6) <= this._floorHeight) if(this.getHeight(_local_7, _local_6) <= this._floorHeight)
{ {
if((_local_7 - 1) < k) if((_local_7 - 1) < width)
{ {
k = (_local_7 - 1); width = (_local_7 - 1);
_arg_2 = _local_6; height = _local_6;
} }
break; break;
} }
@ -167,24 +165,24 @@ export class LegacyWallGeometry implements ILegacyWallGeometry
} }
_local_6--; _local_6--;
} }
_arg_4 = (_arg_4 + ((this.scale / 4) - (_local_12 / 2))); localY = (localY + ((this.scale / 4) - (_local_12 / 2)));
_arg_3 = (_arg_3 - _local_12); localX = (localX - _local_12);
} }
} }
let _local_8: number = k; let _local_8: number = width;
let _local_9: number = _arg_2; let _local_9: number = height;
let _local_10: number = this.getHeight(k, _arg_2); let _local_10: number = this.getHeight(width, height);
if(_arg_5 == LegacyWallGeometry.R) if(direction == LegacyWallGeometry.R)
{ {
_local_8 = (_local_8 + ((_arg_3 / (this._scale / 2)) - 0.5)); _local_8 = (_local_8 + ((localX / (this._scale / 2)) - 0.5));
_local_9 = (_local_9 + 0.5); _local_9 = (_local_9 + 0.5);
_local_10 = (_local_10 - ((_arg_4 - (_arg_3 / 2)) / (this._scale / 2))); _local_10 = (_local_10 - ((localY - (localX / 2)) / (this._scale / 2)));
} }
else else
{ {
_local_9 = (_local_9 + ((((this._scale / 2) - _arg_3) / (this._scale / 2)) - 0.5)); _local_9 = (_local_9 + ((((this._scale / 2) - localX) / (this._scale / 2)) - 0.5));
_local_8 = (_local_8 + 0.5); _local_8 = (_local_8 + 0.5);
_local_10 = (_local_10 - ((_arg_4 - (((this._scale / 2) - _arg_3) / 2)) / (this._scale / 2))); _local_10 = (_local_10 - ((localY - (((this._scale / 2) - localX) / 2)) / (this._scale / 2)));
} }
const _local_11: Vector3d = new Vector3d(_local_8, _local_9, _local_10); const _local_11: Vector3d = new Vector3d(_local_8, _local_9, _local_10);
return _local_11; return _local_11;

78
src/pixi-proxy/RoomTextureUtils.ts
View File

@ -5,14 +5,23 @@ import { Matrix, Rectangle } from '@pixi/math';
import { Sprite } from '@pixi/sprite'; import { Sprite } from '@pixi/sprite';
import { PixiApplicationProxy } from './PixiApplicationProxy'; import { PixiApplicationProxy } from './PixiApplicationProxy';
export class RoomTextureCache export class PlaneTextureCache
{ {
private static DEFAULT_PLANE_ID = 'DEFAULT';
public RENDER_TEXTURE_POOL: Map<string, RenderTexture> = new Map();
public RENDER_TEXTURE_CACHE: RenderTexture[] = []; public RENDER_TEXTURE_CACHE: RenderTexture[] = [];
public clearCache(): void public clearCache(): void
{ {
this.RENDER_TEXTURE_CACHE.forEach(renderTexture => renderTexture?.destroy(true)); const previousTextures = this.RENDER_TEXTURE_CACHE.slice();
setTimeout(() =>
{
previousTextures.forEach(renderTexture => renderTexture?.destroy(true));
}, 1000);
this.RENDER_TEXTURE_POOL.clear();
this.RENDER_TEXTURE_CACHE = []; this.RENDER_TEXTURE_CACHE = [];
} }
@ -23,34 +32,79 @@ export class RoomTextureCache
return this.writeToRenderTexture(new Sprite(Texture.EMPTY), renderTexture); return this.writeToRenderTexture(new Sprite(Texture.EMPTY), renderTexture);
} }
public createRenderTexture(width: number, height: number): RenderTexture private getTextureIdentifier(width: number, height: number, planeId: string): string
{
return `${ planeId ?? PlaneTextureCache.DEFAULT_PLANE_ID }:${ width }:${ height }`;
}
public createRenderTexture(width: number, height: number, planeId: string = null): RenderTexture
{ {
if((width < 0) || (height < 0)) return null; if((width < 0) || (height < 0)) return null;
const renderTexture = RenderTexture.create({ if(!planeId)
width, {
height const renderTexture = RenderTexture.create({
}); width,
height
});
this.RENDER_TEXTURE_CACHE.push(renderTexture); this.RENDER_TEXTURE_CACHE.push(renderTexture);
return renderTexture;
}
planeId = this.getTextureIdentifier(width, height, planeId);
let renderTexture = this.RENDER_TEXTURE_POOL.get(planeId);
if(!renderTexture)
{
renderTexture = RenderTexture.create({
width,
height
});
this.RENDER_TEXTURE_CACHE.push(renderTexture);
this.RENDER_TEXTURE_POOL.set(planeId, renderTexture);
}
/* else
{
renderTexture = this.RENDER_TEXTURE_POOL.get(planeId + '-swap');
if(!renderTexture)
{
renderTexture = RenderTexture.create({
width,
height
});
this.RENDER_TEXTURE_CACHE.push(renderTexture);
this.RENDER_TEXTURE_POOL.set(planeId + '-swap', renderTexture);
}
this.RENDER_TEXTURE_POOL.set(planeId + '-swap', this.RENDER_TEXTURE_POOL.get(planeId));
this.RENDER_TEXTURE_POOL.set(planeId, renderTexture);
} */
return renderTexture; return renderTexture;
} }
public createAndFillRenderTexture(width: number, height: number, color: number = 16777215): RenderTexture public createAndFillRenderTexture(width: number, height: number, planeId = null, color: number = 16777215): RenderTexture
{ {
if((width < 0) || (height < 0)) return null; if((width < 0) || (height < 0)) return null;
const renderTexture = this.createRenderTexture(width, height); const renderTexture = this.createRenderTexture(width, height, planeId);
return this.clearAndFillRenderTexture(renderTexture, color); return this.clearAndFillRenderTexture(renderTexture, color);
} }
public createAndWriteRenderTexture(width: number, height: number, displayObject: DisplayObject, transform: Matrix = null): RenderTexture public createAndWriteRenderTexture(width: number, height: number, displayObject: DisplayObject, planeId: string = null, transform: Matrix = null): RenderTexture
{ {
if((width < 0) || (height < 0)) return null; if((width < 0) || (height < 0)) return null;
const renderTexture = this.createRenderTexture(width, height); const renderTexture = this.createRenderTexture(width, height, planeId);
return this.writeToRenderTexture(displayObject, renderTexture, true, transform); return this.writeToRenderTexture(displayObject, renderTexture, true, transform);
} }