@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/{programs/rings/partial-ring/piece-of-pie.ts → webglobeplugins/programs/rings/partial-ring/piece-of-pie.js}

@@ -1,72 +1,30 @@
-import { createProgram } from "../../../util/webglobjectbuilders";
-import { CameraUniformBlockTotem, CameraUniformBlockString } from "../../totems/index";
-import { noRegisterGlobeProgramCache, globeProgramCache } from "../../programcache";
-import { attributeLoader } from "../../../util/gl-util/buffer/attribute-loader";
-import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
-import { Globe, } from "../../../types";
-import { UBOHandler } from "../../../types";
-
-import {
-    POLE,
-    PI,
-    longLatRadToMercator,
-    mercatorXYToGLPosition,
-    longLatRadToCartesian3D,
-    circleLimpFromLongLatRadCenterCartesian3D_accurate,
-    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
-    //circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-    cartesian3DToGLPosition
-} from "../../../util/shaderfunctions/geometrytransformations";
-
-
-export type BufferObject = {
-    buffer: WebGLBuffer;
-    stride: number;
-    offset: number;
-}
-
-export type DrawMode = 'LINE_STRIP' | 'TRIANGLE_FAN';
-
-// interface DrawModeMap {
-//     readonly LINE_STRIP: 0;
-//     readonly TRIANGLE_FAN: 1;
-// }
-
-interface ProgramCache {
-    get: (globe: Globe) => Logic;
-    release: (globe: Globe) => void;
-}
-
-/**
- * TODO:
- * 1. Triangle face looks at screen. if rotation angle is positive the last vertex must be the faintest.
- * 
- */
-
-const uniformBindingPoints = {
-    camera: 0,
-    flexible: 1,
-};
-
-const flexibleBlockManager = new UniformBlockManager(
-    'FlexibleAttributes',
-    [
-        { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
-        { name: "u_opacity", type: "float", value: new Float32Array([1]) },
-
-    ],
-    uniformBindingPoints.flexible,
-);
-
-
-const drawModeMap = Object.freeze({
-    LINE_STRIP: 0,
-    TRIANGLE_FAN: 1,
-});
-
-//${ circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate }
-
-const vertexShaderSource: string = `#version 300 es
+import { createProgram } from "../../../util/webglobjectbuilders";
+import { CameraUniformBlockTotem, CameraUniformBlockString } from "../../totems/index";
+import { noRegisterGlobeProgramCache, globeProgramCache } from "../../programcache";
+import { attributeLoader } from "../../../util/gl-util/buffer/attribute-loader";
+import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
+import { POLE, PI, longLatRadToMercator, mercatorXYToGLPosition, longLatRadToCartesian3D, circleLimpFromLongLatRadCenterCartesian3D_accurate, circleLimpFromLongLatRadCenterMercatorCompass_accurate, 
+//circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
+cartesian3DToGLPosition } from "../../../util/shaderfunctions/geometrytransformations";
+/**
+ * TODO:
+ * 1. Triangle face looks at screen. if rotation angle is positive the last vertex must be the faintest.
+ *
+ */
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1,
+};
+const flexibleBlockManager = new UniformBlockManager('FlexibleAttributes', [
+    { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
+    { name: "u_opacity", type: "float", value: new Float32Array([1]) },
+], uniformBindingPoints.flexible);
+const drawModeMap = Object.freeze({
+    LINE_STRIP: 0,
+    TRIANGLE_FAN: 1,
+});
+//${ circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate }
+const vertexShaderSource = `#version 300 es
 
 ${CameraUniformBlockString} 
 ${PI} 
@@ -156,9 +114,8 @@ void main() {
     }
 
     gl_PointSize = 10.0;
-}`;
-
-const fragmentShaderSource: string = `#version 300 es` + POLE + PI + `
+}`;
+const fragmentShaderSource = `#version 300 es` + POLE + PI + `
 precision highp float;
 in vec4 v_color;
 in vec2 v_pos;
@@ -167,153 +124,126 @@ void main() {
 
     if ( v_pos.x < -POLE || v_pos.x > POLE || v_pos.y < -POLE || v_pos.y > POLE ) { discard; }
     outColor = v_color;
-}`;
-
-export const ITEM_SIZE: number = 10;
-
-export class Logic {
-    private globe: Globe;
-    private gl: WebGL2RenderingContext;
-    private _lastMode: number;
-    private _lastEdgeCount: number;
-    private _lastAlphaMultiplier: number;
-    private program: WebGLProgram;
-    private _edgeCountLocation: WebGLUniformLocation | null;
-    private _draw_modeLocation: WebGLUniformLocation | null;
-    private cameraBlockBindingPoint: number;
-    private cameraBlockTotem: any; // Type this based on your CameraUniformBlockTotem implementation
-    private _ubosPublished: UBOHandler[] = [];
-    private _defaultFlexibleUBO: UBOHandler;
-    constructor(globe: Globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this._lastMode = 0;
-        this._lastEdgeCount = 64;
-        this._lastAlphaMultiplier = 1.0;
-
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
-        const { gl, program } = this;
-        // set attributes locations 
-        gl.bindAttribLocation(program, 0, 'center2d');
-        gl.bindAttribLocation(program, 1, 'center3d')
-        gl.bindAttribLocation(program, 2, 'start_angle2d');
-        gl.bindAttribLocation(program, 3, 'tail_angle2d');
-        gl.bindAttribLocation(program, 4, 'start_angle3d');
-        gl.bindAttribLocation(program, 5, 'tail_angle3d');
-        gl.bindAttribLocation(program, 6, 'color');
-        gl.bindAttribLocation(program, 7, 'radius');
-        gl.bindAttribLocation(program, 8, 'filling_mode');
-        // vao
-        // instanced draw read 1 
-        // Uniforms
-        this._edgeCountLocation = gl.getUniformLocation(program, 'edge_count');
-        this._draw_modeLocation = gl.getUniformLocation(program, 'draw_mode');
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(program);
-        gl.uniform1i(this._draw_modeLocation!, this._lastMode);
-        gl.uniform1f(this._edgeCountLocation!, this._lastEdgeCount);
-
-        this.cameraBlockBindingPoint = 0;
-        this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
-        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-        gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
-
-        flexibleBlockManager.assignBindingPoint(gl, program);
-        this._defaultFlexibleUBO = flexibleBlockManager.createUBO(gl);
-        gl.useProgram(currentProgram);
-    }
-
-    draw(
-        length: number,
-        vao: WebGLVertexArrayObject,
-        edgeCount: number,
-        drawMode: DrawMode,
-        ubo: UBOHandler | null = null): void {
-        const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
-
-        gl.useProgram(program);
-        if (drawModeMap[drawMode] !== this._lastMode) {
-            gl.uniform1i(this._draw_modeLocation!, drawModeMap[drawMode]);
-            this._lastMode = drawModeMap[drawMode];
-        }
-        if (edgeCount !== this._lastEdgeCount) {
-            gl.uniform1f(this._edgeCountLocation!, edgeCount);
-            this._lastEdgeCount = edgeCount;
-        }
-
-        if (ubo) {
-            ubo.bind();
-        } else {
-            this._defaultFlexibleUBO.bind();
-        }
-        const overdraw = drawModeMap[drawMode];
-        cameraBlockTotem.bind(cameraBlockBindingPoint);
-        gl.bindVertexArray(vao);
-        gl.drawArraysInstanced(gl[drawMode], 0, edgeCount + overdraw, length);
-        cameraBlockTotem.unbind(cameraBlockBindingPoint);
-        gl.bindVertexArray(null);
-        if (ubo) {
-            ubo.unbind();
-        } else {
-            this._defaultFlexibleUBO.unbind();
-        }
-    }
-
-    free(): void {
-        noRegisterGlobeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
-        this.gl.deleteProgram(this.program);
-        this._defaultFlexibleUBO.free();
-        this._ubosPublished.forEach(ubo => ubo.free()); // TODO: can be called 2 times. is it a problem?
-        this.program = null!;
-    }
-
-    /**
-     * in vec2 center; // long, lat in radian
-    in float start_angle; // the start of partial circle from bearing point
-    in float tail_angle; // the rotation of the partial circle
-    in vec4 color;
-    in float radius; // in meter
-    in float filling_mode; // 0.0: constant, 1.0: fading, 2.0: hide
-     */
-
-    createVAO(
-        center2dObj: BufferObject,
-        center3dObj: BufferObject,
-        startAngle2DObj: BufferObject,
-        tailAngle2DObj: BufferObject,
-        startAngle3DObj: BufferObject,
-        tailAngle3DObj: BufferObject,
-        colorObj: BufferObject,
-        radiusObj: BufferObject,
-        colorModeObj: BufferObject
-    ): WebGLVertexArrayObject {
-        const { gl } = this;
-        const vao = gl.createVertexArray()!;
-        gl.bindVertexArray(vao);
-        attributeLoader(gl, center2dObj, 0, 2, { divisor: 1 });
-        attributeLoader(gl, center3dObj, 1, 3, { divisor: 1 });
-        attributeLoader(gl, startAngle2DObj, 2, 1, { divisor: 1 });
-        attributeLoader(gl, tailAngle2DObj, 3, 1, { divisor: 1 });
-        attributeLoader(gl, startAngle3DObj, 4, 1, { divisor: 1 });
-        attributeLoader(gl, tailAngle3DObj, 5, 1, { divisor: 1 });
-        attributeLoader(gl, colorObj, 6, 4, { divisor: 1, escapeValues: [-1.0, -1.0, -1.0, -1.0] });
-        attributeLoader(gl, radiusObj, 7, 1, { divisor: 1, escapeValues: [-1.0] });
-        attributeLoader(gl, colorModeObj, 8, 1, { divisor: 1, escapeValues: [-1.0] });
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return vao;
-    }
-
-
-    createUBO() {
-        const { gl } = this;
-        const ubo = flexibleBlockManager.createUBO(gl, "STATIC_DRAW");
-        this._ubosPublished.push(ubo);
-        return ubo;
-    }
-}
-
-export const PieceOfPieProgramCache: ProgramCache = Object.freeze({
-    get: (globe: Globe): Logic => noRegisterGlobeProgramCache.getProgram(globe, Logic),
-    release: (globe: Globe): void => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
-});
+}`;
+export const ITEM_SIZE = 10;
+export class Logic {
+    globe;
+    gl;
+    _lastMode;
+    _lastEdgeCount;
+    _lastAlphaMultiplier;
+    program;
+    _edgeCountLocation;
+    _draw_modeLocation;
+    cameraBlockBindingPoint;
+    cameraBlockTotem; // Type this based on your CameraUniformBlockTotem implementation
+    _ubosPublished = [];
+    _defaultFlexibleUBO;
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastMode = 0;
+        this._lastEdgeCount = 64;
+        this._lastAlphaMultiplier = 1.0;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        // set attributes locations 
+        gl.bindAttribLocation(program, 0, 'center2d');
+        gl.bindAttribLocation(program, 1, 'center3d');
+        gl.bindAttribLocation(program, 2, 'start_angle2d');
+        gl.bindAttribLocation(program, 3, 'tail_angle2d');
+        gl.bindAttribLocation(program, 4, 'start_angle3d');
+        gl.bindAttribLocation(program, 5, 'tail_angle3d');
+        gl.bindAttribLocation(program, 6, 'color');
+        gl.bindAttribLocation(program, 7, 'radius');
+        gl.bindAttribLocation(program, 8, 'filling_mode');
+        // vao
+        // instanced draw read 1 
+        // Uniforms
+        this._edgeCountLocation = gl.getUniformLocation(program, 'edge_count');
+        this._draw_modeLocation = gl.getUniformLocation(program, 'draw_mode');
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        gl.uniform1i(this._draw_modeLocation, this._lastMode);
+        gl.uniform1f(this._edgeCountLocation, this._lastEdgeCount);
+        this.cameraBlockBindingPoint = 0;
+        this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        flexibleBlockManager.assignBindingPoint(gl, program);
+        this._defaultFlexibleUBO = flexibleBlockManager.createUBO(gl);
+        gl.useProgram(currentProgram);
+    }
+    draw(length, vao, edgeCount, drawMode, ubo = null) {
+        const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        gl.useProgram(program);
+        if (drawModeMap[drawMode] !== this._lastMode) {
+            gl.uniform1i(this._draw_modeLocation, drawModeMap[drawMode]);
+            this._lastMode = drawModeMap[drawMode];
+        }
+        if (edgeCount !== this._lastEdgeCount) {
+            gl.uniform1f(this._edgeCountLocation, edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        if (ubo) {
+            ubo.bind();
+        }
+        else {
+            this._defaultFlexibleUBO.bind();
+        }
+        const overdraw = drawModeMap[drawMode];
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        gl.drawArraysInstanced(gl[drawMode], 0, edgeCount + overdraw, length);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        gl.bindVertexArray(null);
+        if (ubo) {
+            ubo.unbind();
+        }
+        else {
+            this._defaultFlexibleUBO.unbind();
+        }
+    }
+    free() {
+        noRegisterGlobeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+        this.gl.deleteProgram(this.program);
+        this._defaultFlexibleUBO.free();
+        this._ubosPublished.forEach(ubo => ubo.free()); // TODO: can be called 2 times. is it a problem?
+        this.program = null;
+    }
+    /**
+     * in vec2 center; // long, lat in radian
+    in float start_angle; // the start of partial circle from bearing point
+    in float tail_angle; // the rotation of the partial circle
+    in vec4 color;
+    in float radius; // in meter
+    in float filling_mode; // 0.0: constant, 1.0: fading, 2.0: hide
+     */
+    createVAO(center2dObj, center3dObj, startAngle2DObj, tailAngle2DObj, startAngle3DObj, tailAngle3DObj, colorObj, radiusObj, colorModeObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        attributeLoader(gl, center2dObj, 0, 2, { divisor: 1 });
+        attributeLoader(gl, center3dObj, 1, 3, { divisor: 1 });
+        attributeLoader(gl, startAngle2DObj, 2, 1, { divisor: 1 });
+        attributeLoader(gl, tailAngle2DObj, 3, 1, { divisor: 1 });
+        attributeLoader(gl, startAngle3DObj, 4, 1, { divisor: 1 });
+        attributeLoader(gl, tailAngle3DObj, 5, 1, { divisor: 1 });
+        attributeLoader(gl, colorObj, 6, 4, { divisor: 1, escapeValues: [-1.0, -1.0, -1.0, -1.0] });
+        attributeLoader(gl, radiusObj, 7, 1, { divisor: 1, escapeValues: [-1.0] });
+        attributeLoader(gl, colorModeObj, 8, 1, { divisor: 1, escapeValues: [-1.0] });
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+    createUBO() {
+        const { gl } = this;
+        const ubo = flexibleBlockManager.createUBO(gl, "STATIC_DRAW");
+        this._ubosPublished.push(ubo);
+        return ubo;
+    }
+}
+export const PieceOfPieProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/webglobeplugins/programs/totems/attachments/adaptive-opacity.js

@@ -0,0 +1,131 @@
+import { noRegisterGlobeProgramCache } from "../../programcache";
+import { CameraUniformBlockTotemCache } from "../camerauniformblock";
+const epsilon = 0.1;
+export function createSmoothstepOpacityPolicy(minZoom = 4, maxZoom = 12) {
+    const denom = maxZoom - minZoom;
+    if (!Number.isFinite(denom) || denom === 0) {
+        throw new Error("createSmoothstepOpacityPolicy: invalid zoom range");
+    }
+    const smoothstep = (x) => x * x * (3 - 2 * x);
+    return (zoomLevel) => {
+        const t = (zoomLevel - minZoom) / denom;
+        const c = Math.min(1, Math.max(0, t));
+        return 1 - smoothstep(c);
+    };
+}
+/**
+ * Hysteresis policy: reduces flicker by using separate enter/exit zooms.
+ * Example: fade-in begins at enterStart, but won’t fade-out until exitEnd.
+ */
+export function createHysteresisOpacityPolicy(params) {
+    const { enterStart, enterEnd, exitStart, exitEnd } = params;
+    if (!(exitEnd <= exitStart && exitStart <= enterStart && enterStart <= enterEnd)) {
+        throw new Error("createHysteresisOpacityPolicy: expected exitEnd <= exitStart <= enterStart <= enterEnd");
+    }
+    const lerp01 = (x, a, b) => {
+        if (a === b)
+            return x >= b ? 1 : 0;
+        const t = (x - a) / (b - a);
+        return Math.min(1, Math.max(0, t));
+    };
+    return (zoomLevel, prevOpacity) => {
+        // If we were mostly “off”, only allow rising once we hit the enter band.
+        if (prevOpacity <= 0.5) {
+            if (zoomLevel <= exitStart)
+                return lerp01(zoomLevel, exitEnd, exitStart) * 0; // clamp to 0 band
+            if (zoomLevel < enterStart)
+                return 0;
+            return lerp01(zoomLevel, enterStart, enterEnd);
+        }
+        // If we were mostly “on”, only allow falling once we hit the exit band.
+        if (zoomLevel >= enterStart)
+            return lerp01(zoomLevel, enterStart, enterEnd);
+        if (zoomLevel > exitStart)
+            return 1;
+        // decreasing band
+        return 1 - lerp01(zoomLevel, exitEnd, exitStart);
+    };
+}
+/**
+ * Curve policy: caller supplies any curve f(t) where t is normalized [0..1].
+ * This is the most flexible option (e.g., gamma, custom spline, etc.).
+ */
+export function createCurveOpacityPolicy(params) {
+    const { minZoom, maxZoom, curve } = params;
+    const denom = maxZoom - minZoom;
+    if (!Number.isFinite(denom) || denom === 0) {
+        throw new Error("createCurveOpacityPolicy: invalid zoom range");
+    }
+    return (zoomLevel) => {
+        const t = (zoomLevel - minZoom) / denom;
+        const c = Math.min(1, Math.max(0, t));
+        const y = curve(c);
+        return Math.min(1, Math.max(0, y));
+    };
+}
+class AdaptiveOpacityAttachment {
+    globe;
+    cameraUniformBlock;
+    lastZoomLevel = -1;
+    isChangedFlag = false;
+    registry = new Map();
+    defaultAdaptiveOpacityPolicy = createSmoothstepOpacityPolicy(5.5, 7);
+    constructor(globe) {
+        this.globe = globe;
+        this.cameraUniformBlock = CameraUniformBlockTotemCache.get(this.globe);
+        this.cameraUniformBlock.registerAttachment(this);
+    }
+    update() {
+        const zoomLevel = this.globe.api_GetCurrentLODWithDecimal();
+        if (epsilon > Math.abs(this.lastZoomLevel - zoomLevel)) {
+            this._setIsChanged(false);
+            return;
+        }
+        ;
+        this._setIsChanged(true);
+        this.lastZoomLevel = zoomLevel;
+        this.registry.forEach((plugin) => {
+            plugin.__adaptiveOpacity_set((plugin.__adaptivePolicy || this.defaultAdaptiveOpacityPolicy)(zoomLevel, plugin.__adaptiveOpacity));
+        });
+    }
+    registerPlugin(plugin) {
+        if (this.registry.has(plugin.id)) {
+            return false;
+        }
+        this.registry.set(plugin.id, plugin);
+        plugin.__adaptiveOpacity_set((plugin.__adaptivePolicy ||
+            this.defaultAdaptiveOpacityPolicy)(this.lastZoomLevel));
+        return true;
+    }
+    unregisterPlugin(plugin) {
+        if (!this.registry.has(plugin.id)) {
+            return false;
+        }
+        this.registry.delete(plugin.id);
+        return true;
+    }
+    _setIsChanged(value) {
+        this.isChangedFlag = value;
+    }
+    get isChanged() {
+        return this.isChangedFlag;
+    }
+    free() {
+        this.cameraUniformBlock.unregisterAttachment(this);
+    }
+}
+export const AdaptiveOpacityAttachmentObserver = Object.freeze({
+    subscribe: (subscriber) => {
+        const attachment = noRegisterGlobeProgramCache.getProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        if (!attachment.registerPlugin(subscriber)) {
+            noRegisterGlobeProgramCache.releaseProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        }
+    },
+    unsubscribe: (subscriber) => {
+        const attachment = noRegisterGlobeProgramCache.getProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        if (attachment.unregisterPlugin(subscriber)) {
+            subscriber.__adaptiveOpacity_set(1);
+            noRegisterGlobeProgramCache.releaseProgram(subscriber.globe, AdaptiveOpacityAttachment);
+        }
+    }
+});