@pirireis/webglobeplugins 0.9.6 → 0.9.7

package/bearing-line/plugin.js

@@ -1,512 +0,0 @@
-import { PieceOfPieProgramCache } from '../programs/rings/partial-ring/piece-of-pie';
-import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate-flexible';
-import { CircleCache as Circle3DCache } from '../programs/line-on-globe/circle-accurate-3d';
-import { CircleCache, EDGE_COUNT as flatCircleEdgeCount, centerCoords2dflatDataCreator } from '../programs/line-on-globe/circle-accurate-flat';
-import { BufferOrchestrator, BufferManager } from '../util/account';
-import { mapGetOrThrow } from "../util/check/get";
-import { populateFloat32Array } from "../util/jshelpers/data-filler";
-import { ContextTextWriter3 } from '../write-text/context-text3'
-import { constraintFloat, isBoolean } from '../util/check/typecheck';
-import { sphereCoord } from '../util/geometry';
-import { createBufferAndReadInfo } from '../util/gl-util/buffer/attribute-loader';
-
-export const RINGPARTIAL_DRAW_MODE = Object.freeze({
-    LINE_STRIP: "LINE_STRIP",
-    TRIANGLE_FAN: "TRIANGLE_FAN",
-});
-
-
-/**
-     * @typedef {{key, long, lat, endLong, endLat, bearingAngle, radius,  rgba:[4numbers], rgbaMode, bigRadius, dashRatio, dashOpacity, circleDashAngle}} BearingLineItem
-     * @property {string} key   
-     * @property {number} long
-     * @property {number} lat
-     * @property {number} endLong
-     * @property {number} endLat 
-     * @property {number} bearingAngle 0-360
-     * @property {number} radius angle ring radius
-     * @property {number} altitude in meters effects all parts of the item
-     * @property {Array<numbers>} rgba [r,g,b,a] 0-1
-     * @property {number} rgbaMode 0 constant, 1 fading, 2 hides angle ring
-     * @property {number} bigRadius undefined means it will be calculated from long, lat, endLong, endLat
-     * @property {number} dashRatio 0-1
-     * @property {number} dashOpacity 0-1
-     * @property {number} circleDashAngle 0-360
- */
-
-const textWriterGetOrThrow = mapGetOrThrow("BearingLine textContextInjection id does not exist in map")
-
-
-const radian = (degree) => degree * Math.PI / 180;
-
-const integralSec = (angle) => {
-    return Math.log(Math.tan(angle / 2 + Math.PI / 4));
-}
-
-
-const calculateStartAngle = (long, lat, endLong, endLat) => {
-    const dLat = (integralSec(endLat) - integralSec(lat)); // Because lines are strectes toward poles.
-    const dLong = endLong - long;
-
-    let angle = -Math.atan2(dLat, dLong);
-    return angle;
-}
-
-
-
-export default class BearingLinePlugin {
-    /**
-     * @param {*} id 
-     * @param {Map<[key, ContextTextWriter3]>} textWritersMap
-     */
-    constructor(id,
-        {
-            opacity = 1,
-            textWritersMap = new Map(),
-            textDataPreAdaptor = (x) => x,
-            drawVRM = true,
-            drawBearingLine = true,
-            drawAngleRing = true,
-            drawText = true,
-            circleFlatEdgeCount = flatCircleEdgeCount - 2
-        } = {}) {
-        this.id = id;
-        this._opacity = opacity;
-        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
-        this._checkTextContextWriterInjectionMap(textWritersMap);
-        this._textWritersMap = textWritersMap;
-        this._textWritersMap.forEach((writer) => writer.keyAdaptor = (item) => item.key);
-        this.drawVRM = drawVRM;
-        this.drawBearingLine = drawBearingLine;
-        this.drawAngleRing = drawAngleRing;
-        this._textDataPreAdaptor = textDataPreAdaptor;
-        this.drawText = drawText;
-        this._memoryForText = new Map();
-        this.circleFlatEdgeCount = circleFlatEdgeCount + 2;
-    }
-
-
-    setDoDrawVRM(bool) {
-        isBoolean(bool);
-        if (bool === this.drawVRM) return;
-        this.drawVRM = bool;
-        this.globe.DrawRender();
-    }
-
-
-    setDoDrawText(bool) {
-        isBoolean(bool);
-        if (bool === this.drawText) return;
-        this.drawText = bool;
-        this.globe.DrawRender();
-    }
-
-
-    setDoDrawText(bool) {
-        isBoolean(bool);
-        if (bool === this.drawText) return;
-        this.drawText = bool;
-        this.globe.DrawRender();
-    }
-
-
-    setDoDrawAngleRing(bool) {
-        isBoolean(bool);
-        if (bool === this.drawAngleRing) return;
-        this.drawAngleRing = bool;
-        this.globe.DrawRender();
-    }
-
-
-    setOpacity(opacity) {
-        constraintFloat(opacity, 0, 1);
-        this._opacity = opacity;
-        this._textWritersMap.forEach((writer) => writer.setOpacity(opacity));
-        this.globe.DrawRender();
-    }
-
-
-    /**
-
-     * @param {Array<BearingLineItem>} items 
-     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
-     */
-    insertBulk(items, { textWriterIDs = [] } = {}) {
-        const { globe, bufferOrchestrator, bufferManagersCompMap } = this;// angleTextContext, distanceTextContext,
-        const data = []
-        for (let item of items) {
-            data.push(this.__insertAdaptor(item));
-        }
-        bufferOrchestrator.insertBulk(data, bufferManagersCompMap);
-        this.__insertTexts(items, textWriterIDs);
-
-        globe.DrawRender();
-    }
-
-
-    /**
-     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
-     * @param {Array<string>} itemKeys | if empty, all texts will be updated.
-     */
-    updateText(textWriterIDs = [], itemKeys = null) {
-        const textWritersMap = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
-        if (itemKeys === null) {
-            this._memoryForText.forEach((item) => {
-                let _item = this._textDataPreAdaptor(item);
-                textWritersMap.forEach((writer) => writer.insertText(_item));
-            });
-        } else {
-            itemKeys.forEach((key) => {
-                let item = this._memoryForText.get(key);
-                if (item === undefined) return;
-                let _item = this._textDataPreAdaptor(item);
-                textWritersMap.forEach((writer) => writer.insertText(_item));
-            });
-        }
-        this.globe.DrawRender();
-    }
-
-
-    deleteBulk(keys) {
-        this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersCompMap);
-        for (const key of keys) {
-            this._memoryForText.delete(key);
-        }
-        this._deleteTexts(keys);
-        this.globe.DrawRender();
-    }
-
-
-    defrag() {// use with caution
-        this.bufferOrchestrator.defrag(this.bufferManagersCompMap);
-    }
-
-
-    /**
-     * @param {Array<{key, long, lat, endLong, endLat, bearingAngle}>} items
-     * @param {Array<string>} textWriterIDs | textWritersMap keys to be used for writing text.
-     */
-    updateCoordinatesBulk(items, { textWriterIDs = [] } = {}) {
-        const { globe, bufferOrchestrator, bufferManagersCompMap, } = this;
-        const data = []
-        for (let item of items) {
-            data.push(this.__updateCoordsAdaptor(item));
-        }
-        this.__insertTexts(items, textWriterIDs);
-        bufferOrchestrator.updateBulk(data, bufferManagersCompMap, ["centerCoords2d", "centerCoords3d", "targetCoords2d", "targetCoords3d",
-            "startAngle2d", "tailAngle2d", "startAngle3d", "tailAngle3d", "bearingTargetCoords2d", "bearingTargetCoords3d", "centerCoords2dflat",
-            "bigRadius", "radius"]);
-        globe.DrawRender();
-    }
-
-
-    /**
-     * 
-     * @param {Array<BearingLineItem>} items some colums EXCEPT positional ones
-     * @param {string} propertyIDs 
-     * @param {string} textWriterIDs 
-     * Do NOT send empty data if property ID of this data is entered or NaN is loaded to the buffer, resulting in an unwanted behaviour.
-     *{ textWriterIDs = []}
-     */
-    updatePartial(items, propertyIDs = [], { textWriterIDs = [] } = {}) {
-        if (propertyIDs.length === 0) console.warn("updatePartial is called with no target propertyIDs");
-        const fixedPropertyIDs = this.__fixPartialProperties(propertyIDs)
-        const { bufferOrchestrator, bufferManagersCompMap } = this;
-        bufferOrchestrator.updateBulk(items, bufferManagersCompMap, fixedPropertyIDs);
-        // patch to update text opacity
-        this.__insertTexts(items, textWriterIDs);
-        this.globe.DrawRender();
-    }
-
-    // Private methods
-
-    _checkTextContextWriterInjectionMap(textContextWriterInjectionMap) {
-        if (!(textContextWriterInjectionMap instanceof Map)) throw new Error("textContextWriterInjectionMap is not an instance of Map");
-        textContextWriterInjectionMap.forEach((v) => {
-            if (!(v instanceof ContextTextWriter3)) throw new Error("textContextWriterInjectionMap element is not an instance of ContextTextWriter3");
-        });
-    }
-
-
-    __insertTexts(items, textWriterIDs) {
-        const textWritersMap = textWriterGetOrThrow(this._textWritersMap, textWriterIDs);
-        for (const item of items) {
-            const oldItem = this._memoryForText.get(item.key);
-            let _item = oldItem !== undefined ? { ...oldItem, ...item } : item;
-            this._memoryForText.set(item.key, _item);
-            if (this._textDataPreAdaptor !== null) _item = this._textDataPreAdaptor(_item);
-            textWritersMap.forEach((writer) => writer.insertText(_item));
-        }
-    }
-
-
-    __insertAdaptor(item) {
-        const rgba = item.rgba !== undefined ? item.rgba : [0, 0, 0, 0];
-        const rgbaMode = item.rgbaMode !== undefined ? item.rgbaMode : 0;
-        const dashRatio = item.dashRatio !== undefined ? item.dashRatio : 1.0;
-        const dashOpacity = item.dashOpacity !== undefined ? item.dashOpacity : 0.9;
-        const circleDashAngle = item.circleDashAngle !== undefined ? item.circleDashAngle : 360;
-        const coordsData = this.__updateCoordsAdaptor(item);
-
-        return {
-            ...coordsData,
-            rgba,
-            dashRatio,
-            dashOpacity,
-            circleDashAngle,
-            rgbaMode
-        };
-    }
-
-
-    __updateCoordsAdaptor(item) {
-        const { globe } = this;
-        const lat = radian(item.lat)
-        const long = radian(item.long)
-        const endLat = radian(item.endLat)
-        const endLong = radian(item.endLong)
-        const altitude = (item.altitude ?? 0) / 1000;
-        const bigRadius = item.bigRadius ?? globe.Math.GetDist2D(item.long, item.lat, item.endLong, item.endLat);
-        const radius = item.radius !== undefined ? item.radius : bigRadius * 0.2;
-        const { long: bearingLong, lat: bearingLat } = globe.Math.FindPointByPolar(item.long, item.lat, bigRadius, item.bearingAngle)
-        const startAngle2d = calculateStartAngle(long, lat, endLong, endLat);
-        const bearingAngle2d = calculateStartAngle(long, lat, radian(bearingLong), radian(bearingLat))
-        let tailAngle2d = bearingAngle2d - startAngle2d;
-        if (tailAngle2d > 0) {
-            tailAngle2d -= Math.PI * 2;
-        }
-        const bearingAngle = radian(item.bearingAngle - 90);
-        const startAngleOfCircle = globe.Math.GetAzimuthAngle(item.long, item.lat, item.endLong, item.endLat) //startAngle2d * 180 / Math.PI;
-        const startAngle3d = radian(startAngleOfCircle) - radian(90);
-        let tailAngle3d = bearingAngle - startAngle3d;
-        if (tailAngle3d > 0) {
-            tailAngle3d -= Math.PI * 2;
-        }
-
-        const centerCoords2dflat = centerCoords2dflatDataCreator(globe, item.long, item.lat, item.endLong, item.endLat, { startAngleOfCircle, edgeCount: this.circleFlatEdgeCount });
-        return {
-            key: item.key,
-            lat: item.lat,
-            long: item.long,
-            endLat: item.endLat,
-            endLong: item.endLong,
-            altitude,
-            bearingAngle,
-            radius,
-            bigRadius,
-            startAngle2d,
-            tailAngle2d,
-            startAngle3d,
-            tailAngle3d,
-            bearingLong,
-            bearingLat,
-            centerCoords2dflat
-        };
-    }
-
-
-    __fixPartialProperties(propertyIDs) {
-        const s = new Set(["rgba", "dashOpacity", "circleDashAngle"]);
-        const result = []
-        for (const item of propertyIDs) {
-            result.push(item);
-            if (s.has(item)) {
-                result.push(item + "Mercator");
-            }
-        }
-        return result;
-    }
-
-    // Globe API
-
-    init(globe, gl) {
-        this.gl = gl;
-        this.globe = globe;
-        this.lineProgram = LineOnGlobeCache.get(globe);
-        this.pieceOfPieProgram = PieceOfPieProgramCache.get(globe);
-        this.circleProgram = CircleCache.get(globe);
-        this.circle3DProgram = Circle3DCache.get(globe);
-        const circleFlatEdgeCount = this.circleFlatEdgeCount
-        {
-
-            // createBuffers
-            const bufferType = "DYNAMIC_DRAW";
-            const initialCapacity = this.bufferOrchestrator.capacity;
-            this.bufferManagersCompMap = new Map(
-                [
-                    ["centerCoords2d", {
-                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)),
-                    }],
-                    ["centerCoords2dflat", {
-                        'bufferManager': new BufferManager(gl, circleFlatEdgeCount * 2, { bufferType, initialCapacity }),
-                        'adaptor': (item) => item.centerCoords2dflat,
-                    }],
-                    ["centerCoords3d", {
-                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
-                        'adaptor': (item) => sphereCoord(item.long, item.lat, globe, item.altitude),
-                    }],
-                    ["targetCoords2d", {
-                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.endLong, item.endLat))
-                    }],
-                    ["targetCoords3d", {
-                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
-                        'adaptor': (item) => sphereCoord(item.endLong, item.endLat, globe, item.altitude)
-                    }],
-                    ["bearingTargetCoords2d", {
-                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.bearingLong, item.bearingLat))
-                    }],
-                    ["bearingTargetCoords3d", {
-                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
-                        'adaptor': (item) => sphereCoord(item.bearingLong, item.bearingLat, globe, item.altitude)
-                    }],
-                    ["startAngle2d", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.startAngle2d])
-                    }],
-                    ["tailAngle2d", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.tailAngle2d])
-                    }],
-                    ["startAngle3d", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.startAngle3d])
-                    }],
-                    ["tailAngle3d", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.tailAngle3d])
-                    }],
-                    ["bearingDashRatio", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([0])
-                    }],
-                    ["rgba", {
-                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array(item.rgba)
-                    }],
-                    ["radius", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.radius])
-                    }],
-                    ["rgbaMode", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.rgbaMode])
-                    }],
-                    ["dashRatio", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.dashRatio])
-                    }],
-
-                    ["bigRadius", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.bigRadius])
-                    }],
-                    ["dashOpacity", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.dashOpacity]),
-                    }],
-                    ["circleDashAngle", {
-                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
-                        'adaptor': (item) => new Float32Array([item.circleDashAngle / 360]),
-                    }],
-                    // Mercator circle properties are duplicated for the sake of performance.
-                    ["rgbaMercator", {
-                        'bufferManager': new BufferManager(gl, 4 * circleFlatEdgeCount, { bufferType, initialCapacity }),
-                        'adaptor': (item) => populateFloat32Array.fillWithListData(circleFlatEdgeCount, item.rgba),
-                    }],
-                    ["circleDashAngleMercator", {
-                        'bufferManager': new BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
-                        'adaptor': (item) => populateFloat32Array.fillFloat32Array(circleFlatEdgeCount, item.circleDashAngle / 360),
-                    }],
-                    ["dashOpacityMercator", {
-                        'bufferManager': new BufferManager(gl, circleFlatEdgeCount, { bufferType, initialCapacity }),
-                        'adaptor': (item) => populateFloat32Array.fillFloat32Array(circleFlatEdgeCount, item.dashOpacity),
-                    }],
-                ]
-            );
-        }
-
-        const vaoOBJ = (key) => createBufferAndReadInfo(this.bufferManagersCompMap.get(key).bufferManager.buffer);
-        this.lineVao = this.lineProgram.createVAO(
-            ...['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashOpacity', 'dashOpacity', 'rgba'].map(
-                key => vaoOBJ(key)));
-        this.ringVao = this.pieceOfPieProgram.createVAO(
-            ...['centerCoords2d',
-                'centerCoords3d',
-                'startAngle2d',
-                'tailAngle2d',
-                'startAngle3d',
-                'tailAngle3d',
-                'rgba',
-                'radius',
-                'rgbaMode'].map(key => vaoOBJ(key)));
-        this.bearingLineVAO = this.lineProgram.createVAO(
-            ...['centerCoords2d', 'centerCoords3d', 'bearingTargetCoords2d', 'bearingTargetCoords3d', 'bearingDashRatio', 'dashOpacity', 'rgba'
-            ].map(key => vaoOBJ(key)));
-        this.circleVao = this.circleProgram.createVAO(
-            ...["centerCoords2dflat", "rgbaMercator", "circleDashAngleMercator", "dashOpacityMercator"
-            ].map(key => vaoOBJ(key)));
-        this.circle3DVao = this.circle3DProgram.createVAO(
-            ...["centerCoords3d", "targetCoords3d", "rgba", "circleDashAngle", "dashOpacity"
-            ].map(key => vaoOBJ(key)));
-    }
-
-
-    draw3D() {
-        const { gl } = this;
-        gl.disable(gl.DEPTH_TEST);
-        const is3D = this.globe.api_GetCurrentGeometry() === 0;
-        const drawRange = { first: 0, count: this.bufferOrchestrator.length }
-
-        this.lineProgram.draw(this.lineVao, { drawRange }, this._opacity);
-        if (this.drawAngleRing) {
-            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, RINGPARTIAL_DRAW_MODE.TRIANGLE_FAN);
-            this.pieceOfPieProgram.draw(this.bufferOrchestrator.length, this.ringVao, 360, this._opacity * 0.8, RINGPARTIAL_DRAW_MODE.LINE_STRIP);
-        }
-        if (this.drawBearingLine) {
-            // this.lineProgram.draw(this.bearingLineVAO, this.bufferOrchestrator.length, this._opacity );
-            this.lineProgram.draw(this.bearingLineVAO, { drawRange }, this._opacity);
-        }
-        if (this.drawVRM) {
-            if (is3D) {
-                this.circle3DProgram.draw(this.circle3DVao, this.bufferOrchestrator.length, this._opacity);
-            } else {
-                this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this.circleFlatEdgeCount, this._opacity);
-            }
-        }
-        if (this.drawText) {
-            this._textWritersMap.forEach((writer) => writer.draw());
-        }
-        gl.enable(gl.DEPTH_TEST);
-    }
-
-
-    free() {
-        if (this.isFreed) return;
-        this.bufferManagersCompMap.forEach(({ bufferManager, adaptor }) => {
-            bufferManager.free();
-        });
-        const { gl, globe } = this;
-        gl.deleteVertexArray(this.lineVao);
-        gl.deleteVertexArray(this.ringVao);
-        gl.deleteVertexArray(this.bearingLineVAO);
-        gl.deleteVertexArray(this.circleVao);
-        gl.deleteVertexArray(this.circle3DVao);
-        LineOnGlobeCache.release(globe);
-        PieceOfPieProgramCache.release(globe);
-        CircleCache.release(globe);
-        Circle3DCache.release(globe)
-        this.isFreed = true;
-    }
-
-
-    _deleteTexts(keys) {
-        this._textWritersMap.forEach((writer) => {
-            writer.deleteTextBulk(keys);
-        });
-    }
-}
-
-