Refactor/various refactorings

src/lib/effects/billboard/billboard-shader.ts

@@ -34,8 +34,10 @@ function createBillboardMaterial(params: Parameters): THREE.Material {
     let material: THREE.Material;
     if (params.material === 'Phong') {
         material = new THREE.MeshPhongMaterial();
+        material.name = 'billboard-material-phong';
     } else if (params.material === 'Basic') {
         material = new THREE.MeshBasicMaterial();
+        material.name = 'billboard-material-basic';
     } else {
         throw new Error(`Unsupported material "${params.material}".`);
     }
@@ -151,12 +153,13 @@ function createBillboardInstancedBufferGeometry(): THREE.InstancedBufferGeometry
     );
     bufferGeometry.setAttribute('normal', new THREE.Float32BufferAttribute([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1], 3));
     bufferGeometry.setAttribute('uv', new THREE.Float32BufferAttribute([0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0], 2));
+    bufferGeometry.name = 'billboard-instanced-buffergeometry';
     return bufferGeometry;
 }
 
 export {
-    createBillboardMaterial,
     createBillboardInstancedBufferGeometry,
+    createBillboardMaterial,
     type AttributeDefinition,
     type UniformDefinition,
     type VaryingDefinition,

src/lib/effects/billboard/gpu/gpu-textures-state.ts

@@ -29,7 +29,7 @@ class GpuTexturesState {
     private readonly renderTargets: [THREE.WebGLRenderTarget, THREE.WebGLRenderTarget];
     private currentRenderTargetId: number = 0;
 
-    private readonly pipelines: Record<string, Pipeline> = {};
+    private readonly pipelines = new Map<string, Pipeline>();
 
     public constructor(params: Parameters) {
         this.renderTargets = [
@@ -120,7 +120,7 @@ ${['vUv', ...params.textureNames.map((_name: string, index: number) => `out_frag
 }`;
             }
 
-            this.pipelines[name] = {
+            this.pipelines.set(name, {
                 shader: new THREE.RawShaderMaterial({
                     glslVersion: '300 es',
                     blending: THREE.NoBlending,
@@ -131,12 +131,12 @@ ${['vUv', ...params.textureNames.map((_name: string, index: number) => `out_frag
                     fragmentShader,
                 }),
                 requiresPreviousState: definition.requiresPreviousState,
-            };
+            });
         }
     }
 
     public runPipeline(renderer: THREE.WebGLRenderer, name: string): void {
-        const pipeline = this.pipelines[name];
+        const pipeline = this.pipelines.get(name);
         if (!pipeline) {
             throw new Error(`Unknown pipeline "${name}".`);
         }

src/lib/effects/billboard/instanced-billboard-batch.ts

@@ -32,7 +32,7 @@ class InstancedBillboardBatch {
     public readonly maxInstancesCount: number;
     private readonly instanceWorldPositionAttribute: THREE.InstancedBufferAttribute;
     private readonly instanceLocalTransformAttribute: THREE.InstancedBufferAttribute;
-    private readonly instanceCustomAttributes: Record<string, CustomAttribute>;
+    private readonly instanceCustomAttributes = new Map<string, CustomAttribute>();
 
     public constructor(params: Parameters) {
         const billboardGeometry = createBillboardInstancedBufferGeometry();
@@ -50,7 +50,6 @@ class InstancedBillboardBatch {
         this.instanceLocalTransformAttribute = new THREE.InstancedBufferAttribute(new Float32Array(instanceLocalTransformBuffer), 4);
         billboardGeometry.setAttribute('aInstanceLocalTransform', this.instanceLocalTransformAttribute);
 
-        this.instanceCustomAttributes = {};
         for (const [name, definition] of Object.entries(params.customAttributes)) {
             const size = attributeSizes[definition.type];
             if (typeof size === 'undefined') {
@@ -59,10 +58,11 @@ class InstancedBillboardBatch {
 
             const bufferAttribute = new THREE.InstancedBufferAttribute(new Float32Array(size * params.maxInstancesCount), size);
             billboardGeometry.setAttribute(`a_${name}`, bufferAttribute);
-            this.instanceCustomAttributes[name] = { bufferAttribute, size };
+            this.instanceCustomAttributes.set(name, { bufferAttribute, size });
         }
 
         this.mesh = new THREE.InstancedMesh(billboardGeometry, params.billboardMaterial, params.maxInstancesCount);
+        this.mesh.name = 'instanced-billboard-mesh';
         this.mesh.count = 0;
         this.mesh.frustumCulled = false;
         this.mesh.receiveShadow = params.receiveShadows;
@@ -94,7 +94,7 @@ class InstancedBillboardBatch {
     }
 
     public setInstanceCustomAttribute(instanceId: number, name: string, value: ReadonlyArray<number>): void {
-        const customAttribute = this.instanceCustomAttributes[name];
+        const customAttribute = this.instanceCustomAttributes.get(name);
         if (!customAttribute) {
             throw new Error(`Unknown attribute "${name}".`);
         }

src/lib/effects/billboard/instanced-billboard.ts

@@ -40,6 +40,7 @@ class InstancedBillboard {
 
     public constructor(params: Parameters) {
         this.container = new THREE.Group();
+        this.container.name = 'instanced-billboard-container';
 
         this.maxInstancesCount = params.maxInstancesCount ?? Infinity;
 

src/lib/effects/props/props-batch.ts

@@ -184,6 +184,7 @@ class PropsBatch {
         this.groupsDefinitions = new Map();
 
         this.instancedMesh = new THREE.InstancedMesh(params.bufferGeometry, this.material.material, this.maxInstancesCount);
+        this.instancedMesh.name = 'props-batch';
         this.instancedMesh.count = 0;
     }
 

src/lib/effects/props/props-viewer.ts

@@ -3,46 +3,46 @@ import * as THREE from '../../libs/three-usage';
 import { PropsHandler, type Parameters as PropshandlerParameters } from './props-handler';
 
 type Parameters = PropshandlerParameters & {
-    readonly patchSize: THREE.Vector3Like;
+    readonly chunkSize: THREE.Vector3Like;
 };
 
-type PatchId = THREE.Vector3Like;
+type ChunkId = THREE.Vector3Like;
 
-function buildPatchIdString(patchId: PatchId): string {
-    return `${patchId.x}_${patchId.y}_${patchId.z}`;
+function buildChunkIdString(chunkId: ChunkId): string {
+    return `${chunkId.x}_${chunkId.y}_${chunkId.z}`;
 }
 
 class PropsViewer extends PropsHandler {
-    private readonly patchSize: THREE.Vector3Like;
+    private readonly chunkSize: THREE.Vector3Like;
 
     public constructor(params: Parameters) {
         super(params);
 
-        this.patchSize = new THREE.Vector3().copy(params.patchSize);
+        this.chunkSize = new THREE.Vector3().copy(params.chunkSize);
     }
 
-    public setPatchPropsFromLocalMatrices(patchId: THREE.Vector3Like, localMatricesList: ReadonlyArray<THREE.Matrix4>): void {
-        const patchWorldOrigin = new THREE.Vector3().multiplyVectors(patchId, this.patchSize);
-        const patchTransformMatrix = new THREE.Matrix4().makeTranslation(patchWorldOrigin);
+    public setChunkPropsFromLocalMatrices(chunkId: THREE.Vector3Like, localMatricesList: ReadonlyArray<THREE.Matrix4>): void {
+        const chunkWorldOrigin = new THREE.Vector3().multiplyVectors(chunkId, this.chunkSize);
+        const chunkTransformMatrix = new THREE.Matrix4().makeTranslation(chunkWorldOrigin);
         const worldMatricesList = localMatricesList.map(localMatrix =>
-            new THREE.Matrix4().multiplyMatrices(patchTransformMatrix, localMatrix)
+            new THREE.Matrix4().multiplyMatrices(chunkTransformMatrix, localMatrix)
         );
-        this.setPatchPropsFromWorldMatrices(patchId, worldMatricesList);
+        this.setChunkPropsFromWorldMatrices(chunkId, worldMatricesList);
     }
 
-    public setPatchPropsFromWorldMatrices(patchId: THREE.Vector3Like, worldMatricesList: ReadonlyArray<THREE.Matrix4>): void {
-        const patchIdString = buildPatchIdString(patchId);
-        this.setGroup(patchIdString, worldMatricesList);
+    public setChunkPropsFromWorldMatrices(chunkId: THREE.Vector3Like, worldMatricesList: ReadonlyArray<THREE.Matrix4>): void {
+        const chunkIdString = buildChunkIdString(chunkId);
+        this.setGroup(chunkIdString, worldMatricesList);
     }
 
-    public deletePatchProps(patchId: THREE.Vector3Like): void {
-        const patchIdString = buildPatchIdString(patchId);
-        this.deleteGroup(patchIdString);
+    public deleteChunkProps(chunkId: THREE.Vector3Like): void {
+        const chunkIdString = buildChunkIdString(chunkId);
+        this.deleteGroup(chunkIdString);
     }
 
-    public hasPatchProps(patchId: THREE.Vector3Like): boolean {
-        const patchIdString = buildPatchIdString(patchId);
-        return this.hasGroup(patchIdString);
+    public hasChunkProps(chunkId: THREE.Vector3Like): boolean {
+        const chunkIdString = buildChunkIdString(chunkId);
+        return this.hasGroup(chunkIdString);
     }
 }
 

src/lib/effects/weather/rain.ts

@@ -36,6 +36,7 @@ return vec4(0.5, 0.5, 1, 1);
         this.instancedBillboard.initializePositions(renderer);
 
         this.container = new THREE.Group();
+        this.container.name = 'rain-container';
         this.instancedBillboard.container.position.copy(this.instancedBillboard.positionsRange.clone().multiplyScalar(-0.5));
         this.container.add(this.instancedBillboard.container);
     }

src/lib/effects/weather/snow.ts

@@ -39,6 +39,7 @@ return vec4(0.9, 0.9, 1, 1);
         this.instancedBillboard.initializePositions(renderer);
 
         this.container = new THREE.Group();
+        this.container.name = 'snow-container';
         this.instancedBillboard.container.position.copy(this.instancedBillboard.positionsRange.clone().multiplyScalar(-0.5));
         this.container.add(this.instancedBillboard.container);
     }

src/lib/effects/weather/weather-particles-base.ts

@@ -55,6 +55,7 @@ class GpuInstancedBillboard {
 
     public constructor(params: Parameters) {
         this.container = new THREE.Group();
+        this.container.name = 'weather-particles-container';
 
         const textureSize = nextPowerOfTwo(Math.floor(Math.sqrt(params.maxInstancesCount)));
         if (params.maxInstancesCount > textureSize * textureSize) {
@@ -167,6 +168,7 @@ localTransform = mat2(size.x, 0, 0, size.y);`,
         {
             const billboardGeometry = createBillboardInstancedBufferGeometry();
             this.mesh = new THREE.InstancedMesh(billboardGeometry, this.displayPipeline.shader, params.maxInstancesCount);
+            this.mesh.name = 'weather-particles-mesh';
             this.mesh.count = 0;
             this.mesh.frustumCulled = false;
             this.mesh.receiveShadow = params.rendering.shadows.receive;

src/lib/helpers/async/dedicatedWorkers/dedicated-worker.ts

@@ -31,11 +31,11 @@ type TaskResponseMessage =
 
 type RequestMessage = {
     readonly messageId: number;
-    readonly taskRequestMessagesList: ReadonlyArray<TaskRequestMessage>;
+    readonly taskRequestMessagesList: Iterable<TaskRequestMessage>;
 };
 type ResponseMessage = {
     readonly messageId: number;
-    readonly taskResponseMessagesList: ReadonlyArray<TaskResponseMessage>;
+    readonly taskResponseMessagesList: Iterable<TaskResponseMessage>;
 };
 
 type PendingTask = {
@@ -163,7 +163,7 @@ class DedicatedWorker {
         return this.pendingTasks.size;
     }
 
-    private sendTasksToWorker(tasksList: ReadonlyArray<TaskRequestMessage>, transfer: Transferable[]): void {
+    private sendTasksToWorker(tasksList: Iterable<TaskRequestMessage>, transfer: Transferable[]): void {
         if (!this.worker) {
             throw new Error('Worker has been terminated.');
         }

src/lib/helpers/customizable-texture.ts

@@ -17,7 +17,7 @@ class CustomizableTexture {
     public readonly texture: THREE.Texture;
 
     public needsUpdate: boolean = true;
-    public get layerNames(): ReadonlyArray<string> {
+    public get layerNames(): string[] {
         return Array.from(this.layers.keys());
     }
 

src/lib/helpers/disposable-map.ts

@@ -7,24 +7,24 @@ interface IDisposable {
 type Key = string | number;
 
 class DisposableMap<T extends IDisposable> {
-    private store: Record<Key, T> = {};
+    private readonly store = new Map<Key, T>();
     private readonly itemsList = new CachedItem<T[]>(() => Object.values(this.store));
 
     public setItem(id: Key, item: T): void {
         this.deleteItem(id);
-        this.store[id] = item;
+        this.store.set(id, item);
         this.itemsList.invalidate();
     }
 
     public getItem(id: Key): T | null {
-        return this.store[id] || null;
+        return this.store.get(id) || null;
     }
 
     public deleteItem(id: Key): boolean {
-        const item = this.store[id];
+        const item = this.store.get(id);
         if (typeof item !== 'undefined') {
             item.dispose();
-            delete this.store[id];
+            this.store.delete(id);
             this.itemsList.invalidate();
             return true;
         }
@@ -43,7 +43,7 @@ class DisposableMap<T extends IDisposable> {
         for (const item of this.allItems) {
             item.dispose();
         }
-        this.store = {};
+        this.store.clear();
         this.itemsList.invalidate();
     }
 }

src/lib/helpers/fullscreen-quad.ts

@@ -2,9 +2,11 @@ import * as THREE from '../libs/three-usage';
 
 function createFullscreenQuad(attributeName: string): THREE.Mesh {
     const fullscreenQuadGeometry = new THREE.BufferGeometry();
+    fullscreenQuadGeometry.name = 'fullscreen-quad-geometry';
     fullscreenQuadGeometry.setAttribute(attributeName, new THREE.Float32BufferAttribute([0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1], 2));
     fullscreenQuadGeometry.setDrawRange(0, 6);
     const fullscreenQuad = new THREE.Mesh(fullscreenQuadGeometry);
+    fullscreenQuad.name = 'fullscreenq-quad-mesh';
     fullscreenQuad.frustumCulled = false;
     return fullscreenQuad;
 }

src/lib/index.ts

@@ -2,8 +2,9 @@ export { PromisesQueue } from './helpers/async/promises-queue';
 export { ELogLevel, setVerbosity } from './helpers/logger';
 export { HeightmapViewerCpu, type HeightmapViewerCpuStatistics } from './terrain/heightmap/cpu/heightmap-viewer-cpu';
 export { HeightmapViewerGpu, type HeightmapViewerGpuStatistics } from './terrain/heightmap/gpu/heightmap-viewer-gpu';
-export type { IHeightmap, IHeightmapCoords, IHeightmapSample } from './terrain/heightmap/i-heightmap';
+export type { HeightmapSamples, IHeightmap } from './terrain/heightmap/i-heightmap';
 export { type IHeightmapViewer } from './terrain/heightmap/i-heightmap-viewer';
+export { MaterialsStore } from './terrain/materials-store';
 export { TerrainViewer } from './terrain/terrain-viewer';
 export { computeBoard, EBoardSquareType, type Board, type BoardSquare } from './terrain/voxelmap/board/board';
 export { BoardRenderableFactory, type BoardRenderable } from './terrain/voxelmap/board/board-renderable-factory';
@@ -17,18 +18,15 @@ export {
     type VoxelsChunkOrdering,
     type VoxelsChunkSize,
 } from './terrain/voxelmap/i-voxelmap';
-export {
-    VoxelmapViewerAutonomous,
-    type VoxelmapViewerAutonomousOptions,
-} from './terrain/voxelmap/viewer/autonomous/voxelmap-viewer-autonomous';
+export type { IVoxelmapViewer } from './terrain/voxelmap/i-voxelmap-viewer';
 export {
     EComputationMethod,
     EComputationResult,
     VoxelmapViewer,
     type ComputationOptions,
     type VoxelmapViewerOptions,
     type VoxelsChunkData,
-} from './terrain/voxelmap/viewer/simple/voxelmap-viewer';
+} from './terrain/voxelmap/viewer/voxelmap-viewer';
 export { VoxelmapVisibilityComputer } from './terrain/voxelmap/voxelmap-visibility-computer';
 export { EVoxelsDisplayMode } from './terrain/voxelmap/voxelsRenderable/voxels-material';
 export { type CheckerboardType } from './terrain/voxelmap/voxelsRenderable/voxelsRenderableFactory/voxels-renderable-factory-base';