@pirireis/webglobeplugins 0.12.0-alpha → 0.14.0-alpha

package/shape-on-terrain/arc/naive/plugin.js

@@ -1,205 +0,0 @@
-import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip";
-import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
-// import { populateFloat32Array } from "../../../util/jshelpers/data-filler";
-import { BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
-import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
-import { generateArcPoints } from "../../../Math/arc-cdf-points";
-import * as vec3 from "../../../Math/vec3";
-import * as arc from "../../../Math/arc";
-import { CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
-import { WORLD_RADIUS_3D } from "../../../Math/constants";
-const VERTEX_COUNT = 70;
-const INITAL_CAPACITY = 10;
-const _0vector = [0, 0, 0];
-const _attractionPoint = [0, 0, 0];
-const _start = [0, 0, 0];
-const _end = [0, 0, 0];
-const _0arc = arc.create([1, 0, 0], [0, 1, 0]); // zero arc for intersection tests
-let interval = 1;
-export class NaiveLineOnTerrainPlugin {
-    id;
-    program = null;
-    _bufferManagersCompMap = null;
-    _bufferManagersCompMapTest = null;
-    _bufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-    _testOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-    _opacity = 1;
-    _arcUBOHandler = null;
-    _vao = null;
-    _vaoAllTest = null;
-    _ubohandlerAllTest = null;
-    globe = null;
-    gl = null;
-    _arcMap;
-    _arcMapTest;
-    _doBuild = false;
-    _cameraUniformBlock = null;
-    _attractionStrength = 8;
-    constructor(id) {
-        this.id = id;
-        this._arcMap = new Map();
-        this._arcMapTest = new Map();
-    }
-    insertArcFromLongLat(key, startPoint, endPoint) {
-        if (this._arcMap.has(key)) {
-            this._arcMap.delete(key);
-        }
-        vec3.fromLongLatToUnitVector(_start, [startPoint.long * RADIANS, startPoint.lat * RADIANS]);
-        vec3.fromLongLatToUnitVector(_end, [endPoint.long * RADIANS, endPoint.lat * RADIANS]);
-        const _arc = arc.create(_start, _end);
-        this._arcMap.set(key, _arc);
-        this._arcMapTest.set(key, arc.clone(_arc));
-        this._doBuild = true;
-        this.globe.DrawRender();
-    }
-    deleteArcs(keys) {
-        for (const key of keys) {
-            if (this._arcMap.has(key)) {
-                this._arcMap.delete(key);
-            }
-        }
-        this._doBuild = true;
-        this.globe.DrawRender();
-    }
-    init(globe, gl) {
-        this.globe = globe;
-        this.gl = gl;
-        this.program = LineStripProgramCache.get(globe);
-        const g3D = globe3Dcoordinates(globe, 30);
-        const g2D = globe2Dcoordinates(globe);
-        this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
-        this._bufferManagersCompMap = new Map([
-            ["position3d", {
-                    bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-                    adaptor: (item) => {
-                        const { longLatArr } = item;
-                        const result = g3D(longLatArr, { paddingCount: 1 });
-                        // console.log("result", result);
-                        return result;
-                    }
-                }],
-            ["position2d", {
-                    bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-                    adaptor: (item) => {
-                        const { longLatArr } = item;
-                        return g2D(longLatArr, { paddingCount: 1 });
-                    }
-                }
-            ],
-        ]);
-        this._bufferManagersCompMapTest = new Map([
-            ["positionTest3d", {
-                    bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-                    adaptor: (item) => {
-                        const { longLatArr } = item;
-                        const result = g3D(longLatArr, { paddingCount: 1 });
-                        return result;
-                    }
-                }],
-            ["positionTest2d", {
-                    bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-                    adaptor: (item) => {
-                        const { longLatArr } = item;
-                        return g2D(longLatArr, { paddingCount: 1 });
-                    }
-                }
-            ]
-        ]);
-        this._bufferOrchestrator = new BufferOrchestrator();
-        this._arcUBOHandler = this.program.createUBO();
-        this._arcUBOHandler.update(new Map([
-            ["u_color", new Float32Array([1, 0, 0, 1])],
-        ]));
-        this._ubohandlerAllTest = this.program.createUBO();
-        this._ubohandlerAllTest.update(new Map([
-            ["u_color", new Float32Array([0, 0, 1, 1])],
-        ]));
-        this._vao = this.program.createVAO(createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d")?.bufferManager.buffer), createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d")?.bufferManager.buffer), null, null, null);
-        this._vaoAllTest = this.program.createVAO(createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d")?.bufferManager.buffer), createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d")?.bufferManager.buffer), null, null, null);
-    }
-    draw3D() {
-        // Drawing logic here
-        this._buildArcs(); // can be async
-        const { gl, program, _bufferOrchestrator, _vao, _arcUBOHandler, _vaoAllTest, _ubohandlerAllTest, _testOrchestrator } = this;
-        if (!gl || !program || !_bufferOrchestrator || !_vao || !_arcUBOHandler
-            || !_vaoAllTest || !_ubohandlerAllTest || !_testOrchestrator) {
-            console.warn("WebGL context, program, or buffer orchestrator is not initialized.");
-            return;
-        }
-        gl.disable(gl.DEPTH_TEST);
-        const drawOptions = {
-            drawRange: {
-                first: 0,
-                count: _bufferOrchestrator.length * (VERTEX_COUNT + 1)
-            },
-            indexes: null
-        };
-        program.draw(_vao, drawOptions, this._opacity, _arcUBOHandler);
-        gl.enable(gl.DEPTH_TEST);
-    }
-    _buildArcs() {
-        if (!this._doBuild)
-            return; // if not needed to build, return early
-        const { globe, _arcMap, _cameraUniformBlock, _bufferManagersCompMap } = this;
-        if (!globe || !_cameraUniformBlock || !_bufferManagersCompMap) {
-            console.warn("Globe or camera uniform block is not initialized.");
-            return;
-        }
-        const lookAtPosition = _cameraUniformBlock.getLookAtVector();
-        const cameraPosition = _cameraUniformBlock.getCameraVector();
-        vec3.divideScalar(cameraPosition, cameraPosition, WORLD_RADIUS_3D);
-        vec3.add(cameraPosition, cameraPosition, lookAtPosition);
-        // vec3.normalize(cameraPosition, cameraPosition);
-        vec3.divideScalar(cameraPosition, cameraPosition, 2);
-        // vec3.multiplyScalar(cameraPosition, cameraPosition, 1.3);
-        const _attractionStrength = (() => {
-            const lod = globe.api_GetCurrentLODWithDecimal();
-            if (lod < 11) {
-                return 1;
-            }
-            return lod * (lod - 8.5);
-        })();
-        console.log("Attraction strength: ", _attractionStrength);
-        const result = [];
-        const longLat = [0, 0];
-        for (const [key, arcInstance] of _arcMap) {
-            arc.copy(_0arc, arcInstance);
-            const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPosition);
-            if (!isOnArc) {
-                if (vec3.distanceSquared(cameraPosition, _0arc.p0) < vec3.distanceSquared(cameraPosition, _0arc.p1)) {
-                    vec3.copy(_attractionPoint, _0arc.p0);
-                }
-                else {
-                    vec3.copy(_attractionPoint, _0arc.p1);
-                }
-            }
-            const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, _attractionStrength);
-            const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-            for (let i = 0; i < generatedPoints.length; i++) {
-                const point = generatedPoints[i];
-                vec3.fromUnitVectorToLongLat(longLat, point);
-                longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
-            }
-            result.push({
-                key: key,
-                longLatArr: longLatArr,
-            });
-        }
-        this._bufferOrchestrator.resetWithCapacity(_bufferManagersCompMap, result.length);
-        this._bufferOrchestrator.insertBulk(result, _bufferManagersCompMap);
-        this._doBuild = false; // reset build flag
-        this._checkIfCorrupted(); // check if any arc is corrupted
-    }
-    _checkIfCorrupted() {
-        for (const [key, arcInstance] of this._arcMap) {
-            const copyarc = this._arcMapTest.get(key);
-            if (!copyarc) {
-                console.warn(`Arc with key ${key} is missing in the test map.`);
-                continue;
-            }
-            if (!arc.equals(arcInstance, copyarc)) {
-                console.warn(`Arc with key ${key} is corrupted: p0 and p1 are the same point.`);
-            }
-        }
-    }
-}

package/util/check/get.js

@@ -1,14 +0,0 @@
-export const mapGetOrThrow = (errorNote) => {
-    return (mapInstance, ids) => {
-        if (!ids)
-            throw new Error("There is no map keys to get");
-        const result = [];
-        for (let i = 0; i < ids.length; i++) {
-            const e = mapInstance.get(ids[i]);
-            if (e === undefined)
-                throw new Error(errorNote + " " + ids[i]);
-            result.push(e);
-        }
-        return result;
-    };
-};

package/util/gl-util/buffer/types.js

@@ -1 +0,0 @@
-"use strict";

package/util/gl-util/draw-options/types.js

@@ -1,15 +0,0 @@
-/**
- * @typedef DrawRange
- * @type {Object}
- * @property {int} first
- * @property {int} count
- *
- * @typedef DrawRangeIndexParams
- * @type {Object}
- * @property {null|DrawRange} drawRange
- * @property {null|ElementBuffer} elementBuffer
- * @property {null|indexType} indexType
- * @property {null|int} drawMode
- *
- */
-export {};

package/util/webglobjectbuilders1.js

@@ -1,219 +0,0 @@
-// export function createShader(gl, type, source) {
-//     const shader = gl.createShader(type);
-//     gl.shaderSource(shader, source);
-//     gl.compileShader(shader);
-//     if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-//         throw new Error(gl.getShaderInfoLog(shader));
-//     }
-//     return shader;
-// }
-export function createShader(gl, type, source) {
-    const shader = gl.createShader(type);
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-        const errorLog = gl.getShaderInfoLog(shader);
-        const shaderType = type === gl.VERTEX_SHADER ? 'VERTEX_SHADER' : 'FRAGMENT_SHADER';
-        const sourceWithLineNumbers = source.split('\n').map((line, i) => `${i + 1}: ${line}`).join('\n');
-        throw new Error(`Error compiling ${shaderType}:\n${errorLog}\nSource:\n${sourceWithLineNumbers}`);
-    }
-    return shader;
-}
-export function createProgram(gl, vertexSource, fragmentSource) {
-    const program = gl.createProgram();
-    const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexSource);
-    const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
-    gl.compileShader(vertexShader);
-    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
-        console.error(gl.getShaderInfoLog(vertexShader));
-        return;
-    }
-    gl.compileShader(fragmentShader);
-    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
-        console.error(gl.getShaderInfoLog(fragmentShader));
-        return;
-    }
-    gl.attachShader(program, vertexShader);
-    gl.attachShader(program, fragmentShader);
-    gl.linkProgram(program);
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-        console.error(gl.getProgramInfoLog(program));
-        return;
-    }
-    return program;
-}
-export function createProgramWrapper(gl, vertexSource, fragmentSource) {
-    const program = gl.createProgram();
-    const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexSource);
-    const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
-    gl.attachShader(program, vertexShader);
-    gl.attachShader(program, fragmentShader);
-    gl.linkProgram(program);
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-        // console.log(gl.getProgramInfoLog(program));
-        throw new Error(gl.getProgramInfoLog(program));
-    }
-    const wrapper = { program: program };
-    const numAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
-    for (let i = 0; i < numAttributes; i++) {
-        const attribute = gl.getActiveAttrib(program, i);
-        wrapper[attribute.name] = gl.getAttribLocation(program, attribute.name);
-    }
-    const numUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
-    for (let i = 0; i < numUniforms; i++) {
-        const uniform = gl.getActiveUniform(program, i);
-        wrapper[uniform.name] = gl.getUniformLocation(program, uniform.name);
-    }
-    return wrapper;
-}
-export function createTexture(gl, filter, data, width, height) {
-    const texture = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
-    if (data instanceof Uint8Array) {
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
-    }
-    else {
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, data);
-    }
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    return texture;
-}
-export function bindTexture(gl, texture, unit) {
-    gl.activeTexture(gl.TEXTURE0 + unit);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-}
-export function createBuffer(gl, data) {
-    const buffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-    return buffer;
-}
-export function bindAttribute(gl, buffer, attribute, numComponents) {
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.enableVertexAttribArray(attribute);
-    gl.vertexAttribPointer(attribute, numComponents, gl.FLOAT, false, 0, 0);
-}
-export function bindFramebuffer(gl, framebuffer, texture) {
-    if (texture) {
-        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
-    }
-    else {
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    }
-}
-export function decodeBase64(data) {
-    const binary_string = atob(data);
-    const len = binary_string.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-        bytes[i] = binary_string.charCodeAt(i);
-    }
-    return bytes;
-}
-export function createImageFromBase64(encodedData) {
-    const bytes = decodeBase64(encodedData);
-    const blob = new Blob([bytes.buffer], { type: "image/png" });
-    const urlCreator = window.URL || window.webkitURL;
-    const imageUrl = urlCreator.createObjectURL(blob);
-    const image = new Image();
-    image.src = imageUrl;
-    return image;
-}
-export function getColorRamp(colors) {
-    // console.log("getColorRamp", colors)
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    canvas.width = 256;
-    canvas.height = 1;
-    const gradient = ctx.createLinearGradient(0, 0, 256, 0);
-    for (const stop in colors) {
-        // console.log("stop", stop);
-        gradient.addColorStop(colors[stop][0], colors[stop][1]);
-        // Alttaki satir ile gradienti cevirip, shaderda ki `speed_t = 1.0 - speed_t`' kaldirdim.
-        // gradientin en dusuk olmasi gereken siyah - mavi aralikta, mor renk gozlemledim.
-        // gradient.addColorStop( 1.0 - colors[stop][0], colors[stop][1]);
-    }
-    ctx.fillStyle = gradient;
-    ctx.fillRect(0, 0, 256, 1);
-    return new Uint8Array(ctx.getImageData(0, 0, 256, 1).data);
-}
-export function getColorRampDiscrate(values, thresholds) {
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    canvas.width = 256;
-    canvas.height = 1;
-    const gap = 1.0 / 256;
-    const gradient = ctx.createLinearGradient(0, 0, 256, 0);
-    for (let i = 0; i < thresholds.length - 1; i++) {
-        gradient.addColorStop(thresholds[i], values[i]);
-        gradient.addColorStop(thresholds[i + 1] - gap, values[i]);
-    }
-    gradient.addColorStop(thresholds[thresholds.length - 1], values[values.length - 1]);
-    ctx.fillStyle = gradient;
-    ctx.fillRect(0, 0, 256, 1);
-    return new Uint8Array(ctx.getImageData(0, 0, 256, 1).data);
-}
-export function getColorRampInterpolated(values, thresholds) {
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    canvas.width = 256;
-    canvas.height = 1;
-    const gradient = ctx.createLinearGradient(0, 0, 256, 0);
-    // const gap = 1.0 / 256;
-    // gradient.addColorStop(thresholds[0], values[0]);
-    // gradient.addColorStop(thresholds[0] + gap, values[1]);
-    for (let i = 0; i < thresholds.length; i++) {
-        gradient.addColorStop(thresholds[i], values[i]);
-    }
-    // gradient.addColorStop(thresholds[thresholds.length - 1] - gap, values[values.length - 1]);
-    ctx.fillStyle = gradient;
-    ctx.fillRect(0, 0, 256, 1);
-    return new Uint8Array(ctx.getImageData(0, 0, 256, 1).data);
-}
-/**
- * values: n + 1 number of color hex values without alpha channel. Ex: ["#ff0000", "#00ff00", "#0000ff"]
- * thresholds: n number of thresholds. Ex: [0, 10, 20]
- * mode: [discrete, interpolated,]
- */
-export function getColorRampModed(values, thresholds, mode = "interpolated") {
-    if (mode === "discrete") {
-        return getColorRampDiscrate(values, thresholds);
-    }
-    else if (mode === "interpolated") {
-        return getColorRampInterpolated(values, thresholds);
-    }
-    else {
-        throw new Error("mode is not valid");
-    }
-}
-export function defaultColorRamp() {
-    const defaultRampColors = [
-        [0.0, '#5e4fa2'],
-        [0.15, '#3288bd'],
-        [0.20, '#66c2a5'],
-        [0.25, '#66c2a5'],
-        [0.3, '#abdda4'],
-        [0.4, '#e6f598'],
-        [0.5, '#fee08b'],
-        [0.6, '#fdae61'],
-        [0.7, '#f46d43'],
-        [1.0, '#ff1e13']
-    ];
-    return getColorRamp(defaultRampColors);
-}
-export function reloadCurrentGLProgram() {
-    return function (target, key, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = function () {
-            const gl = target.gl;
-            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-            originalMethod.apply(this, arguments);
-            gl.useProgram(currentProgram);
-        };
-    };
-}