ohzi-core 13.3.0 → 15.0.0

package/src/materials/deferred/depth_normal_encoding.ts

@@ -0,0 +1,36 @@
+import { dot, float, fract, Fn, vec2, vec3 } from 'three/tsl';
+import type { Node } from 'three/webgpu';
+
+// Packing shared by DepthAndNormalsRenderer and its consumers: depth01 goes in RG,
+// the view space normal in BA. Each value spreads over two 8 bit channels.
+
+const NORMAL_SCALE = 1.7777;
+
+// Splits a [0, 1) float over two channels. 1.0 itself wraps around to 0.
+const encode_float_rg = Fn(([value]: [Node<'float'>]) =>
+{
+  const encoded = fract(vec2(1, 255).mul(value));
+
+  return vec2(encoded.x.sub(encoded.y.div(255)), encoded.y);
+});
+
+const decode_float_rg = Fn(([encoded]: [Node<'vec2'>]) =>
+{
+  return dot(encoded, vec2(1, 1 / 255));
+});
+
+// Stereographic projection of a unit normal onto two channels.
+const encode_normal = Fn(([normal]: [Node<'vec3'>]) =>
+{
+  return normal.xy.div(normal.z.add(1)).div(NORMAL_SCALE).mul(0.5).add(0.5);
+});
+
+const decode_normal = Fn(([encoded]: [Node<'vec2'>]) =>
+{
+  const projected = vec3(encoded.mul(2 * NORMAL_SCALE).sub(NORMAL_SCALE), 1);
+  const g = float(2).div(dot(projected, projected));
+
+  return vec3(projected.xy.mul(g), g.sub(1));
+});
+
+export { decode_float_rg, decode_normal, encode_float_rg, encode_normal };

package/src/primitives/Cube.ts

@@ -6,7 +6,7 @@ class Cube extends Mesh
   {
     size     = size || new Vector3(1, 1, 1);
     segments = segments || new Vector3(1, 1, 1);
-    color    = color || 0xff0000;
+    color    = color ?? 0xff0000;
 
     const geometry = new BoxGeometry(size.x, size.y, size.z, segments.x, segments.y, segments.z);
     const material = new MeshBasicMaterial({ color: color });

package/src/primitives/Sphere.ts

@@ -9,7 +9,7 @@ class Sphere extends Mesh
 
   constructor(radius: number, color: number | string)
   {
-    color = color || '#FF0000';
+    color = color ?? '#FF0000';
     radius = radius || 1;
     const geometry = new SphereGeometry(radius, 64, 64);
     const material = new MeshBasicMaterial({ color: color });

package/src/raycast/GroupRaycaster.ts

@@ -3,7 +3,7 @@ import type { Input } from '../lib/Input';
 import { RaycastResolver } from './RaycastResolver';
 import { IdleState } from './states/IdleState';
 
-import type { Camera, Intersection, Object3D } from 'three';
+import type { Camera, Intersection, Object3D, Vector2 } from 'three';
 import { Raycaster } from 'three';
 import type { BaseState } from './states/BaseState';
 
@@ -36,7 +36,7 @@ class GroupRaycaster
 
   update()
   {
-    this.raycaster.setFromCamera(this.input.NDC, this.camera);
+    this.raycaster.setFromCamera(this.input.NDC as Vector2, this.camera);
     this.current_intersections = this.raycaster.intersectObjects(this.raycastee_group);
     this.current_state.update(this);
   }

package/src/render_mode/BloomRender.ts

@@ -7,19 +7,25 @@ import { CameraManager } from '../CameraManager';
 import { Graphics } from '../Graphics';
 import { OScreen } from '../OScreen';
 import { Blurrer } from '../render_utilities/Blurrer';
+import { DualFilteringBlurrer } from '../render_utilities/DualFilteringBlurrer';
 import { SceneManager } from '../SceneManager';
 
 class BloomRender extends BaseRender
 {
   bloom_compose_mat: BloomComposeMaterial;
   blur_RT: RenderTarget;
-  blurrer: Blurrer;
+  blurrer: Blurrer | DualFilteringBlurrer;
   main_RT: RenderTarget;
+  use_dual_filtering: boolean;
 
-  constructor()
+  // use_dual_filtering swaps the box blur for the dual filtering (Kawase) blur, which
+  // spreads the glow much wider.
+  constructor(use_dual_filtering = false)
   {
     super();
 
+    this.use_dual_filtering = use_dual_filtering;
+
     this.bloom_compose_mat = new BloomComposeMaterial();
     // @ts-expect-error -- DEBUG --
     window.bloom_mat = this.bloom_compose_mat;
@@ -31,12 +37,20 @@ class BloomRender extends BaseRender
 
   on_enter()
   {
-    this.blurrer = new Blurrer();
-    // this.blurrer = new DualFilteringBlurrer()
+    this.blurrer = this.use_dual_filtering ? new DualFilteringBlurrer() : new Blurrer();
     this.main_RT = new RenderTarget(OScreen.width, OScreen.height);
     this.blur_RT = new RenderTarget(OScreen.width, OScreen.height);
   }
 
+  // Frees what on_enter built. Render modes are often built once per switch and then
+  // dropped, so anything kept past on_exit stays on the GPU.
+  on_exit()
+  {
+    this.blurrer.dispose();
+    this.main_RT.dispose();
+    this.blur_RT.dispose();
+  }
+
   render()
   {
     this.__check_RT_size();

package/src/render_mode/DebugNormalsRender.ts

@@ -6,16 +6,21 @@ import { NormalMaterial } from '../materials/NormalMaterial';
 
 class DebugNormalsRender extends BaseRender
 {
+  normal_material: NormalMaterial;
+
   constructor()
   {
     super();
+
+    // Built once: node materials compile per instance, so a new one per frame recompiles every frame.
+    this.normal_material = new NormalMaterial();
   }
 
   render()
   {
     Graphics.clear(undefined, CameraManager.current, true, true);
 
-    Graphics.render(SceneManager.current, CameraManager.current, undefined, new NormalMaterial());
+    Graphics.render(SceneManager.current, CameraManager.current, undefined, this.normal_material);
   }
 }
 

package/src/render_mode/DeferredRender.ts

@@ -2,7 +2,6 @@ import { CameraManager } from '../CameraManager';
 import { Graphics } from '../Graphics';
 import { OScreen } from '../OScreen';
 import { SceneManager } from '../SceneManager';
-import { DeferredRendererComposeMaterial } from '../materials/DeferredRendererComposeMaterial';
 import { DeferredPointLightMaterial } from '../materials/deferred/DeferredPointLightMaterial';
 import { BaseRender } from '../render_mode/BaseRender';
 
@@ -12,7 +11,6 @@ import { AbstractScene } from '../scenes/AbstractScene';
 class DeferredRender extends BaseRender
 {
   camera_inverse_proj_mat: Matrix4;
-  compose_mat: DeferredRendererComposeMaterial;
   main_rt: RenderTarget;
   scene_lights: AbstractScene;
 
@@ -20,11 +18,7 @@ class DeferredRender extends BaseRender
   {
     super();
 
-    this.compose_mat = new DeferredRendererComposeMaterial();
-    this.main_rt = new RenderTarget(OScreen.width, OScreen.height, {
-      // magFilter: NearestFilter,
-      // minFilter: NearestFilter
-    });
+    this.main_rt = new RenderTarget(OScreen.width, OScreen.height);
 
     this.scene_lights = new AbstractScene({ name: 'lights_scene', compilators: {} });
 
@@ -32,24 +26,6 @@ class DeferredRender extends BaseRender
     const light_brightest_component = 1;
     const radius_needed_for_intensity = Math.sqrt(4 * light_intensity * (light_brightest_component * (256.0 / 5.0))) / (2 * light_intensity);
     const sphere = new Mesh(new SphereGeometry(radius_needed_for_intensity), new DeferredPointLightMaterial(light_intensity));
-    // sphere.position.y = 2;
-    // this.scene_lights.add(sphere);
-
-    // let sphere2 = sphere.clone();
-    // sphere2.position.x = 2;
-    // this.scene_lights.add(sphere2);
-
-    // let sphere3 = sphere.clone();
-    // sphere3.position.x = -2;
-    // this.scene_lights.add(sphere3);
-
-    // let sphere4 = sphere.clone();
-    // sphere4.position.z = -2;
-    // this.scene_lights.add(sphere4);
-
-    // let sphere5 = sphere.clone();
-    // sphere5.position.z = 2;
-    // this.scene_lights.add(sphere5);
 
     const light_row = 2;
     const light_col = 2;
@@ -79,18 +55,14 @@ class DeferredRender extends BaseRender
 
     Graphics.render(SceneManager.current, CameraManager.current, this.main_rt);
 
-    // this.compose_mat.set_normal_depth_rt(Graphics.depth_normals_RT);
-    // this.compose_mat.set_proj_matrix(CameraManager.current.projectionMatrix);
-
-    // Graphics.blit(this.main_rt, undefined, this.compose_mat);
-
-    this.camera_inverse_proj_mat = CameraManager.current.projectionMatrix.clone().invert()
+    this.camera_inverse_proj_mat.copy(CameraManager.current.projectionMatrix).invert();
 
     const inverse_proj = this.camera_inverse_proj_mat;
     const albedo_rt = this.main_rt;
     const depth_normals_rt = Graphics.depth_normals_RT;
 
-    this.scene_lights.traverse((child: Mesh) => {
+    this.scene_lights.traverse((child: Mesh) =>
+    {
       if (child.material)
       {
         (child.material as DeferredPointLightMaterial).set_inverse_proj_matrix(inverse_proj);
@@ -98,8 +70,7 @@ class DeferredRender extends BaseRender
         (child.material as DeferredPointLightMaterial).set_albedo_rt(albedo_rt);
       }
     });
-    // Graphics.clear(undefined, CameraManager.current, true, true);
-    // Graphics.render(SceneManager.current, CameraManager.current);
+
     Graphics.clear(undefined, CameraManager.current, true, true);
     Graphics.render(this.scene_lights, CameraManager.current);
   }

package/src/render_mode/NormalAORender.ts

@@ -1,6 +1,5 @@
 import { CameraManager } from '../CameraManager';
 import { Graphics } from '../Graphics';
-import { DisplayNormalTextureMaterial } from '../materials/DisplayNormalTextureMaterial';
 import { SSAOComposeMaterial } from '../materials/SSAOComposeMaterial';
 import { SSAOMaterial } from '../materials/SSAOMaterial';
 import { OScreen } from '../OScreen';
@@ -14,19 +13,19 @@ class NormalAORender extends BaseRender
 {
   SSAO_RT: RenderTarget;
   blurrer: Blurrer;
-  debug_normals: DisplayNormalTextureMaterial;
   main_RT: RenderTarget;
   ssaa: number;
   ssao_compose_mat: SSAOComposeMaterial;
   ssao_mat: SSAOMaterial;
 
-  constructor(use_ssaa = false)
+  // Turning use_exact_depth off swaps the SSAO pass's banding free depth reads for one
+  // filtered fetch per sample, which roughly halves the pass's cost. See SSAOMaterial.
+  constructor(use_ssaa = false, use_exact_depth = true)
   {
     super();
 
-    this.ssao_mat = new SSAOMaterial();
+    this.ssao_mat = new SSAOMaterial(use_exact_depth);
     this.ssao_compose_mat = new SSAOComposeMaterial();
-    this.debug_normals = new DisplayNormalTextureMaterial();
 
     this.ssaa = use_ssaa ? 2 : 1;
 
@@ -34,6 +33,10 @@ class NormalAORender extends BaseRender
     this.SSAO_RT = new RenderTarget(OScreen.width, OScreen.height);
 
     this.blurrer = new Blurrer();
+  }
+
+  on_enter()
+  {
     Graphics.generate_depth_normal_texture = true;
   }
 
@@ -44,26 +47,13 @@ class NormalAORender extends BaseRender
     Graphics.clear(this.main_RT, CameraManager.current, true, false);
     Graphics.render(SceneManager.current, CameraManager.current, this.main_RT);
 
-    this.__update_uniforms();
-
+    this.ssao_mat.set_projection_matrix(CameraManager.current.projectionMatrix);
     Graphics.blit(Graphics.depth_normals_RT, this.SSAO_RT, this.ssao_mat);
 
-    // // BLUR
     this.blurrer.blur(this.SSAO_RT);
-    Graphics.blit(this.SSAO_RT, undefined);
 
-    // // COMPOSE
     this.ssao_compose_mat.uniforms._AO.value = this.SSAO_RT.texture;
     Graphics.blit(this.main_RT, undefined, this.ssao_compose_mat);
-
-    // Graphics.blit(this.SSAO_RT, undefined);
-  }
-
-  __update_uniforms()
-  {
-    this.ssao_mat.uniforms._InverseProjMatrix.value = CameraManager.current.projectionMatrix.clone().invert();
-    this.ssao_mat.uniforms._ProjectionMatrix.value = CameraManager.current.projectionMatrix.clone();
-    this.ssao_mat.uniforms._FarPlane.value = CameraManager.current.far;
   }
 
   __check_RT_size()

package/src/render_mode/UnrealBloomRender.ts

@@ -27,7 +27,8 @@ class UnrealBloomRender extends BaseRender
     this.add_mat = new AddMaterial(use_half_float);
 
     const rt_settings = {
-      samples: use_antialiasing ? 8 : 1,
+      // WebGPU only supports 1 or 4 samples. Higher counts render nothing on both backends.
+      samples: use_antialiasing ? 4 : 1,
       type: use_half_float ? HalfFloatType : UnsignedByteType,
       format: RGBAFormat,
       colorSpace: LinearSRGBColorSpace,

package/src/render_mode/VRRender.ts

@@ -42,7 +42,10 @@ class VRRender extends BaseRender
 
     if (spectator_camera && Graphics._renderer.xr.isPresenting)
     {
-      const xrCam = Graphics._renderer.xr.getCamera();
+      // XRManager types isPresenting as readonly, but it is a plain field that three's
+      // own examples flip to render the spectator view without WebXR.
+      const xr = Graphics._renderer.xr as typeof Graphics._renderer.xr & { isPresenting: boolean };
+      const xrCam = xr.getCamera();
 
       spectator_camera.projectionMatrix.copy(CameraManager.current.projectionMatrix);
 
@@ -53,7 +56,7 @@ class VRRender extends BaseRender
       const currentRenderTarget = Graphics._renderer.getRenderTarget();
 
       // turn off the WebXR rendering
-      Graphics._renderer.xr.isPresenting = false;
+      xr.isPresenting = false;
 
       // render to the canvas on our main display
       Graphics._renderer.setRenderTarget(null);
@@ -61,7 +64,7 @@ class VRRender extends BaseRender
 
       // reset back to enable WebXR
       Graphics._renderer.setRenderTarget(currentRenderTarget);
-      Graphics._renderer.xr.isPresenting = true;
+      xr.isPresenting = true;
     }
   }
 }

package/src/render_utilities/Blitter.ts

@@ -1,13 +1,13 @@
 import type { Renderer } from 'three/webgpu';
-import { BlitMaterial } from '../materials/BlitMaterial';
+import { BlitNodeMaterial } from '../materials/BlitNodeMaterial';
 
 import { Mesh, OrthographicCamera, PlaneGeometry, Scene } from 'three';
 
 class Blitter
 {
   _blit_camera: OrthographicCamera;
-  _blit_material: BlitMaterial;
-  _blit_quad: Mesh;
+  _blit_material: BlitNodeMaterial;
+  _blit_quad: Mesh<PlaneGeometry, BlitNodeMaterial>;
   _blit_scene: Scene;
   renderer: Renderer;
 
@@ -15,7 +15,7 @@ class Blitter
   {
     this.renderer = renderer;
     this._blit_scene = new Scene();
-    this._blit_material = new BlitMaterial();
+    this._blit_material = new BlitNodeMaterial();
     this._blit_quad = new Mesh(
       new PlaneGeometry(1, 1), this._blit_material);
     this._blit_scene.add(this._blit_quad);

package/src/render_utilities/Blurrer.ts

@@ -30,6 +30,13 @@ class Blurrer
     Graphics.blit(this.RT1, RT, this.box_blur_mat);
     // return this.RT2;
   }
+
+  dispose()
+  {
+    this.RT1.dispose();
+    this.RT2.dispose();
+    this.box_blur_mat.dispose();
+  }
 }
 
 export { Blurrer };

package/src/render_utilities/DualFilteringBlurrer.ts

@@ -1,6 +1,5 @@
 import { RenderTarget } from 'three';
 import { Graphics } from '../Graphics';
-import { AlphaFilterMaterial } from '../materials/AlphaFilterMaterial';
 import { DualFilteringBlurMaterial } from '../materials/DualFilteringBlurMaterial';
 class DualFilteringBlurrer
 {
@@ -9,7 +8,6 @@ class DualFilteringBlurrer
   RT2: RenderTarget;
   RT3: RenderTarget;
   RT4: RenderTarget;
-  alpha_filter_mat: AlphaFilterMaterial;
   current_height: number;
   current_width: number;
   downscale_blur_mat: DualFilteringBlurMaterial;
@@ -27,14 +25,12 @@ class DualFilteringBlurrer
 
     this.upscale_blur_mat   = new DualFilteringBlurMaterial(true);
     this.downscale_blur_mat = new DualFilteringBlurMaterial(false);
-
-    this.alpha_filter_mat = new AlphaFilterMaterial();
   }
 
   blur(RT: RenderTarget)
   {
     this.check_RT_resize(RT.width, RT.height);
-    Graphics.blit(RT,       this.RT1, this.alpha_filter_mat);
+    Graphics.blit(RT,       this.RT1);
 
     // Graphics.blit(this.RT0, this.RT1, this.downscale_blur_mat);
     Graphics.blit(this.RT1, this.RT2, this.downscale_blur_mat);
@@ -58,13 +54,33 @@ class DualFilteringBlurrer
       this.current_width = width;
       this.current_height = height;
 
-      this.RT0.setSize(this.current_width / 2, this.current_height / 2);
-      this.RT1.setSize(this.current_width / 2, this.current_height / 2);
-      this.RT2.setSize(this.current_width / 4, this.current_height / 4);
-      this.RT3.setSize(this.current_width / 8, this.current_height / 8);
-      this.RT4.setSize(this.current_width / 16, this.current_height / 16);
+      // this.resize(this.RT0, 2);
+      this.resize(this.RT1, 2);
+      this.resize(this.RT2, 4);
+      this.resize(this.RT3, 8);
+      this.resize(this.RT4, 16);
     }
   }
+
+  dispose()
+  {
+    this.RT0.dispose();
+    this.RT1.dispose();
+    this.RT2.dispose();
+    this.RT3.dispose();
+    this.RT4.dispose();
+    this.upscale_blur_mat.dispose();
+    this.downscale_blur_mat.dispose();
+  }
+
+  // Whole pixels, and at least one: GPU textures have no fractional or zero sizes.
+  resize(target: RenderTarget, divisor: number)
+  {
+    target.setSize(
+      Math.max(1, Math.floor(this.current_width / divisor)),
+      Math.max(1, Math.floor(this.current_height / divisor))
+    );
+  }
 }
 
 export { DualFilteringBlurrer };

package/src/resource_loader/AudioLoader.ts

@@ -1,4 +1,4 @@
-import { AudioContext } from 'three';
+import { AudioContext as ThreeAudioContext } from 'three';
 
 import { AudioClip } from '../components/AudioClip';
 import type { ResourceContainer } from '../loaders/assets_loader/ResourceContainer';
@@ -42,7 +42,9 @@ class AudioLoader extends AbstractLoader
 
   instantiate_audio(resource_container: ResourceContainer)
   {
-    const context = AudioContext.getContext();
+    // three's typings declare getContext() as returning its own AudioContext helper class,
+    // but it returns the native Web Audio context.
+    const context = ThreeAudioContext.getContext() as unknown as AudioContext;
 
     const buffer = context.createBuffer(2, 22050, 44100);
 
@@ -52,7 +54,7 @@ class AudioLoader extends AbstractLoader
       {
         response.arrayBuffer().then((array_buffer) =>
         {
-          context.decodeAudioData(array_buffer, (audio_buffer) =>
+          void context.decodeAudioData(array_buffer, (audio_buffer) =>
           {
             resource_container.set_resource(
               this.resource_id,

package/src/resource_loader/HDRTextureLoader.ts

@@ -1,4 +1,4 @@
-import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader';
+import { HDRLoader } from 'three/examples/jsm/loaders/HDRLoader.js';
 import type { ResourceContainer } from '../loaders/assets_loader/ResourceContainer';
 import { AbstractLoader } from './AbstractLoader';
 

package/src/scenes/AbstractScene.ts

@@ -5,7 +5,9 @@ import { Mesh, Scene } from 'three';
 import type { CameraController } from '../camera_controller/CameraController';
 import { CameraManager } from '../CameraManager';
 import { Graphics } from '../Graphics';
+import type { CompilatorConstructor } from './Compilator';
 import { HighQualityLoadingState } from './loading_states/HighQualityLoadingState';
+import type { LoadingCompilators } from './loading_states/LoadingState';
 import { LoadingState } from './loading_states/LoadingState';
 import { RegularLoadingState } from './loading_states/RegularLoadingState';
 
@@ -25,7 +27,7 @@ class AbstractScene extends Scene
   constructor({
     name,
     compilators
-  }: { name: string, compilators: any })
+  }: { name: string, compilators: LoadingCompilators })
   {
     super();
 
@@ -137,14 +139,16 @@ class AbstractScene extends Scene
     // AvatarSystem.component_container.component_instancer.data_texture.data = new Float32Array(4);
 
     this.initialized = false;
+
+    super.dispose();
   }
 
-  set_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders?: any[], custom_compilators?: Compilator[], custom_data?: any[])
+  set_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders?: any[], custom_compilators?: CompilatorConstructor[], custom_data?: any[])
   {
     this.loading_states.regular.set_assets(scene_objects, scene_textures, scene_sounds, custom_loaders, custom_compilators, custom_data);
   }
 
-  set_high_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders?: any[], custom_compilators?: Compilator[], custom_data?: any[])
+  set_high_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders?: any[], custom_compilators?: CompilatorConstructor[], custom_data?: any[])
   {
     this.loading_states.high.set_assets(scene_objects, scene_textures, scene_sounds, custom_loaders, custom_compilators, custom_data);
   }

package/src/scenes/Compilator.ts

@@ -11,4 +11,8 @@ export class Compilator
     {
         this.finished = true;
     }
-}
+}
+
+// Compilators are handed around as classes and instantiated by the loading states,
+// each subclass taking its own constructor arguments.
+export type CompilatorConstructor = new (...args: any[]) => Compilator;

package/src/scenes/loading_states/LoadingState.ts

@@ -4,18 +4,26 @@ import { AsyncObjectsLoader } from '../../loaders/AsyncObjectsLoader';
 import { AsyncTexturesLoader } from '../../loaders/AsyncTexturesLoader';
 import { ResourceContainer } from '../../ResourceContainer';
 import type { AbstractScene } from '../AbstractScene';
-import type { Compilator } from '../Compilator';
+import type { Compilator, CompilatorConstructor } from '../Compilator';
 import { CompilatorManager } from '../CompilatorManager';
 
+// Empty for scenes that never load assets, like the default and the deferred lights scenes.
+export interface LoadingCompilators
+{
+  AudiosCompilator?: CompilatorConstructor;
+  SceneCompilator?: CompilatorConstructor;
+  TexturesCompilator?: CompilatorConstructor;
+}
+
 export class LoadingState
 {
-  AudiosCompilator: Compilator;
-  SceneCompilator: Compilator;
-  TexturesCompilator: Compilator;
+  AudiosCompilator: CompilatorConstructor;
+  SceneCompilator: CompilatorConstructor;
+  TexturesCompilator: CompilatorConstructor;
   callback_called: boolean;
   compilator_manager: CompilatorManager;
   compilators: Compilator[];
-  custom_compilators: Compilator[];
+  custom_compilators: CompilatorConstructor[];
   custom_data: any[];
   custom_loaders: any[];
   loaders: AsyncAbstractLoader[];
@@ -28,7 +36,7 @@ export class LoadingState
     SceneCompilator,
     TexturesCompilator,
     AudiosCompilator
-  }: { SceneCompilator: Compilator, TexturesCompilator: Compilator, AudiosCompilator: Compilator })
+  }: LoadingCompilators)
   {
     this.scene = scene;
 
@@ -42,7 +50,7 @@ export class LoadingState
     this.callback_called = false;
   }
 
-  set_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders: any[] = [], custom_compilators: Compilator[] = [], custom_data: any[] = [])
+  set_assets(scene_objects: any[], scene_textures: any[], scene_sounds: any[], custom_loaders: any[] = [], custom_compilators: CompilatorConstructor[] = [], custom_data: any[] = [])
   {
     this.scene_objects = scene_objects;
     this.scene_textures = scene_textures;

package/src/scenes/loading_states/RegularLoadingState.ts

@@ -1,11 +1,12 @@
 import type { AbstractScene } from '../AbstractScene';
+import type { LoadingCompilators } from './LoadingState';
 import { LoadingState } from './LoadingState';
 
 export class RegularLoadingState extends LoadingState
 {
   on_assets_ready_called: boolean;
 
-  constructor(scene: AbstractScene, compilators: any)
+  constructor(scene: AbstractScene, compilators: LoadingCompilators)
   {
     super(scene, compilators);