@pirireis/webglobeplugins 0.17.0 → 1.0.2

package/programs/totems/{camerauniformblock.js → camerauniformblock.ts}

@@ -1,232 +1,328 @@
-import { globeProgramCache } from "../programcache";
-import { fromLongLatToUnitVector } from "../../Math/vec3";
-import { RADIAN } from "../../Math/methods";
-import { GlobeChangeObserver } from "./globe-changes";
+import { globeProgramCache } from "../programcache";
+import { Globe, GlobeChanges } from "../../types";
+import { Vec3 } from "../../Math/types";
+import { fromLongLatToUnitVector } from "../../Math/vec3";
+import { RADIAN } from "../../Math/methods";
+import { GlobeChangeObserver } from "./globe-changes";
+// import { DemTextureManager } from "./dem-textures-manager";
+
+import { CameraTotemAttachmentInterface } from "./camera-totem-attactment-interface";
+
 export const CameraUniformBlockString = `
 layout(std140) uniform CameraUniformBlock {
-    mat4 view; // 64 bytes           0
-    mat4 projection; // 64 bytes     64
-    vec3 translate; // 12 bytes      128
-    bool is3D; // 4 bytes            140
-    vec2 mapWH; // 8 bytes           144
-    vec2 screenWH; //  8 bytes       152
-    float z_level; // 4 bytes        160 | 164
-    float world_distance; // 4 bytes 164
-    float world_tilt; // 4 bytes     168
-    float world_north_angle; // 4 bytes 172
-    vec2 world_center_radian; // 8 bytes    176 | 184
-}; // 14 lines
-`;
-const Radian = Math.PI / 180.0;
-const _0vec3 = [0, 0, 0];
-export class CameraUniformBlockTotem {
-    id;
-    description;
-    gl;
-    globe;
-    ubo;
-    traslateFloat32;
-    mapWHFloat32;
-    _isMovedParams;
-    _normalizedCameraVector = [0, 0, 0]; // Normalized camera vector
-    // _frustumPlanes: any; // Uncomment and type if used
-    _aproximatedLOD = -1;
-    _globeChangeObserver = null;
-    constructor() {
-        this.id = "CameraUniformBlockTotem";
-        this.description =
-            `Sets a uniform block and provides buffer for it. The following is the glsl uniform block:` +
-                CameraUniformBlockString;
-        this.gl = null;
-        this.globe = null;
-        this.ubo = null;
-        // this._frustumPlanes = { ... }
-        this._isMovedParams = {
-            lastLod: null,
-            isMoved: false,
-        };
-        this.traslateFloat32 = new Float32Array(3);
-        this.mapWHFloat32 = new Float32Array(2);
-    }
-    init(globe, gl) {
-        this.gl = gl;
-        this.globe = globe;
-        this.ubo = this._createUBO();
-        this.traslateFloat32 = new Float32Array(3);
-        this.mapWHFloat32 = new Float32Array(2);
-        this._globeChangeObserver = new GlobeChangeObserver(globe);
-        this.setGeometry();
-        this.resize();
-    }
-    _createUBO() {
-        const gl = this.gl;
-        const ubo = gl.createBuffer();
-        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        // 184 bytes in reality. Overflow on linux for some reason. So, 200 bytes.
-        gl.bufferData(gl.UNIFORM_BUFFER, 200, gl.STREAM_DRAW);
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        return ubo;
-    }
-    resize() {
-        const gl = this.gl;
-        const globe = this.globe;
-        const ubo = this.ubo;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 152, new Float32Array([globe.api_ScrW(), globe.api_ScrH()]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setGeometry() {
-        const gl = this.gl;
-        const globe = this.globe;
-        const ubo = this.ubo;
-        const is3D = globe.api_GetCurrentGeometry() === 0 ? 1 : 0;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
-    }
-    draw3D(projection, modelView, translate) {
-        const gl = this.gl;
-        const traslateFloat32 = this.traslateFloat32;
-        const ubo = this.ubo;
-        const mapWHFloat32 = this.mapWHFloat32;
-        const globe = this.globe;
-        this._globeChangeObserver?.checkChanges();
-        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        // view, projection, translate
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
-        traslateFloat32.set([translate.x, translate.y, translate.z], 0);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 128, traslateFloat32);
-        // zoom level
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 160, new Float32Array([globe.api_GetCurrentLODWithDecimal()]));
-        // mapWH
-        if (globe.api_GetCurrentGeometry() === 1) {
-            const { width, height } = globe.api_GetCurrentWorldWH();
-            mapWHFloat32.set([width, height]);
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
-        }
-        // float world_distance; // 4 bytes 164
-        // float world_tilt; // 4 bytes     168
-        // float world_north_angle; // 4 bytes 172
-        // vec2 world_center_radian; // 8 bytes    180
-        const { CenterLong, CenterLat, Distance, Tilt, NorthAng } = globe.api_GetCurrentLookInfo();
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 164, new Float32Array([
-            Distance,
-            Radian * Tilt,
-            Radian * NorthAng,
-            Radian * CenterLong,
-            Radian * CenterLat,
-        ]));
-        // this._frustumPlanes = getFrustumPlanes(projection, translate);
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        // isMoved
-        const currentLOD = globe.api_GetCurrentLODWithDecimal();
-        this._isMovedParams.isMoved =
-            this._isMovedParams.lastLod !== currentLOD ||
-                globe.api_IsScreenMoving();
-        this._isMovedParams.lastLod = currentLOD;
-        this.__setCameraVectors();
-        // this._calculateAproximatedLOD();
-    }
-    __setCameraVectors() {
-        if (!this.globe) {
-            throw new Error("Globe is not initialized");
-        }
-        const globe = this.globe;
-        const currentGeom = globe.api_GetCurrentGeometry();
-        if (currentGeom === 0) {
-            const { Fp } = globe; // FUPos
-            const cameraVector = [Fp.x, Fp.y, Fp.z];
-            const length = Math.sqrt(cameraVector.reduce((sum, val) => sum + val * val, 0));
-            this._normalizedCameraVector[0] = cameraVector[0] / length;
-            this._normalizedCameraVector[1] = cameraVector[1] / length;
-            this._normalizedCameraVector[2] = cameraVector[2] / length;
-        }
-        else if (currentGeom === 1) {
-            const { CenterLong, CenterLat } = globe.api_GetCurrentLookInfo();
-            fromLongLatToUnitVector(_0vec3, [CenterLong * RADIAN, CenterLat * RADIAN]);
-            this._normalizedCameraVector[0] = _0vec3[0];
-            this._normalizedCameraVector[1] = _0vec3[1];
-            this._normalizedCameraVector[2] = _0vec3[2];
-        }
-    }
-    // TODO: cut implicits to the bottom
-    assignBindingPoint(program, bindingPoint) {
-        const gl = this.gl;
-        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-        gl.uniformBlockBinding(program, cameraBlockIndex, bindingPoint);
-    }
-    getUBO() {
-        return this.ubo;
-    }
-    bind(bindingPoint) {
-        const gl = this.gl;
-        const ubo = this.ubo;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
-    }
-    unbind(bindingPoint) {
-        const gl = this.gl;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
-    }
-    isMoved() {
-        return this._isMovedParams.isMoved;
-    }
-    getCameraVector() {
-        const globe = this.globe;
-        return [globe.Fp.x, globe.Fp.y, globe.Fp.z];
-    }
-    getNormalizedCameraVector() {
-        return this._normalizedCameraVector || _0vec3;
-    }
-    getCameraUpVector() {
-        const globe = this.globe;
-        return [globe.FUPos.x, globe.FUPos.y, globe.FUPos.z];
-    }
-    getLookAtVector() {
-        const globe = this.globe;
-        const { CenterLong, CenterLat } = globe.api_GetCurrentLookInfo();
-        const result = [0, 0, 0];
-        fromLongLatToUnitVector(result, [CenterLong * RADIAN, CenterLat * RADIAN]);
-        return result;
-    }
-    getGlobeChanges() {
-        return this._globeChangeObserver?.getChanges();
-    }
-    // getApproximatedLOD(): number {
-    //     return this._aproximatedLOD;
-    // }
-    // _calculateAproximatedLOD(){
-    //     const globe = this.globe!;
-    //     this._aproximatedLOD = approximatedZoomLevel(globe)
-    // }
-    free() {
-        const gl = this.gl;
-        const ubo = this.ubo;
-        gl.deleteBuffer(ubo);
-    }
-    readBuffer() {
-        const gl = this.gl;
-        const ubo = this.ubo;
-        const result = new Float32Array(41);
-        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        gl.getBufferSubData(gl.UNIFORM_BUFFER, 0, result);
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        return {
-            view: result.slice(0, 16),
-            projection: result.slice(16, 32),
-            translate: result.slice(32, 35),
-            is3D: result[35],
-            mapWH: result.slice(36, 38),
-            screenWH: result.slice(38, 40),
-            z_level: result[40],
-        };
-    }
-}
-export const CameraUniformBlockTotemCache = Object.freeze({
-    get: (globe) => {
-        return globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
-    },
-    release: (globe) => {
-        return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem);
-    },
-});
+    mat4 view; // 64 bytes                0
+    mat4 projection; // 64 bytes          64
+    vec3 translate; // 12 bytes           128
+    bool is3D; // 4 bytes                 140
+    vec2 mapWH; // 8 bytes                144
+    vec2 screenWH; //  8 bytes             152
+    float z_level; // 4 bytes                160 
+    float world_distance; // 4 bytes         164
+    float world_tilt; // 4 bytes             168
+    float world_north_angle; // 4 bytes      172
+    vec2 world_center_radian; // 8 bytes     176
+    float NaN; // padding to 16 bytes         184
+};  // 188 bytes total
+`;
+// TODO: Remove NaN
+const Radian = Math.PI / 180.0;
+
+const _0vec3: Vec3 = [0, 0, 0];
+
+interface GLContext extends WebGL2RenderingContext {
+    // Extend with any custom methods if needed
+}
+
+
+
+
+type TranslateVec3 = { x: number; y: number; z: number };
+
+export class CameraUniformBlockTotem {
+    id: string;
+    description: string;
+    gl: GLContext | null;
+    globe: Globe | null;
+    ubo: WebGLBuffer | null;
+    traslateFloat32: Float32Array;
+    mapWHFloat32: Float32Array;
+    _isMovedParams: { lastLod: number | null; isMoved: boolean };
+    _normalizedCameraVector: Vec3 = [0, 0, 0]; // Normalized camera vector
+    // _frustumPlanes: any; // Uncomment and type if used
+    _aproximatedLOD: number = -1;
+    _globeChangeObserver: GlobeChangeObserver | null = null;
+    private attachments: Set<CameraTotemAttachmentInterface> = new Set();
+
+    constructor() {
+        this.id = "CameraUniformBlockTotem";
+        this.description = `Provides and updates camera related uniform block
+Should be on top of DrawOrder.
+Attachments can register to process right after camera data is updated without creating other plugins listed on DrawOrder
+The following is the glsl uniform block: ${CameraUniformBlockString}`
+        this.gl = null;
+        this.globe = null;
+        this.ubo = null;
+        // this._frustumPlanes = { ... }
+        this._isMovedParams = {
+            lastLod: null,
+            isMoved: false,
+        };
+        this.traslateFloat32 = new Float32Array(3);
+        this.mapWHFloat32 = new Float32Array(2);
+    }
+
+    init(globe: Globe, gl: WebGL2RenderingContext) {
+        this.gl = gl;
+        this.globe = globe;
+        this.ubo = this._createUBO();
+        this.traslateFloat32 = new Float32Array(3);
+        this.mapWHFloat32 = new Float32Array(2);
+        this._globeChangeObserver = new GlobeChangeObserver(globe);
+        this.setGeometry();
+        this.resize();
+    }
+
+    _createUBO(): WebGLBuffer | null {
+        const gl = this.gl!;
+        const ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        // 184 bytes in reality. Overflow on linux for some reason. So, 200 bytes.
+        gl.bufferData(gl.UNIFORM_BUFFER, 200, gl.STREAM_DRAW);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        // assign NaN to padding float
+        gl.bufferSubData(
+            gl.UNIFORM_BUFFER, 184,
+            new Float32Array([NaN])
+        );
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return ubo;
+    }
+
+    resize() {
+        const gl = this.gl!;
+        const globe = this.globe!;
+        const ubo = this.ubo!;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(
+            gl.UNIFORM_BUFFER,
+            152,
+            new Float32Array([globe.api_ScrW(), globe.api_ScrH()])
+        );
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+
+    setGeometry() {
+        const gl = this.gl!;
+        const globe = this.globe!;
+        const ubo = this.ubo!;
+        const is3D = globe.api_GetCurrentGeometry() === 0 ? 1 : 0;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 140, new Float32Array([is3D]));
+    }
+
+    draw3D(projection: Float32Array, modelView: Float32Array, translate: TranslateVec3) {
+        const gl = this.gl!;
+        const traslateFloat32 = this.traslateFloat32;
+        const ubo = this.ubo!;
+        const mapWHFloat32 = this.mapWHFloat32;
+        const globe = this.globe!;
+        this._globeChangeObserver?.checkChanges();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        // view, projection, translate
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
+        traslateFloat32.set([translate.x, translate.y, translate.z], 0);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 128, traslateFloat32);
+        // zoom level
+        gl.bufferSubData(
+            gl.UNIFORM_BUFFER,
+            160,
+            new Float32Array([globe.api_GetCurrentLODWithDecimal()])
+        );
+        // mapWH
+        if (globe.api_GetCurrentGeometry() === 1) {
+            const { width, height } = globe.api_GetCurrentWorldWH();
+            mapWHFloat32.set([width, height]);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 144, mapWHFloat32);
+        }
+        // float world_distance; // 4 bytes 164
+        // float world_tilt; // 4 bytes     168
+        // float world_north_angle; // 4 bytes 172
+        // vec2 world_center_radian; // 8 bytes    180
+        const { CenterLong, CenterLat, Distance, Tilt, NorthAng } =
+            globe.api_GetCurrentLookInfo();
+        gl.bufferSubData(
+            gl.UNIFORM_BUFFER,
+            164,
+            new Float32Array([
+                Distance,
+                Radian * Tilt,
+                Radian * NorthAng,
+                Radian * CenterLong,
+                Radian * CenterLat,
+            ])
+        );
+
+        // this._frustumPlanes = getFrustumPlanes(projection, translate);
+
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+
+        // isMoved
+        const currentLOD = globe.api_GetCurrentLODWithDecimal();
+        this._isMovedParams.isMoved =
+            this._isMovedParams.lastLod !== currentLOD ||
+            globe.api_IsScreenMoving();
+        this._isMovedParams.lastLod = currentLOD;
+
+        this.__setCameraVectors();
+        // this._calculateAproximatedLOD();
+        for (const attachment of this.attachments) {
+            attachment.update();
+        }
+    }
+
+    __setCameraVectors() {
+        if (!this.globe) {
+            throw new Error("Globe is not initialized");
+        }
+        const globe = this.globe;
+        const currentGeom = globe.api_GetCurrentGeometry()
+        if (currentGeom === 0) {
+
+            const { Fp } = globe as Globe; // FUPos
+
+
+            const cameraVector = [Fp.x, Fp.y, Fp.z];
+            const length = Math.sqrt(
+                cameraVector.reduce((sum, val) => sum + val * val, 0)
+            );
+
+
+            this._normalizedCameraVector[0] = cameraVector[0] / length;
+            this._normalizedCameraVector[1] = cameraVector[1] / length;
+            this._normalizedCameraVector[2] = cameraVector[2] / length;
+        } else if (currentGeom === 1) {
+            const { CenterLong, CenterLat } = globe.api_GetCurrentLookInfo();
+
+            fromLongLatToUnitVector(
+                _0vec3,
+                [CenterLong * RADIAN, CenterLat * RADIAN]
+            );
+            this._normalizedCameraVector[0] = _0vec3[0];
+            this._normalizedCameraVector[1] = _0vec3[1];
+            this._normalizedCameraVector[2] = _0vec3[2];
+        }
+    }
+
+    // TODO: cut implicits to the bottom
+
+    assignBindingPoint(program: WebGLProgram, bindingPoint: number) {
+        const gl = this.gl!;
+        const cameraBlockIndex = gl.getUniformBlockIndex(
+            program,
+            "CameraUniformBlock"
+        );
+        gl.uniformBlockBinding(program, cameraBlockIndex, bindingPoint);
+    }
+
+    getUBO(): WebGLBuffer | null {
+        return this.ubo;
+    }
+
+
+    bind(bindingPoint: number) {
+        const gl = this.gl!;
+        const ubo = this.ubo!;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, ubo);
+    }
+
+    unbind(bindingPoint: number) {
+        const gl = this.gl!;
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    }
+
+    isMoved(): boolean {
+        return this._isMovedParams.isMoved;
+    }
+
+    getCameraVector(): Vec3 {
+        const globe = this.globe!;
+        return [globe.Fp.x, globe.Fp.y, globe.Fp.z];
+    }
+
+    getNormalizedCameraVector(): Vec3 {
+        return this._normalizedCameraVector || _0vec3;
+    }
+
+    getCameraUpVector(): Vec3 {
+        const globe = this.globe!;
+        return [globe.FUPos.x, globe.FUPos.y, globe.FUPos.z];
+    }
+
+
+    getLookAtVector(): Vec3 {
+        const globe = this.globe!;
+        const { CenterLong, CenterLat } = globe.api_GetCurrentLookInfo();
+        const result: Vec3 = [0, 0, 0];
+        fromLongLatToUnitVector(result, [CenterLong * RADIAN, CenterLat * RADIAN]);
+        return result;
+    }
+
+
+    getGlobeChanges(): GlobeChanges {
+        return this._globeChangeObserver?.getChanges()!;
+    }
+
+
+
+    registerAttachment(attachment: CameraTotemAttachmentInterface) {
+        this.attachments.add(attachment);
+    }
+
+    unregisterAttachment(attachment: CameraTotemAttachmentInterface) {
+        this.attachments.delete(attachment);
+    }
+
+
+
+
+
+    free() {
+        const gl = this.gl!;
+        const ubo = this.ubo!;
+        gl.deleteBuffer(ubo);
+
+        if (this.attachments.size > 0) {
+            throw new Error("There are still attachments registered to CameraUniformBlockTotem during free()");
+        }
+
+    }
+
+    readBuffer() {
+        const gl = this.gl!;
+        const ubo = this.ubo!;
+        const result = new Float32Array(41);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        gl.getBufferSubData(gl.UNIFORM_BUFFER, 0, result);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return {
+            view: result.slice(0, 16),
+            projection: result.slice(16, 32),
+            translate: result.slice(32, 35),
+            is3D: result[35],
+            mapWH: result.slice(36, 38),
+            screenWH: result.slice(38, 40),
+            z_level: result[40],
+        };
+    }
+}
+
+export const CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe: Globe) => {
+        return globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+    },
+    release: (globe: Globe) => {
+        return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem);
+    },
+});
+