ohzi-core 13.3.0 → 15.0.0

package/src/utilities/CameraUtilities.ts

@@ -1,9 +1,8 @@
 import { CameraManager } from '../CameraManager';
 import { OScreen } from '../OScreen';
-import { OMath } from '../utilities/OMath';
 
-import type { Camera, Object3D } from 'three';
-import { Box3, Matrix4, Plane, Ray, Sphere, Vector3 } from 'three';
+import type { Camera, Object3D, OrthographicCamera, PerspectiveCamera as ThreePerspectiveCamera } from 'three';
+import { Box3, Matrix4, Plane, Ray, Vector3 } from 'three';
 
 import type { Input } from '../lib/Input';
 import type { Vector2 } from '../lib/Vector2';
@@ -16,9 +15,6 @@ class CameraUtilities
   input: Input;
   plane: Plane;
   ray: Ray;
-  reference_position: Vector3;
-  reference_rotation: Vector3;
-  reference_zoom: number;
   tmp_mat: Matrix4;
   tmp_size: Vector3;
   tmp_unproj: Vector3;
@@ -97,7 +93,13 @@ class CameraUtilities
     }
     else
     {
-      const pos = new Vector3(NDC.x * camera.right, NDC.y * camera.top, 0);
+      // The same frustum OrthographicCamera.updateProjectionMatrix() builds.
+      const orthographic_camera = camera as OrthographicCamera;
+      const center_x = (orthographic_camera.right + orthographic_camera.left) / 2;
+      const center_y = (orthographic_camera.top + orthographic_camera.bottom) / 2;
+      const half_width = (orthographic_camera.right - orthographic_camera.left) / (2 * orthographic_camera.zoom);
+      const half_height = (orthographic_camera.top - orthographic_camera.bottom) / (2 * orthographic_camera.zoom);
+      const pos = new Vector3(center_x + NDC.x * half_width, center_y + NDC.y * half_height, 0);
       pos.applyQuaternion(camera.quaternion);
       pos.add(camera.position);
       const dir = new Vector3(0, 0, -1).applyQuaternion(camera.quaternion);
@@ -108,50 +110,34 @@ class CameraUtilities
     return tmp_vec;
   }
 
+  // Fits the points as the current camera sees them, flattened onto its view
+  // plane. zoom_scale scales the area to fit.
   fit_points_on_camera(points: Array<Vector3>, zoom_scale = 1)
   {
-    const points_sphere = new Sphere().setFromPoints(points);
-    const world_space_center = points_sphere.center;
-    const camera_forward = this.get_forward_dir(CameraManager.current).clone();
-
-    const plane = new Plane().setFromNormalAndCoplanarPoint(camera_forward, world_space_center);
-
-    const points_on_plane = OMath.project_points_on_plane(points, plane);
-
-    const projected_points_center = new Vector3();
-    let box =  new Box3().setFromPoints(points_on_plane);
-    box.getCenter(projected_points_center);
-
-    const up = new Vector3(0, 1, 0).applyQuaternion(CameraManager.current.quaternion);
-    const right = up.clone().cross(camera_forward).normalize();
-    const mat = new Matrix4().set(right.x, up.x, camera_forward.x, world_space_center.x,
-      right.y, up.y, camera_forward.y, world_space_center.y,
-      right.z, up.z, camera_forward.z, world_space_center.z,
-      0,    0,                0,        1);
-
-    const inverse_mat = mat.invert();
-    for (let i = 0; i < points_on_plane.length; i++)
-    {
-      points_on_plane[i].applyMatrix4(inverse_mat);
-    }
-
-    const size = new Vector3();
-    box =  new Box3().setFromPoints(points_on_plane);
-    box.getSize(size);
-    size.multiplyScalar(zoom_scale);
-    const projected_center = new Vector3();
-    box.getCenter(projected_center);
+    const bounds = new OrthographicFrustumPointFitter().get_view_bounds(points, CameraManager.current.quaternion);
+    const size = bounds.size.clone().multiplyScalar(zoom_scale);
 
     return {
-      position: projected_points_center,
+      position: bounds.center,
       zoom: this.get_zoom_to_fit_rect(size.x / 2, size.y / 2)
     };
   }
 
+  // Fits a half width and half height on the current camera. For a
+  // perspective camera this is a distance; for an orthographic camera it is
+  // the camera zoom.
   get_zoom_to_fit_rect(width: number, height: number)
   {
-    const v_fov = (CameraManager.current.fov / 2) * Math.PI / 180;
-    const h_fov = (2 * Math.atan(Math.tan(v_fov) * CameraManager.current.aspect)) / 2;
+    const camera = CameraManager.current as Camera as ThreePerspectiveCamera | OrthographicCamera;
+
+    if ((camera as OrthographicCamera).isOrthographicCamera)
+    {
+      return new OrthographicFrustumPointFitter().get_zoom_to_fit_size(camera as OrthographicCamera, width * 2, height * 2);
+    }
+
+    const perspective_camera = camera as ThreePerspectiveCamera;
+    const v_fov = (perspective_camera.fov / 2) * Math.PI / 180;
+    const h_fov = (2 * Math.atan(Math.tan(v_fov) * perspective_camera.aspect)) / 2;
 
     const distV = height / Math.tan(v_fov);
     const distH = width / Math.tan(h_fov);
@@ -159,31 +145,18 @@ class CameraUtilities
     return Math.max(Math.abs(distH), Math.abs(distV));
   }
 
+  // For a perspective camera this is a distance; for an orthographic camera it
+  // is the camera zoom.
   get_zoom_to_fit_box(bb: Box3, camera: Camera)
   {
-    if (camera.isOrthographicCamera)
-    {
-      bb.getSize(this.tmp_size);
-
-      const obj_x = this.tmp_size.x;
-      const obj_y = this.tmp_size.y;
-      const object_aspect = obj_x / obj_y;
-      if (OScreen.aspect_ratio / object_aspect > 1)
-      {
-        return OScreen.height / obj_y;
-      }
-      else
-      {
-        return OScreen.width / obj_x;
-      }
-    }
-    else
+    camera = camera || CameraManager.current;
+
+    if (bb.isEmpty())
     {
-      // return this.fit_points_on_camera([bb.min, bb.max], 1).zoom;
-      const size = new Vector3();
-      bb.getSize(size);
-      return this.get_zoom_to_fit_rect(size.x, size.y);
+      return (camera as OrthographicCamera).isOrthographicCamera ? (camera as OrthographicCamera).zoom : 0;
     }
+
+    return this.fit_bounding_box_points(camera, bb).zoom;
   }
 
   get_html_screen_pos(object: Object3D, camera: Camera)
@@ -214,12 +187,14 @@ class CameraUtilities
 
   update_projection(camera: Camera)
   {
-    camera.left   = -OScreen.width / 2;
-    camera.right  = OScreen.width / 2;
-    camera.top    = OScreen.height / 2;
-    camera.bottom = -OScreen.height / 2;
-    camera.aspect = OScreen.aspect_ratio;
-    camera.updateProjectionMatrix(true);
+    const orthographic_camera = camera as OrthographicCamera & { aspect: number };
+
+    orthographic_camera.left   = -OScreen.width / 2;
+    orthographic_camera.right  = OScreen.width / 2;
+    orthographic_camera.top    = OScreen.height / 2;
+    orthographic_camera.bottom = -OScreen.height / 2;
+    orthographic_camera.aspect = OScreen.aspect_ratio;
+    orthographic_camera.updateProjectionMatrix();
   }
 
   fit_bounding_box_points(camera: Camera, bb: Box3, scale = 1)
@@ -242,16 +217,16 @@ class CameraUtilities
 
   fit_points(camera: Camera, points: Array<Vector3>, zoom_scale = 1)
   {
-    if (camera.isPerspectiveCamera)
+    const perspective_camera = camera as ThreePerspectiveCamera;
+
+    if (perspective_camera.isPerspectiveCamera)
     {
       const camera_forward_dir = new Vector3(0, 0, -1).applyQuaternion(camera.quaternion);
       const camera_backward_dir = camera_forward_dir.clone().multiplyScalar(-1);
 
       const fitter = new PerspectiveFrustumPointFitter();
 
-      const aspect_ratio = OScreen.aspect_ratio;
-
-      const camera_pos = fitter.fit_points(points, camera.quaternion, camera.fov * zoom_scale, aspect_ratio);
+      const camera_pos = fitter.fit_points(points, camera.quaternion, perspective_camera.fov * zoom_scale, perspective_camera.aspect);
       const box = new Box3().setFromPoints(points);
       const center = new Vector3();
       box.getCenter(center);
@@ -273,17 +248,20 @@ class CameraUtilities
     }
     else
     {
+      // An orthographic camera frames through its zoom. It keeps its distance
+      // to the points when that fits their depth between the near and far planes.
+      const orthographic_camera = camera as OrthographicCamera;
       const fitter = new OrthographicFrustumPointFitter();
-      const result = fitter.fit_points(points, this.reference_rotation, camera.fov * zoom_scale, OScreen.aspect_ratio);
+      const bounds = fitter.get_view_bounds(points, camera.quaternion);
+      const camera_backward_dir = new Vector3(0, 0, 1).applyQuaternion(camera.quaternion);
 
-      this.reference_position.copy(result.center);
-      this.reference_zoom = result.distance_to_center;
+      const current_distance = camera.position.clone().sub(bounds.center).dot(camera_backward_dir);
+      const distance = fitter.get_distance_to_fit_depth(orthographic_camera, bounds.size.z / 2, current_distance);
 
-      const forward = new Vector3(0, 0, 1).applyQuaternion(camera.quaternion);
       return {
-        zoom: result.distance_to_center,
-        reference_position: result.center,
-        camera_position: forward.multiplyScalar(result.distance_to_center)
+        zoom: fitter.get_zoom_to_fit_size(orthographic_camera, bounds.size.x, bounds.size.y, zoom_scale),
+        reference_position: bounds.center,
+        camera_position: bounds.center.clone().addScaledVector(camera_backward_dir, distance)
       };
     }
   }

package/src/utilities/HTMLUtilities.ts

@@ -59,7 +59,8 @@ class HTMLUtilities
 
   static load_elements(container: HTMLElement, selector: string)
   {
-    const elements = container.querySelectorAll(selector);
+    // Any element with a src attribute (img, video, source, iframe...).
+    const elements = container.querySelectorAll<HTMLElement & { src: string }>(selector);
 
     for (let i = 0; i < elements.length; i++)
     {

package/src/utilities/MeshSampler.ts

@@ -1,6 +1,13 @@
 import type { BufferGeometry } from 'three';
 import { Vector2, Vector3 } from 'three';
 
+// What sample_point_in_face needs from a point, which Vector2 (UVs) and Vector3 both provide.
+interface Sampleable<T> {
+  add(v: T): T;
+  clone(): T;
+  multiplyScalar(scalar: number): T;
+}
+
 interface Face {
   a: Vector3;
   b: Vector3;
@@ -205,7 +212,7 @@ class MeshSampler
     return vec1.cross(vec2).length() / 2;
   }
 
-  sample_point_in_face(w1: number, w2: number, v1: Vector3, v2: Vector3, v3: Vector3)
+  sample_point_in_face<T extends Sampleable<T>>(w1: number, w2: number, v1: T, v2: T, v3: T): T
   {
     if (w1 + w2 > 1)
     {

package/src/utilities/OrthographicFrustumPointFitter.ts

@@ -1,4 +1,4 @@
-import type { Quaternion } from 'three';
+import type { OrthographicCamera, Quaternion } from 'three';
 import { Box3, Vector3 } from 'three';
 
 class OrthographicFrustumPointFitter
@@ -10,7 +10,21 @@ class OrthographicFrustumPointFitter
 
   fit_points(points: Vector3[], camera_quaternion: Quaternion, vertical_fov: number, aspect: number)
   {
-    const inverse_camera_quat = camera_quaternion.clone().inverse();
+    const bounds = this.get_view_bounds(points, camera_quaternion);
+
+    const distance = this.get_distance_to_fit_rect(bounds.size.x / 2, bounds.size.y / 2, vertical_fov, aspect);
+
+    return {
+      center: bounds.center,
+      distance_to_center: distance
+    };
+  }
+
+  // Bounds of the points as seen by a camera with this rotation: the center in
+  // world space, and the size along the camera right (x), up (y) and view (z) axes.
+  get_view_bounds(points: Vector3[], camera_quaternion: Quaternion)
+  {
+    const inverse_camera_quat = camera_quaternion.clone().invert();
 
     const inverted_points = [];
 
@@ -23,7 +37,13 @@ class OrthographicFrustumPointFitter
     const size = new Vector3();
     box.getSize(size);
 
-    const distance = this.get_distance_to_fit_rect(size.x / 2, size.y / 2, vertical_fov, aspect);
+    // Points lined up along an axis leave rounding noise, not 0, across it.
+    const epsilon = 1e-9 * Math.max(size.x, size.y, size.z);
+    size.set(
+      size.x > epsilon ? size.x : 0,
+      size.y > epsilon ? size.y : 0,
+      size.z > epsilon ? size.z : 0
+    );
 
     const center = new Vector3();
     box.getCenter(center);
@@ -32,10 +52,39 @@ class OrthographicFrustumPointFitter
 
     return {
       center: center,
-      distance_to_center: distance
+      size: size
     };
   }
 
+  // The camera zoom that shows a width x height area through the camera
+  // frustum, times scale. A degenerate area keeps the current zoom, unscaled.
+  get_zoom_to_fit_size(camera: OrthographicCamera, width: number, height: number, scale = 1)
+  {
+    const zoom = Math.min(
+      Math.abs((camera.right - camera.left) / width),
+      Math.abs((camera.top - camera.bottom) / height)
+    );
+
+    return Number.isFinite(zoom) ? zoom * scale : camera.zoom;
+  }
+
+  // An orthographic camera frames through its zoom, so its distance to the
+  // center only has to keep a depth of +-half_depth between the near and far
+  // planes. The preferred distance is kept when it does; if nothing does, the
+  // near plane wins.
+  get_distance_to_fit_depth(camera: OrthographicCamera, half_depth: number, preferred_distance: number)
+  {
+    const closest = half_depth + camera.near;
+    const farthest = camera.far - half_depth;
+
+    let distance = Math.max(preferred_distance, closest);
+    if (distance > farthest)
+    {
+      distance = Math.max(closest, farthest);
+    }
+    return distance;
+  }
+
   get_distance_to_fit_rect(width: number, height: number, vertical_fov: number, aspect: number)
   {
     const v_fov = (vertical_fov / 2) * Math.PI / 180;

package/src/view_components/ApplicationView.ts

@@ -75,7 +75,7 @@ class ApplicationView extends ViewState
     {
       this.current_opacity = opacity;
 
-      this.container.style.opacity = this.current_opacity;
+      this.container.style.opacity = String(this.current_opacity);
     }
   }
 }

package/src/view_components/ViewComponent.ts

@@ -50,7 +50,7 @@ export class ViewComponent
 
   toggle_hidden()
   {
-    if (this.container.style.opacity > 0.001)
+    if (Number(this.container.style.opacity) > 0.001)
     {
       if (this.hidden)
       {

package/src/view_components/ViewManager.ts

@@ -1,6 +1,12 @@
 import type { ApplicationView } from './ApplicationView';
 import { TransitionManager } from './TransitionManager';
 
+// The app registers a view named 'transition' that loads the next view in between.
+interface TransitionView extends ApplicationView
+{
+  set_next_view(view: ApplicationView, reload?: boolean): void;
+}
+
 class ViewManager
 {
   browser_title_suffix: string;
@@ -34,7 +40,7 @@ class ViewManager
   go_to_scene(scene_name: string, change_url = false, skip = false)
   {
     const next_view = this.get(scene_name);
-    const transition_view = this.get('transition');
+    const transition_view = this.get('transition') as TransitionView;
 
     transition_view.set_next_view(next_view);
     this.go_to_view(transition_view.name, change_url, skip);

package/src/view_components/transition/DrawIOAnimationSheet.ts

@@ -82,7 +82,7 @@ class DrawIOAnimationSheet
     };
   }
 
-  get_node_x_position(node: HTMLElement)
+  get_node_x_position(node: Element)
   {
     const x_pos = node.getAttribute('x');
     return x_pos === null ? 0 : parseFloat(x_pos);

package/types/Capabilities.d.ts

@@ -4,5 +4,4 @@ declare class Capabilities {
     init(): void;
     max_anisotropy: number;
     vertex_texture_sampler_available: boolean;
-    fp_textures_available: boolean;
 }

package/types/SceneManager.d.ts

@@ -5,7 +5,7 @@ declare class SceneManager {
     get current(): Scene;
     set current(arg: Scene);
     
-    init(): void;
+    init(default_scene: Scene): void;
     add_scene(name: string): void;
     dispose(): void;
 }

package/types/blitter_index.d.ts

@@ -1,6 +1,5 @@
 import { Blitter } from './render_utilities/Blitter';
 import { Blurrer } from './render_utilities/Blurrer';
 import { GaussianBlurrer } from './render_utilities/GaussianBlurrer';
-import { MedianFilter } from './render_utilities/MedianFilter';
 import { DualFilteringBlurMaterial } from './materials/DualFilteringBlurMaterial';
-export { Blitter, Blurrer, DualFilteringBlurMaterial, GaussianBlurrer, MedianFilter };
+export { Blitter, Blurrer, DualFilteringBlurMaterial, GaussianBlurrer };

package/types/camera_controller/CameraController.d.ts

@@ -85,4 +85,13 @@ export declare class CameraController {
     get_current_orientation(): number;
     get_current_azimuth(): number;
     __get_zoom_to_show_rect(width: number, height: number, scale?: number): number;
+    __is_orthographic(): boolean;
+    __fit_orthographic(quaternion: Quaternion, points: Vector3[], zoom_scale: number): {
+        zoom: number;
+        center: Vector3;
+        distance: number;
+    };
+    __get_orthographic_distance(half_depth: number): number;
+    __get_orthographic_zoom(width: number, height: number, scale?: number): number;
+    __set_orthographic_zoom(zoom: number): void;
 }

package/types/components/Line.d.ts

@@ -1,8 +1,9 @@
-import type { Color, ShaderMaterial, Vector3 } from "three";
+import type { Color, Vector3 } from "three";
+import type { NodeMaterial } from "three/webgpu";
 import { Mesh } from "three";
 export class Line extends Mesh {
     constructor(points?: Vector3[]);
-    material: ShaderMaterial;
+    material: NodeMaterial;
     _length: number;
     accumulated_length: number;
     set thickness(arg: any);

package/types/components/WorldImage.d.ts

@@ -1,11 +1,12 @@
-import type { ShaderMaterial, Texture, Vector2, Vector3 } from "three";
+import type { Texture, Vector2, Vector3 } from "three";
+import type { NodeMaterial } from "three/webgpu";
 import { Mesh } from "three";
 
 export class WorldImage extends Mesh {
     constructor(texture: Texture, pivot?: Vector2);
     current_scale: number;
     tmp_bb_size: Vector3;
-    material: ShaderMaterial;
+    material: NodeMaterial;
     update_texture(): void;
     set size(arg: Vector3);
     get size(): Vector3;

package/types/index.d.ts

@@ -29,17 +29,13 @@ import { Text2D } from "./components/Text2D";
 import { UpdatableMaterialMesh } from "./components/UpdatableMaterialMesh";
 import { WorldImage } from "./components/WorldImage";
 import { SDFTextBatch } from "./components/sdf_text/SDFTextBatch";
-import { GPUParticleSystem } from "./gpu_particles/GPUParticleSystem";
-import { ParticleAttribute } from "./gpu_particles/ParticleAttribute";
-import { ParticlePositionAttribute } from "./gpu_particles/ParticlePositionAttribute";
 import { CSSAnimator } from "./html_utilities/CSSAnimator";
 import { AsyncAbstractLoader } from "./loaders/AsyncAbstractLoader";
 import { AsyncAudiosLoader } from "./loaders/AsyncAudiosLoader";
 import { AsyncObjectsLoader } from "./loaders/AsyncObjectsLoader";
 import { AsyncTexturesLoader } from "./loaders/AsyncTexturesLoader";
 import { AddMaterial } from "./materials/AddMaterial";
-import { BaseShaderMaterial } from "./materials/BaseShaderMaterial";
-import { BlitMaterial } from "./materials/BlitMaterial";
+import { BlitNodeMaterial } from "./materials/BlitNodeMaterial";
 import { DualFilteringBlurMaterial } from "./materials/DualFilteringBlurMaterial";
 import { UnrealBloomComposeMaterial } from "./materials/UnrealBloomComposeMaterial";
 import { Arrow } from "./primitives/Arrow";
@@ -56,7 +52,6 @@ import { VRRender } from "./render_mode/VRRender";
 import { Blurrer } from "./render_utilities/Blurrer";
 import { DualFilteringBlurrer } from "./render_utilities/DualFilteringBlurrer";
 import { GaussianBlurrer } from "./render_utilities/GaussianBlurrer";
-import { MedianFilter } from "./render_utilities/MedianFilter";
 import { AbstractLoader } from "./resource_loader/AbstractLoader";
 import { AsyncTextureLoader } from "./resource_loader/AsyncTextureLoader";
 import { AudioLoader } from "./resource_loader/AudioLoader";
@@ -104,5 +99,5 @@ import { ViewManager } from "./view_components/ViewManager";
 import { ActionSequencerBuilder } from "./view_components/transition/ActionSequencerBuilder";
 import { DrawIOAnimationSheet } from "./view_components/transition/DrawIOAnimationSheet";
 import { TransitionTable } from "./view_components/transition/TransitionTable";
-export { AbstractLoader, AbstractScene, ActionEvent, ActionInterpolator, ActionSequencer, ActionSequencerBuilder, AddMaterial, ApplicationView, ArrayUtilities, Arrow, AsyncAbstractLoader, AsyncAudiosLoader, AsyncObjectsLoader, AsyncTextureLoader, AsyncTexturesLoader, AudioLoader, BaseApplication, BaseRender, BaseShaderMaterial, BasisLoader, BlitMaterial, Blurrer, Browser, BufferGeometryUtils, CameraManager, CameraUtilities, CanvasDrawer, Capabilities, CSSAnimator, Cube, CubemapLoader, DAELoader, Debug, DebugNormalsRender, DrawIOAnimationSheet, DualFilteringBlurMaterial, DualFilteringBlurrer, EasingFunctions, FileLoader, FontLoader, FrustumPointFitter, GaussianBlurrer, GeometryUtilities, GLTFDRACOLoader, GLTFLoader, GPUParticleSystem, Graphics, Grid, HDRCubeTextureLoader, HDRTextureLoader, HighQualityLoadingState, HorizontalPlane, HTMLUtilities, ImageUtilities, Initializer, JSONLoader, KeyboardInput, Line, LoadingState, MedianFilter, MeshSampler, ModelUtilities, NormalAORender, NormalRender, NumberInterpolator, ObjectUtilities, OBJLoader, OMath, OrthographicCamera, OrthographicFrustumPointFitter, OS, OScreen, ParticleAttribute, ParticlePositionAttribute, PerspectiveCamera, PerspectiveFrustumPointFitter, PointArrayLoader, RegularLoadingState, RenderLoop, ResourceBatch, ResourceContainer, SceneManager, Screen, SDFTextBatch, SimpleTextDrawer, Sphere, StringUtilities, Text2D, TextLoader, TextureLoader, Time, TimeUtilities, TransitionManager, TransitionTable, UnrealBloomComposeMaterial, UnrealBloomRender, UpdatableMaterialMesh, Validation, VectorInterpolator, VerticalPlane, VideoLoader, ViewComponent, ViewComponentManager, ViewManager, VRRender, WorldImage };
+export { AbstractLoader, AbstractScene, ActionEvent, ActionInterpolator, ActionSequencer, ActionSequencerBuilder, AddMaterial, ApplicationView, ArrayUtilities, Arrow, AsyncAbstractLoader, AsyncAudiosLoader, AsyncObjectsLoader, AsyncTextureLoader, AsyncTexturesLoader, AudioLoader, BaseApplication, BaseRender, BasisLoader, BlitNodeMaterial, Blurrer, Browser, BufferGeometryUtils, CameraManager, CameraUtilities, CanvasDrawer, Capabilities, CSSAnimator, Cube, CubemapLoader, DAELoader, Debug, DebugNormalsRender, DrawIOAnimationSheet, DualFilteringBlurMaterial, DualFilteringBlurrer, EasingFunctions, FileLoader, FontLoader, FrustumPointFitter, GaussianBlurrer, GeometryUtilities, GLTFDRACOLoader, GLTFLoader, Graphics, Grid, HDRCubeTextureLoader, HDRTextureLoader, HighQualityLoadingState, HorizontalPlane, HTMLUtilities, ImageUtilities, Initializer, JSONLoader, KeyboardInput, Line, LoadingState, MeshSampler, ModelUtilities, NormalAORender, NormalRender, NumberInterpolator, ObjectUtilities, OBJLoader, OMath, OrthographicCamera, OrthographicFrustumPointFitter, OS, OScreen, PerspectiveCamera, PerspectiveFrustumPointFitter, PointArrayLoader, RegularLoadingState, RenderLoop, ResourceBatch, ResourceContainer, SceneManager, Screen, SDFTextBatch, SimpleTextDrawer, Sphere, StringUtilities, Text2D, TextLoader, TextureLoader, Time, TimeUtilities, TransitionManager, TransitionTable, UnrealBloomComposeMaterial, UnrealBloomRender, UpdatableMaterialMesh, Validation, VectorInterpolator, VerticalPlane, VideoLoader, ViewComponent, ViewComponentManager, ViewManager, VRRender, WorldImage };
 

package/types/materials/AddMaterial.d.ts

@@ -1,5 +1,5 @@
-export class AddMaterial extends BlitMaterial {
+export class AddMaterial extends BlitNodeMaterial {
     constructor(nMips: any);
     set_add_texture(tex: any): void;
 }
-import { BlitMaterial } from "./BlitMaterial";
+import { BlitNodeMaterial } from "./BlitNodeMaterial";

package/types/materials/BlitNodeMaterial.d.ts

@@ -0,0 +1,18 @@
+import { texture } from 'three/tsl';
+import { type Node, NodeMaterial } from 'three/webgpu';
+type TextureNode = ReturnType<typeof texture>;
+declare class BlitNodeMaterial extends NodeMaterial {
+    uniforms: {
+        [uniform: string]: {
+            value: any;
+        };
+    };
+    uv_by_texture: Map<import("three/webgpu").TextureNode<"vec4">, Node<"vec2">>;
+    top_left_origin_by_texture: Map<import("three/webgpu").TextureNode<"vec4">, Node<"bool">>;
+    constructor();
+    uv_for(texture_node: TextureNode): Node<"vec2">;
+    texture_uv_at(texture_node: TextureNode, quad_uv: Node<'vec2'>): Node<"vec2">;
+    sample(texture_node: TextureNode, offset?: Node<'vec2'>): Node<"vec4">;
+    sample_main_tex(offset?: Node<'vec2'>): Node<"vec4">;
+}
+export { BlitNodeMaterial };

package/types/materials/BloomComposeMaterial.d.ts

@@ -1,5 +1,5 @@
-import { BlitMaterial } from './BlitMaterial';
-declare class BloomComposeMaterial extends BlitMaterial {
+import { BlitNodeMaterial } from './BlitNodeMaterial';
+declare class BloomComposeMaterial extends BlitNodeMaterial {
     constructor(alpha_blending?: boolean);
 }
 export { BloomComposeMaterial };

package/types/materials/BoxBlurMaterial.d.ts

@@ -1,4 +1,4 @@
-export class BoxBlurMaterial extends BlitMaterial {
+export class BoxBlurMaterial extends BlitNodeMaterial {
     constructor();
 }
-import { BlitMaterial } from "../materials/BlitMaterial";
+import { BlitNodeMaterial } from "../materials/BlitNodeMaterial";

package/types/materials/ClearDepthNormalMaterial.d.ts

@@ -1,4 +1,4 @@
-export class ClearDepthNormalMaterial extends BlitMaterial {
+export class ClearDepthNormalMaterial extends BlitNodeMaterial {
     constructor(clear_depth: any, clear_normal: any);
 }
-import { BlitMaterial } from "../materials/BlitMaterial";
+import { BlitNodeMaterial } from "../materials/BlitNodeMaterial";

package/types/materials/DepthNormalMaterial.d.ts

@@ -1,5 +1,5 @@
-import { ShaderMaterial } from "three";
-export class DepthNormalMaterial extends ShaderMaterial {
+import { NodeMaterial } from "three/webgpu";
+export class DepthNormalMaterial extends NodeMaterial {
     constructor();
     set far_plane(arg: any);
     get far_plane(): any;

package/types/materials/DualFilteringBlurMaterial.d.ts

@@ -1,4 +1,4 @@
-export class DualFilteringBlurMaterial extends BlitMaterial {
+export class DualFilteringBlurMaterial extends BlitNodeMaterial {
     constructor(upsample: any);
 }
-import { BlitMaterial } from "./BlitMaterial";
+import { BlitNodeMaterial } from "./BlitNodeMaterial";

package/types/materials/GaussianBlurMaterial.d.ts

@@ -1,5 +1,5 @@
-import { BlitMaterial } from './BlitMaterial';
-declare class GaussianBlurMaterial extends BlitMaterial {
+import { BlitNodeMaterial } from './BlitNodeMaterial';
+declare class GaussianBlurMaterial extends BlitNodeMaterial {
     constructor(kernel_radius: number);
     set_size(w: number, h: number): void;
     set_direction(x: number, y: number): void;

package/types/materials/LuminosityHighPassMaterial.d.ts

@@ -1,4 +1,4 @@
-export class LuminosityHighPassMaterial extends BlitMaterial {
+export class LuminosityHighPassMaterial extends BlitNodeMaterial {
     constructor(kernel_radius: any);
 }
-import { BlitMaterial } from "./BlitMaterial";
+import { BlitNodeMaterial } from "./BlitNodeMaterial";

package/types/materials/NormalMaterial.d.ts

@@ -1,5 +1,5 @@
-import { ShaderMaterial } from 'three';
-declare class NormalMaterial extends ShaderMaterial {
+import { NodeMaterial } from 'three/webgpu';
+declare class NormalMaterial extends NodeMaterial {
     constructor();
 }
 export { NormalMaterial };

package/types/materials/SDFTextMaterial.d.ts

@@ -1,7 +1,7 @@
-import { BaseShaderMaterial } from './BaseShaderMaterial';
 import type { Texture } from 'three';
 import { Vector2 } from 'three';
-declare class SDFTextMaterial extends BaseShaderMaterial {
+import { NodeMaterial } from 'three/webgpu';
+declare class SDFTextMaterial extends NodeMaterial {
     constructor(texture: Texture);
     set_atlas_size(size: Vector2): void;
     set_boldness(value: number): void;

package/types/materials/SSAOComposeMaterial.d.ts

@@ -1,4 +1,4 @@
-export class SSAOComposeMaterial extends BlitMaterial {
+export class SSAOComposeMaterial extends BlitNodeMaterial {
     constructor();
 }
-import { BlitMaterial } from "../materials/BlitMaterial";
+import { BlitNodeMaterial } from "../materials/BlitNodeMaterial";

package/types/materials/SSAOMaterial.d.ts

@@ -1,6 +1,6 @@
 import type { DataTexture, Vector3 } from "three";
-import { BlitMaterial } from "../materials/BlitMaterial";
-export class SSAOMaterial extends BlitMaterial {
+import { BlitNodeMaterial } from "../materials/BlitNodeMaterial";
+export class SSAOMaterial extends BlitNodeMaterial {
     constructor();
     __get_sample_kernel(): Vector3[];
     __get_rotation_kernel(): DataTexture;

package/types/materials/ScreenSpaceTextureMaterial.d.ts

@@ -1,6 +1,6 @@
 import type { Texture } from 'three';
-import { BaseShaderMaterial } from './BaseShaderMaterial';
-declare class ScreenSpaceTextureMaterial extends BaseShaderMaterial {
+import { BlitNodeMaterial } from './BlitNodeMaterial';
+declare class ScreenSpaceTextureMaterial extends BlitNodeMaterial {
     constructor();
     set_position(x: number, y: number): void;
     set_texture(tex: Texture, w: number, h: number): void;

package/types/materials/UnrealBloomComposeMaterial.d.ts

@@ -1,4 +1,4 @@
-export class UnrealBloomComposeMaterial extends BlitMaterial {
+export class UnrealBloomComposeMaterial extends BlitNodeMaterial {
     constructor(nMips: any);
     set_blur_texture_0(texture: Texture): void;
     set_blur_texture_1(texture: Texture): void;
@@ -13,5 +13,5 @@ export class UnrealBloomComposeMaterial extends BlitMaterial {
     set_tint_color_3(col_string: any): void;
     set_tint_color_4(col_string: any): void;
 }
-import { BlitMaterial } from "./BlitMaterial";
+import { BlitNodeMaterial } from "./BlitNodeMaterial";