reformat export

viewer/src/lib/splat.js/cameras/Camera.ts

@@ -1,7 +1,7 @@
 import { Object3D } from "../core/Object3D";
 import { Matrix4 } from "../math/Matrix4";
 
-export class Camera extends Object3D {
+class Camera extends Object3D {
     projectionMatrix: Matrix4;
 
     constructor() {
@@ -10,3 +10,5 @@ export class Camera extends Object3D {
         this.projectionMatrix = new Matrix4();
     }
 }
+
+export { Camera };

viewer/src/lib/splat.js/cameras/PerspectiveCamera.ts

@@ -1,7 +1,6 @@
 import { Camera } from "./Camera";
-import { Matrix4 } from "../math/Matrix4";
 
-export class PerspectiveCamera extends Camera {
+class PerspectiveCamera extends Camera {
     fx: number;
     fy: number;
 
@@ -27,3 +26,5 @@ export class PerspectiveCamera extends Camera {
         );
     }
 }
+
+export { PerspectiveCamera };

viewer/src/lib/splat.js/core/EventDispatcher.ts

@@ -0,0 +1,38 @@
+class EventDispatcher {
+    listeners: { [key: string]: Function[] } = {};
+
+    addEventListener(type: string, listener: Function): void {
+        if (this.listeners[type] === undefined) {
+            this.listeners[type] = [];
+        }
+        if (this.listeners[type].indexOf(listener) === -1) {
+            this.listeners[type].push(listener);
+        }
+    }
+
+    hasEventListener(type: string, listener: Function): boolean {
+        return this.listeners[type] !== undefined && this.listeners[type].indexOf(listener) !== -1;
+    }
+
+    removeEventListener(type: string, listener: Function): void {
+        const listenerArray = this.listeners[type];
+        if (listenerArray !== undefined) {
+            const index = listenerArray.indexOf(listener);
+            if (index !== -1) {
+                listenerArray.splice(index, 1);
+            }
+        }
+    }
+
+    dispatchEvent(event: { type: string }): void {
+        const listenerArray = this.listeners[event.type];
+        if (listenerArray !== undefined) {
+            const array = listenerArray.slice(0);
+            for (let i = 0, l = array.length; i < l; i++) {
+                array[i].call(this, event);
+            }
+        }
+    }
+}
+
+export { EventDispatcher };

viewer/src/lib/splat.js/core/Object3D.ts

@@ -1,7 +1,7 @@
 import { Vector3 } from "../math/Vector3";
 import { Quaternion } from "../math/Quaternion";
 
-export class Object3D {
+class Object3D {
     position: Vector3;
     rotation: Quaternion;
 
@@ -10,3 +10,5 @@ export class Object3D {
         this.rotation = new Quaternion();
     }
 }
+
+export { Object3D };

viewer/src/lib/splat.js/core/Renderer.ts

@@ -1,6 +0,0 @@
-import type { Camera } from "../cameras/Camera";
-
-export interface Renderer {
-    render(camera: Camera): void;
-    setData(data: Uint8Array): void;
-}

viewer/src/lib/splat.js/core/Scene.ts

@@ -0,0 +1,18 @@
+import { Object3D } from "./Object3D";
+
+class Scene extends Object3D {
+    data: Uint8Array;
+
+    constructor() {
+        super();
+
+        this.data = new Uint8Array(0);
+    }
+
+    setData(data: Uint8Array): void {
+        this.data = data;
+        console.log(data);
+    }
+}
+
+export { Scene };

viewer/src/lib/splat.js/index.ts

@@ -1,10 +1,11 @@
-export * from "./cameras/Camera";
-export * from "./core/Renderer";
+export { Camera } from "./cameras/Camera";
+export { Renderer } from "./renderers/Renderer";
+export { Scene } from "./core/Scene";
 
-export * from "./loaders/Loader";
+export { Loader } from "./loaders/Loader";
 
-export * from "./renderers/WebGLRenderer";
+export { WebGLRenderer } from "./renderers/WebGLRenderer";
 
-export * from "./math/Quaternion";
-export * from "./math/Vector3";
-export * from "./math/Matrix4";
+export { Quaternion } from "./math/Quaternion";
+export { Vector3 } from "./math/Vector3";
+export { Matrix4 } from "./math/Matrix4";

viewer/src/lib/splat.js/loaders/Loader.ts

@@ -1,7 +1,7 @@
-import type { Renderer } from "../core/Renderer";
+import type { Scene } from "../core/Scene";
 
-export class Loader {
-    static async LoadAsync(url: string, renderer: Renderer, onProgress?: (progress: number) => void): Promise<void> {
+class Loader {
+    static async LoadAsync(url: string, scene: Scene, onProgress?: (progress: number) => void): Promise<void> {
         const req = await fetch(url, {
             mode: "cors",
             credentials: "omit",
@@ -27,6 +27,8 @@ export class Loader {
             onProgress?.(bytesRead / contentLength);
         }
 
-        renderer.setData(data);
+        scene.setData(data);
     }
 }
+
+export { Loader };

viewer/src/lib/splat.js/math/Matrix4.ts

@@ -1,4 +1,4 @@
-export class Matrix4 {
+class Matrix4 {
     elements: number[];
 
     // prettier-ignore
@@ -31,3 +31,5 @@ export class Matrix4 {
         return this;
     }
 }
+
+export { Matrix4 };

viewer/src/lib/splat.js/math/Quaternion.ts

@@ -1,4 +1,4 @@
-export class Quaternion {
+class Quaternion {
     x: number;
     y: number;
     z: number;
@@ -20,3 +20,5 @@ export class Quaternion {
         return this;
     }
 }
+
+export { Quaternion };

viewer/src/lib/splat.js/math/Vector3.ts

@@ -1,4 +1,4 @@
-export class Vector3 {
+class Vector3 {
     x: number;
     y: number;
     z: number;
@@ -17,3 +17,5 @@ export class Vector3 {
         return this;
     }
 }
+
+export { Vector3 };

viewer/src/lib/splat.js/renderers/Renderer.ts

@@ -0,0 +1,9 @@
+import type { Camera } from "../cameras/Camera";
+import type { Scene } from "../core/Scene";
+
+class Renderer {
+    render(scene: Scene, camera: Camera): void {}
+    dispose(): void {}
+}
+
+export { Renderer };

viewer/src/lib/splat.js/renderers/WebGLRenderer.ts

@@ -1,17 +1,20 @@
 import type { Camera } from "../cameras/Camera";
-import type { Renderer } from "../core/Renderer";
+import type { Scene } from "../core/Scene";
+import type { Renderer } from "./Renderer";
 
 export class WebGLRenderer implements Renderer {
     canvas: HTMLCanvasElement;
 
+    gl: WebGLRenderingContext;
+    ext: ANGLE_instanced_arrays;
+
     constructor(canvas?: HTMLCanvasElement) {
         this.canvas =
             canvas ?? (document.createElementNS("http://www.w3.org/1999/xhtml", "canvas") as HTMLCanvasElement);
+        this.gl = this.canvas.getContext("webgl") as WebGLRenderingContext;
+        this.ext = this.gl.getExtension("ANGLE_instanced_arrays") as ANGLE_instanced_arrays;
     }
 
-    render(camera: Camera): void {}
-
-    setData(data: Uint8Array): void {
-        console.log("setData", data);
-    }
+    render(scene: Scene, camera: Camera): void {}
+    dispose(): void {}
 }

viewer/src/lib/splat.js/renderers/webgl/shaders/frag.glsl.ts

@@ -0,0 +1,13 @@
+export const frag = /* glsl */ `
+precision mediump float;
+
+varying vec4 vColor;
+varying vec2 vPosition;
+
+void main () {    
+    float A = -dot(vPosition, vPosition);
+    if (A < -4.0) discard;
+    float B = exp(A) * vColor.a;
+    gl_FragColor = vec4(B * vColor.rgb, B);
+}
+`;

viewer/src/lib/splat.js/renderers/webgl/shaders/vertex.glsl.ts

@@ -0,0 +1,75 @@
+export const vertex = /* glsl */ `
+precision mediump float;
+attribute vec2 position;
+
+attribute vec4 color;
+attribute vec3 center;
+attribute vec3 covA;
+attribute vec3 covB;
+
+uniform mat4 projection, view;
+uniform vec2 focal;
+uniform vec2 viewport;
+
+varying vec4 vColor;
+varying vec2 vPosition;
+
+mat3 transpose(mat3 m) {
+    return mat3(
+        m[0][0], m[1][0], m[2][0],
+        m[0][1], m[1][1], m[2][1],
+        m[0][2], m[1][2], m[2][2]
+    );
+}
+
+void main () {
+    vec4 camspace = view * vec4(center, 1);
+    vec4 pos2d = projection * camspace;
+
+    float bounds = 1.2 * pos2d.w;
+    if (pos2d.z < -pos2d.w || pos2d.x < -bounds || pos2d.x > bounds
+        || pos2d.y < -bounds || pos2d.y > bounds) {
+        gl_Position = vec4(0.0, 0.0, 2.0, 1.0);
+        return;
+    }
+
+    mat3 Vrk = mat3(
+        covA.x, covA.y, covA.z, 
+        covA.y, covB.x, covB.y,
+        covA.z, covB.y, covB.z
+    );
+
+    mat3 J = mat3(
+        focal.x / camspace.z, 0., -(focal.x * camspace.x) / (camspace.z * camspace.z), 
+        0., -focal.y / camspace.z, (focal.y * camspace.y) / (camspace.z * camspace.z), 
+        0., 0., 0.
+    );
+
+    mat3 W = transpose(mat3(view));
+    mat3 T = W * J;
+    mat3 cov = transpose(T) * Vrk * T;
+    
+    vec2 vCenter = vec2(pos2d) / pos2d.w;
+
+    float diagonal1 = cov[0][0] + 0.3;
+    float offDiagonal = cov[0][1];
+    float diagonal2 = cov[1][1] + 0.3;
+
+    float mid = 0.5 * (diagonal1 + diagonal2);
+    float radius = length(vec2((diagonal1 - diagonal2) / 2.0, offDiagonal));
+    float lambda1 = mid + radius;
+    float lambda2 = max(mid - radius, 0.1);
+    vec2 diagonalVector = normalize(vec2(offDiagonal, lambda1 - diagonal1));
+    vec2 v1 = min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector;
+    vec2 v2 = min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x);
+
+    vColor = color;
+    vPosition = position;
+
+    gl_Position = vec4(
+        vCenter 
+        + position.x * v1 / viewport * 2.0 
+        + position.y * v2 / viewport * 2.0, 0.0, 1.0
+    );
+}
+`;