@benjos/create-boilerplate 1.4.0 → 1.5.0

package/template-vanilla/src/experiences/views/htmls/loaders/LoaderHTMLView.ts

@@ -9,9 +9,9 @@ export default class LoaderHTMLView extends HTMLViewBase {
 
     constructor() {
         super();
-        LoaderManager.onBeginLoad.add(this._onBeginLoad);
         LoaderManager.onProgress.add(this._onProgress);
-        LoaderManager.onFinishLoad.add(this._onFinishLoad);
+        LoaderManager.onShow.add(this._onShow);
+        LoaderManager.onHide.add(this._onHide);
     }
 
     protected override _getElement(): void {
@@ -21,20 +21,19 @@ export default class LoaderHTMLView extends HTMLViewBase {
         this._loadingBar = this._htmlElement.querySelector('.loading-bar')!;
     }
 
-    private readonly _onBeginLoad = (): void => {
+    private readonly _onShow = (): void => {
         this._loadingNumber.textContent = '0';
         this._loadingBar.style.transform = '';
         this._loadingBar.classList.remove('ended');
         this.show();
     };
-
-    private _onProgress = (): void => {
-        const progress = Math.min(LoaderManager.loadedSize / LoaderManager.totalSize, 1) * 100;
-        this._loadingBar.style.transform = `translateY(-50%) scaleX(${progress / 100})`;
+    private readonly _onProgress = (): void => {
+        const progress = LoaderManager.progress * 100;
+        this._loadingBar.style.transform = `translateY(-50%) scaleX(${LoaderManager.progress})`;
         this._loadingNumber.textContent = Math.round(progress).toString();
     };
 
-    private readonly _onFinishLoad = (): void => {
+    private readonly _onHide = (): void => {
         this._loadingNumber.textContent = '100';
         this._loadingBar.style.transform = '';
         this._loadingBar.classList.add('ended');

package/template-vanilla/src/experiences/views/threes/bases/ThreeViewBase.ts

@@ -1,26 +1,49 @@
 import { Object3D } from 'three';
-import ActorBase from '../worlds/components/actors/bases/ActorBase';
+import { ViewId } from '../../../constants/experiences/ViewId';
+import ThreeActorBase from '../worlds/components/actors/bases/ThreeActorBase';
 
 export default abstract class ThreeViewBase extends Object3D {
-    protected readonly _actors: ActorBase[];
+    private readonly _id: ViewId;
+    protected readonly _actors: ThreeActorBase[];
+    private _areActorsGenerated = false;
 
-    constructor() {
+    constructor(id: ViewId) {
         super();
-
+        this._id = id;
         this._actors = [];
     }
 
-    protected _generateActors(): void {
+    public declareAssets(): void {
         //
     }
 
+    public init(): void {
+        if (!this._areActorsGenerated) this._generateActors();
+        this.reset();
+        for (const actor of this._actors) actor.init();
+    }
+
+    public reset(): void {
+        for (const actor of this._actors) actor.reset();
+    }
+
+    protected _generateActors(): void {
+        this._areActorsGenerated = true;
+    }
+
     public dispose(): void {
         for (const actor of this._actors) {
             actor.dispose();
         }
     }
 
-    public update(dt: number): void {
+    public update(_dt: number): void {
         //
     }
+
+    //#region Getters
+    //
+    public get viewId(): ViewId { return this._id; }
+    //
+    //#endregion
 }

package/template-vanilla/src/experiences/views/threes/loaders/LoaderThreeView.ts

@@ -1,38 +1,28 @@
-import LoaderManager from '../../../managers/LoaderManager';
+import { ViewId } from '../../../constants/experiences/ViewId';
 import ThreeViewBase from '../bases/ThreeViewBase';
-import ThreeTemplateLoader from './components/ThreeTemplateLoader';
+import TemplateLoaderThreeActor from './components/TemplateLoaderThreeActor';
 
 export default class LoaderThreeView extends ThreeViewBase {
-    declare private _threeLoader: ThreeTemplateLoader;
+    declare private _threeLoader: TemplateLoaderThreeActor;
 
     constructor() {
-        super();
+        super(ViewId.THREE_LOADER);
         this._generateActors();
-        LoaderManager.onBeginLoad.add(this._onBeginLoad);
-        LoaderManager.onFinishLoad.add(this._onFinishLoad);
     }
 
     protected override _generateActors(): void {
         super._generateActors();
-        this._threeLoader = new ThreeTemplateLoader();
+        this._threeLoader = new TemplateLoaderThreeActor();
         this._actors.push(this._threeLoader);
 
         for (const actor of this._actors) this.add(actor);
     }
 
-    protected _show(): void {
-        this._threeLoader.material.show();
-    }
-
-    protected _hide(): void {
-        this._threeLoader.material.hide();
-    }
-
-    private readonly _onBeginLoad = (): void => {
-        this._show();
+    public readonly show = (): Promise<void> => {
+        return this._threeLoader.material.show();
     };
 
-    private readonly _onFinishLoad = (): void => {
-        this._hide();
+    public readonly hide = (): Promise<void> => {
+        return this._threeLoader.material.hide();
     };
 }

package/template-vanilla/src/experiences/views/threes/loaders/components/{ThreeTemplateLoader.ts → TemplateLoaderThreeActor.ts}

@@ -1,8 +1,8 @@
 import { Mesh, PlaneGeometry } from 'three';
 import LoaderMaterial from '../../../../materials/threes/loaders/LoaderMaterial';
-import ActorBase from '../../worlds/components/actors/bases/ActorBase';
+import ThreeActorBase from '../../worlds/components/actors/bases/ThreeActorBase';
 
-export default class ThreeTemplateLoader extends ActorBase {
+export default class TemplateLoaderThreeActor extends ThreeActorBase {
     private static readonly _DEFAULT_SIZE_WIDTH: number = 2;
     private static readonly _DEFAULT_SIZE_HEIGHT: number = 2;
     private static readonly _DEFAULT_SEGMENTS_WIDTH: number = 1;
@@ -24,10 +24,10 @@ export default class ThreeTemplateLoader extends ActorBase {
 
     private _generateGeometry(): void {
         this._geometry = new PlaneGeometry(
-            ThreeTemplateLoader._DEFAULT_SIZE_WIDTH,
-            ThreeTemplateLoader._DEFAULT_SIZE_HEIGHT,
-            ThreeTemplateLoader._DEFAULT_SEGMENTS_WIDTH,
-            ThreeTemplateLoader._DEFAULT_SEGMENTS_HEIGHT
+            TemplateLoaderThreeActor._DEFAULT_SIZE_WIDTH,
+            TemplateLoaderThreeActor._DEFAULT_SIZE_HEIGHT,
+            TemplateLoaderThreeActor._DEFAULT_SEGMENTS_WIDTH,
+            TemplateLoaderThreeActor._DEFAULT_SEGMENTS_HEIGHT
         );
     }
 
@@ -39,12 +39,6 @@ export default class ThreeTemplateLoader extends ActorBase {
         this._mesh = new Mesh(this._geometry, this._material);
     }
 
-    public override dispose(): void {
-        super.dispose();
-        this._geometry.dispose();
-        this._material.dispose();
-    }
-
     //#region Getters
     //
     public get material(): LoaderMaterial {

package/template-vanilla/src/experiences/views/threes/worlds/World2ThreeView.ts

@@ -0,0 +1,35 @@
+import { DebugGuiTitle } from '../../../constants/experiences/DebugGuiTitle';
+import { ViewId } from '../../../constants/experiences/ViewId';
+import MainThreeApp from '../../../engines/threes/app/MainThreeApp';
+import DebugManager from '../../../managers/DebugManager';
+import ThreeViewBase from '../bases/ThreeViewBase';
+import Environment from './components/Environment';
+import TemplateFont from './components/actors/TemplateFont';
+import TemplateMesh2 from './components/actors/TemplateMesh2';
+import TemplateModel from './components/actors/TemplateModel';
+
+export default class World2ThreeView extends ThreeViewBase {
+    constructor() {
+        super(ViewId.THREE_VIEW_WORLD_2);
+    }
+
+    protected override _generateActors(): void {
+        super._generateActors();
+
+        if (DebugManager.isActive) {
+            const viewsDebug = DebugManager.getGuiFolder(DebugGuiTitle.THREE_VIEWS)
+            viewsDebug.add({ switchToWorld2ThreeView: () => MainThreeApp.setCurrentView(ViewId.THREE_VIEW_WORLD_2) }, 'switchToWorld2ThreeView').name('SWITCH WORLD_2_VIEW');
+        }
+
+        this._actors.push(new Environment());
+        this._actors.push(new TemplateMesh2());
+        this._actors.push(new TemplateModel());
+        this._actors.push(new TemplateFont());
+
+        for (const actor of this._actors) this.add(actor);
+    }
+
+    public override update(dt: number): void {
+        for (const actor of this._actors) actor.update(dt);
+    }
+}

package/template-vanilla/src/experiences/views/threes/worlds/WorldThreeView.ts

@@ -1,4 +1,7 @@
-import LoaderManager from '../../../managers/LoaderManager';
+import { DebugGuiTitle } from '../../../constants/experiences/DebugGuiTitle';
+import { ViewId } from '../../../constants/experiences/ViewId';
+import MainThreeApp from '../../../engines/threes/app/MainThreeApp';
+import DebugManager from '../../../managers/DebugManager';
 import ThreeViewBase from '../bases/ThreeViewBase';
 import Environment from './components/Environment';
 import TemplateFont from './components/actors/TemplateFont';
@@ -6,27 +9,19 @@ import TemplateMesh from './components/actors/TemplateMesh';
 import TemplateModel from './components/actors/TemplateModel';
 
 export default class WorldThreeView extends ThreeViewBase {
-    declare private _environment: Environment;
-
     constructor() {
-        super();
-        LoaderManager.onFinishLoad.add(this._onFinishLoad);
-    }
-
-    private readonly _onFinishLoad = (): void => {
-        this._generateEnvironment();
-        this._generateActors();
-        LoaderManager.onFinishLoad.remove(this._onFinishLoad);
-    };
-
-    private _generateEnvironment(): void {
-        this._environment = new Environment();
-
-        this.add(this._environment);
+        super(ViewId.THREE_VIEW_WORLD_1);
     }
 
     protected override _generateActors(): void {
         super._generateActors();
+
+        if (DebugManager.isActive) {
+            const viewsDebug = DebugManager.getGuiFolder(DebugGuiTitle.THREE_VIEWS)
+            viewsDebug.add({ switchToWorldThreeView: () => MainThreeApp.setCurrentView(ViewId.THREE_VIEW_WORLD_1) }, 'switchToWorldThreeView').name('SWITCH WORLD_1_VIEW');
+        }
+
+        this._actors.push(new Environment());
         this._actors.push(new TemplateMesh());
         this._actors.push(new TemplateModel());
         this._actors.push(new TemplateFont());
@@ -35,9 +30,6 @@ export default class WorldThreeView extends ThreeViewBase {
     }
 
     public override update(dt: number): void {
-        if (!this._environment) return;
-
-        this._environment.update(dt);
         for (const actor of this._actors) actor.update(dt);
     }
 }

package/template-vanilla/src/experiences/views/threes/worlds/components/Environment.ts

@@ -1,15 +1,17 @@
-import { DataTexture, DirectionalLight, Object3D, Vector3 } from 'three';
+import { DataTexture, DirectionalLight, Vector3 } from 'three';
 import { AssetId } from '../../../../constants/experiences/AssetId';
-import MainThree from '../../../../engines/threes/MainThree';
+import { DebugGuiTitle } from '../../../../constants/experiences/DebugGuiTitle';
+import MainThreeApp from '../../../../engines/threes/app/MainThreeApp';
 import DebugManager from '../../../../managers/DebugManager';
 import ThreeAssetsManager from '../../../../managers/threes/ThreeAssetsManager';
+import ThreeActorBase from './actors/bases/ThreeActorBase';
 
 interface EnvironmentMap {
     intensity?: number;
     texture?: DataTexture;
 }
 
-export default class Environment extends Object3D {
+export default class Environment extends ThreeActorBase {
     private static readonly _DEFAULT_ENVIRONMENT_MAP_INTENSITY: number = 1;
     private static readonly _DEFAULT_SUN_LIGHT_COLOR: number = 0xffffff;
     private static readonly _DEFAULT_SUN_LIGHT_INTENSITY: number = 10;
@@ -28,19 +30,32 @@ export default class Environment extends Object3D {
         this._generateSunLight();
     }
 
+    public init(): void {
+        this.reset();
+        if (this._environmentMap) {
+            MainThreeApp.scene.environment = this._environmentMap.texture!;
+            MainThreeApp.scene.environmentIntensity = this._environmentMap.intensity!;
+        }
+    }
+
+    public reset(): void {
+        //
+    }
+
     private _generateEnvironmentMap = (): void => {
         this._environmentMap = {};
         this._environmentMap.intensity = Environment._DEFAULT_ENVIRONMENT_MAP_INTENSITY;
         this._environmentMap.texture = ThreeAssetsManager.getHDR(AssetId.THREE_HDR_TEMPLATE);
         this._environmentMap.texture.needsUpdate = true;
 
-        MainThree.scene.environment = this._environmentMap.texture;
-        MainThree.scene.environmentIntensity = this._environmentMap.intensity!;
+        MainThreeApp.scene.environment = this._environmentMap.texture;
+        MainThreeApp.scene.environmentIntensity = this._environmentMap.intensity!;
 
         if (DebugManager.isActive) {
-            const environmentFolder = DebugManager.gui.addFolder('Environment');
+            const viewsDebug = DebugManager.getGuiFolder(DebugGuiTitle.THREE_VIEWS)
+            const environmentFolder = viewsDebug.addFolder('Environment');
             environmentFolder.add(this._environmentMap, 'intensity', 0, 10, 0.01).onChange(() => {
-                MainThree.scene.environmentIntensity = this._environmentMap.intensity!;
+                MainThreeApp.scene.environmentIntensity = this._environmentMap.intensity!;
             });
         }
     };
@@ -61,7 +76,8 @@ export default class Environment extends Object3D {
         this.add(this._sunLight);
 
         if (DebugManager.isActive) {
-            const sunLightFolder = DebugManager.gui.addFolder('Sun Light');
+            const viewsDebug = DebugManager.getGuiFolder(DebugGuiTitle.THREE_VIEWS)
+            const sunLightFolder = viewsDebug.addFolder('Sun Light');
             sunLightFolder.add(this._sunLight, 'intensity', 0, 10, 0.01).name('intensity');
             sunLightFolder.add(this._sunLight.position, 'x', -5, 5, 0.01).name('positionX');
             sunLightFolder.add(this._sunLight.position, 'y', -5, 5, 0.01).name('positionY');
@@ -69,5 +85,5 @@ export default class Environment extends Object3D {
         }
     }
 
-    public update(_dt: number): void {}
+    public update(_dt: number): void { }
 }

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/TemplateFont.ts

@@ -2,9 +2,9 @@ import { Mesh, MeshStandardMaterial, type MeshStandardMaterialParameters } from
 import { TextGeometry, type TextGeometryParameters } from 'three/examples/jsm/Addons.js';
 import { AssetId } from '../../../../../constants/experiences/AssetId';
 import ThreeAssetsManager from '../../../../../managers/threes/ThreeAssetsManager';
-import ActorBase from './bases/ActorBase';
+import ThreeActorBase from './bases/ThreeActorBase';
 
-export default class TemplateFont extends ActorBase {
+export default class TemplateFont extends ThreeActorBase {
     private static readonly _DEFAULT_TEXT: string = 'Hello boilerplate!';
     private static readonly _DEFAULT_TEXT_OPTION: TextGeometryParameters = {
         font: null!,
@@ -55,10 +55,4 @@ export default class TemplateFont extends ActorBase {
 
         this.add(this._mesh);
     }
-
-    public override dispose(): void {
-        super.dispose();
-        this._geometry.dispose();
-        this._material.dispose();
-    }
 }

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/TemplateMesh.ts

@@ -1,9 +1,9 @@
 import { Mesh, MeshStandardMaterial, RepeatWrapping, SphereGeometry, type MeshStandardMaterialParameters } from 'three';
 import { AssetId } from '../../../../../constants/experiences/AssetId';
 import ThreeAssetsManager from '../../../../../managers/threes/ThreeAssetsManager';
-import ActorBase from './bases/ActorBase';
+import ThreeActorBase from './bases/ThreeActorBase';
 
-export default class TemplateMesh extends ActorBase {
+export default class TemplateMesh extends ThreeActorBase {
     private static readonly _DEFAULT_GEOMETRY_RADIUS = 1;
     private static readonly _DEFAULT_GEOMETRY_WIDTH_SEGMENTS = 64;
     private static readonly _DEFAULT_GEOMETRY_HEIGHT_SEGMENTS = 64;
@@ -54,10 +54,8 @@ export default class TemplateMesh extends ActorBase {
         this.add(this._mesh);
     }
 
-    public override dispose(): void {
-        super.dispose();
-        this._geometry.dispose();
-        this._material.dispose();
+    public override reset(): void {
+        this._mesh.rotation.y = 0;
     }
 
     public update(dt: number): void {

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/TemplateMesh2.ts

@@ -0,0 +1,71 @@
+import { BoxGeometry, Mesh, MeshStandardMaterial, RepeatWrapping, type MeshStandardMaterialParameters } from 'three';
+import { AssetId } from '../../../../../constants/experiences/AssetId';
+import ThreeAssetsManager from '../../../../../managers/threes/ThreeAssetsManager';
+import ThreeActorBase from './bases/ThreeActorBase';
+
+export default class TemplateMesh2 extends ThreeActorBase {
+    private static readonly _DEFAULT_GEOMETRY_WIDTH = 2;
+    private static readonly _DEFAULT_GEOMETRY_HEIGHT = 2;
+    private static readonly _DEFAULT_GEOMETRY_DEPTH = 2;
+    private static readonly _DEFAULT_GEOMETRY_WIDTH_SEGMENTS = 1;
+    private static readonly _DEFAULT_GEOMETRY_HEIGHT_SEGMENTS = 1;
+    private static readonly _DEFAULT_GEOMETRY_DEPTH_SEGMENTS = 1;
+    private static readonly _DEFAULT_MATERIAL_REPEAT = 1.5;
+    private static readonly _DEFAULT_MATERIAL_OPTIONS: MeshStandardMaterialParameters = {
+        color: 0xffffff,
+        metalness: 0.7,
+        roughness: 0.2,
+        envMapIntensity: 0,
+    };
+    private static readonly _MESH_ROTATION_Y = 0.25;
+
+    declare private _geometry: BoxGeometry;
+    declare private _material: MeshStandardMaterial;
+    declare private _mesh: Mesh;
+
+    constructor() {
+        super();
+
+        this._generateGeometry();
+        this._generateMaterial();
+        this._generateMesh();
+    }
+
+    private _generateGeometry(): void {
+        this._geometry = new BoxGeometry(
+            TemplateMesh2._DEFAULT_GEOMETRY_WIDTH,
+            TemplateMesh2._DEFAULT_GEOMETRY_HEIGHT,
+            TemplateMesh2._DEFAULT_GEOMETRY_DEPTH,
+            TemplateMesh2._DEFAULT_GEOMETRY_WIDTH_SEGMENTS,
+            TemplateMesh2._DEFAULT_GEOMETRY_HEIGHT_SEGMENTS,
+            TemplateMesh2._DEFAULT_GEOMETRY_DEPTH_SEGMENTS
+        );
+    }
+
+    private _generateMaterial(): void {
+        const normalMat = ThreeAssetsManager.getTexture(AssetId.THREE_TEXTURE_TEMPLATE);
+        normalMat.repeat.set(TemplateMesh2._DEFAULT_MATERIAL_REPEAT, TemplateMesh2._DEFAULT_MATERIAL_REPEAT);
+        normalMat.wrapS = normalMat.wrapT = RepeatWrapping;
+
+        this._material = new MeshStandardMaterial({
+            ...TemplateMesh2._DEFAULT_MATERIAL_OPTIONS,
+            normalMap: normalMat,
+        });
+    }
+
+    private _generateMesh(): void {
+        this._mesh = new Mesh(this._geometry, this._material);
+        this._mesh.castShadow = true;
+        this._mesh.receiveShadow = true;
+        this.add(this._mesh);
+    }
+
+    public override reset(): void {
+        this._mesh.rotation.y = 0;
+    }
+
+    public update(dt: number): void {
+        super.update(dt);
+        this._mesh.rotation.y += dt * TemplateMesh2._MESH_ROTATION_Y;
+    }
+}

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/TemplateModel.ts

@@ -1,9 +1,10 @@
 import { Vector3 } from 'three';
 import { AssetId } from '../../../../../constants/experiences/AssetId';
+import { DebugGuiTitle } from '../../../../../constants/experiences/DebugGuiTitle';
 import DebugManager from '../../../../../managers/DebugManager';
-import ModelBase from './bases/ModelBase';
+import ThreeModelBase from './bases/ThreeModelBase';
 
-export default class TemplateModel extends ModelBase {
+export default class TemplateModel extends ThreeModelBase {
     private static readonly _DEFAULT_POSITION: Vector3 = new Vector3(0, 1, 0);
     private static readonly _ROTATION_Y = 0.25;
 
@@ -15,11 +16,16 @@ export default class TemplateModel extends ModelBase {
         this.position.copy(TemplateModel._DEFAULT_POSITION);
 
         if (DebugManager.isActive) {
-            const templateModelFolder = DebugManager.gui.addFolder('Template Model');
+            const viewsDebug = DebugManager.getGuiFolder(DebugGuiTitle.THREE_VIEWS)
+            const templateModelFolder = viewsDebug.addFolder('Template Model');
             templateModelFolder.add(this.position, 'y', -1, 1, 0.01);
         }
     }
 
+    public override reset(): void {
+        this.rotation.y = 0;
+    }
+
     public update(dt: number): void {
         super.update(dt);
         this.rotation.y += dt * TemplateModel._ROTATION_Y;

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/bases/ThreeActorBase.ts

@@ -0,0 +1,44 @@
+import { BufferGeometry, Material, Mesh, Object3D, Texture } from 'three';
+
+export default abstract class ThreeActorBase extends Object3D {
+    constructor() {
+        super();
+    }
+
+    public init(): void {
+        this.reset();
+    }
+
+    public reset(): void {
+        //
+    }
+
+    public dispose(): void {
+        const geometries = new Set<BufferGeometry>();
+        const materials = new Set<Material>();
+        const textures = new Set<Texture>();
+
+        this.traverse((child) => {
+            if (child instanceof Mesh) {
+                if (child.geometry instanceof BufferGeometry) geometries.add(child.geometry as BufferGeometry);
+
+                const mats = Array.isArray(child.material) ? child.material : [child.material];
+                mats.forEach((mat) => {
+                    if (mat instanceof Material) {
+                        materials.add(mat);
+
+                        Object.values(mat).forEach((value) => {
+                            if (value instanceof Texture) textures.add(value);
+                        });
+                    }
+                });
+            }
+        });
+
+        textures.forEach((tex) => tex.dispose());
+        materials.forEach((mat) => mat.dispose());
+        geometries.forEach((geo) => geo.dispose());
+    }
+
+    public update(_dt: number): void { }
+}

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/bases/{AnimatedModelBase.ts → ThreeAnimatedModelBase.ts}

@@ -2,9 +2,9 @@ import { AnimationAction, AnimationMixer } from 'three';
 import type { AnimationId } from '../../../../../../constants/experiences/AnimationId';
 import type { AssetId } from '../../../../../../constants/experiences/AssetId';
 import ThreeAssetsManager from '../../../../../../managers/threes/ThreeAssetsManager';
-import ModelBase, { type ModelBaseParams } from './ModelBase';
+import ThreeModelBase, { type ModelBaseParams } from './ThreeModelBase';
 
-export default abstract class AnimatedModelBase extends ModelBase {
+export default abstract class ThreeAnimatedModelBase extends ThreeModelBase {
     private static readonly _DEFAULT_ANIMATION_FADE_DURATION: number = 1;
 
     declare private _mixer: AnimationMixer;
@@ -35,7 +35,7 @@ export default abstract class AnimatedModelBase extends ModelBase {
 
     protected _playAnimation = (
         animationId: AnimationId,
-        fadeDuration: number = AnimatedModelBase._DEFAULT_ANIMATION_FADE_DURATION
+        fadeDuration: number = ThreeAnimatedModelBase._DEFAULT_ANIMATION_FADE_DURATION
     ): void => {
         if (!this._actions) return;
         const newAction = this._getAnimationAction(animationId);

package/template-vanilla/src/experiences/views/threes/worlds/components/actors/bases/{ModelBase.ts → ThreeModelBase.ts}

@@ -3,7 +3,7 @@ import { SkeletonUtils } from 'three/examples/jsm/Addons.js';
 import type { AssetId } from '../../../../../../constants/experiences/AssetId';
 import type { Object3DId } from '../../../../../../constants/experiences/Object3dId';
 import ThreeAssetsManager from '../../../../../../managers/threes/ThreeAssetsManager';
-import ActorBase from './ActorBase';
+import ThreeActorBase from './ThreeActorBase';
 
 export interface ModelBaseParams {
     object3DId?: Object3DId;
@@ -11,7 +11,7 @@ export interface ModelBaseParams {
     receiveShadow?: boolean;
 }
 
-export default abstract class ModelBase extends ActorBase {
+export default abstract class ThreeModelBase extends ThreeActorBase {
     protected _assetId: AssetId;
     protected _parameters: ModelBaseParams;
     declare protected _model: Group | Object3D | Mesh;
@@ -42,20 +42,6 @@ export default abstract class ModelBase extends ActorBase {
         this.add(this._model);
     }
 
-    public override dispose(): void {
-        super.dispose();
-        this._model.traverse((child) => {
-            if (child instanceof Mesh) {
-                child.geometry.dispose();
-                if (Array.isArray(child.material)) {
-                    child.material.forEach((material) => material.dispose());
-                } else {
-                    child.material.dispose();
-                }
-            }
-        });
-    }
-
     public update(dt: number): void {
         super.update(dt);
     }

package/template-vanilla/tsconfig.json

@@ -4,14 +4,9 @@
         "module": "ESNext",
         "moduleResolution": "Node",
         "strict": true,
-        "lib": [
-            "DOM",
-            "ES2020"
-        ],
+        "lib": ["DOM", "ES2020"],
         "skipLibCheck": true,
         "noEmit": true
     },
-    "include": [
-        "src"
-    ]
-}
+    "include": ["src"]
+}

package/template-vanilla/src/experiences/engines/threes/LoaderThree.ts

@@ -1,39 +0,0 @@
-import { DomUtils } from '@benjos/cookware';
-import { Scene } from 'three';
-import LoaderThreeCameraController from '../../cameras/threes/LoaderThreeCameraController';
-import { CameraId } from '../../constants/experiences/CameraId';
-import ThreeCameraControllerManager from '../../managers/threes/ThreeCameraControllerManager';
-import LoaderRenderer from '../../renderers/threes/LoaderRenderer';
-import LoaderThreeView from '../../views/threes/loaders/LoaderThreeView';
-import ThreeBase from './bases/ThreeBase';
-
-class LoaderThree extends ThreeBase {
-    constructor() {
-        super(DomUtils.GetLoader());
-    }
-
-    protected override _generateScenes(): void {
-        this._scene = new Scene();
-    }
-
-    protected override _generateCameras(): void {
-        ThreeCameraControllerManager.add(new LoaderThreeCameraController());
-        this._cameraController = ThreeCameraControllerManager.get(CameraId.THREE_LOADER);
-    }
-
-    protected override _generateRenderers(): void {
-        this._renderer = new LoaderRenderer(
-            this._scene,
-            ThreeCameraControllerManager.get(CameraId.THREE_LOADER).camera
-        );
-        this._domElementContainer.appendChild(this._renderer.domElement);
-    }
-
-    protected override _generateViews(): void {
-        const loaderThreeView = new LoaderThreeView();
-        this._views.push(loaderThreeView);
-        this._setCurrentView(loaderThreeView);
-    }
-}
-
-export default new LoaderThree();