@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/{programs/vectorfields/pingpongbuffermanager.ts → webglobeplugins/programs/vectorfields/pingpongbuffermanager.js}

@@ -1,113 +1,99 @@
-/**
- * Manages PingPong Buffers.
- * Updated positions are written to the target buffer.
- * Then source and target buffers are swapped.
- * 
- * update coords and draw particles programs will use this class.
- */
-
-export class PingPongBufferManager {
-    public readonly gl: WebGL2RenderingContext;
-    public length: number;
-    
-    private readonly _inPositionLocation: number;
-    private readonly _buffers: [WebGLBuffer, WebGLBuffer];
-    private readonly _tfs: [WebGLTransformFeedback, WebGLTransformFeedback];
-    private readonly _vaos: [WebGLVertexArrayObject, WebGLVertexArrayObject];
-    private _index: number;
-
-    constructor(gl: WebGL2RenderingContext, particleCount: number, inPositionLocation: number = 0) {
-        this.gl = gl;
-        this._inPositionLocation = inPositionLocation;
-        this._buffers = [gl.createBuffer()!, gl.createBuffer()!];
-        this._tfs = this._createTransformFeedbacksAndBindBuffers();
-        this._vaos = this._createVaos();
-        this.length = 0;
-        this.setParticleCount(particleCount);
-        this._index = 0;
-    }
-
-    public setParticleCount(count: number): void {
-        const gl = this.gl;
-        this.length = count;
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[0]);
-        gl.bufferData(gl.ARRAY_BUFFER, randomNumbers(this.length * 2), gl.DYNAMIC_DRAW);
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[1]);
-        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(this.length * 2), gl.DYNAMIC_DRAW);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        this._index = 0;
-    }
-
-    private _createTransformFeedbacksAndBindBuffers(): [WebGLTransformFeedback, WebGLTransformFeedback] {
-        const gl = this.gl;
-        const tfs: [WebGLTransformFeedback, WebGLTransformFeedback] = [
-            gl.createTransformFeedback()!,
-            gl.createTransformFeedback()!
-        ];
-        tfs.forEach((tf, idx) => {
-            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf);
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this._buffers[idx]);
-        });
-        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
-        return tfs;
-    }
-
-    private _createVaos(): [WebGLVertexArrayObject, WebGLVertexArrayObject] {
-        const gl = this.gl;
-        const vaos: [WebGLVertexArrayObject, WebGLVertexArrayObject] = [
-            gl.createVertexArray()!,
-            gl.createVertexArray()!
-        ];
-        vaos.forEach((vao, idx) => {
-            gl.bindVertexArray(vao);
-            gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[idx]);
-            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-            gl.vertexAttribDivisor(0, 1);
-            gl.enableVertexAttribArray(this._inPositionLocation);
-            gl.bindVertexArray(null);
-        });
-        return vaos;
-    }
-
-    public getSourceVao(): WebGLVertexArrayObject {
-        return this._vaos[this._index];
-    }
-
-    public getTargetVao(): WebGLVertexArrayObject {
-        return this._vaos[1 - this._index];
-    }
-
-    public sourceBuffer(): WebGLBuffer {
-        return this._buffers[this._index];
-    }
-
-    public targetBuffer(): WebGLBuffer {
-        return this._buffers[1 - this._index];
-    }
-
-    public getTargetTF(): WebGLTransformFeedback {
-        return this._tfs[1 - this._index];
-    }
-
-    public swap(): void {
-        this._index = 1 - this._index;
-    }
-
-    public free(): void {
-        this.gl.deleteBuffer(this._buffers[0]);
-        this.gl.deleteBuffer(this._buffers[1]);
-        this.gl.deleteTransformFeedback(this._tfs[0]);
-        this.gl.deleteTransformFeedback(this._tfs[1]);
-        this.gl.deleteVertexArray(this._vaos[0]);
-        this.gl.deleteVertexArray(this._vaos[1]);
-    }
-}
-
-function randomNumbers(count: number): Float32Array {
-    const result = new Float32Array(count);
-    const random = Math.random;
-    for (let i = 0; i < count; i++) {
-        result[i] = random() * 2 - 1;
-    }
-    return result;
-}
+/**
+ * Manages PingPong Buffers.
+ * Updated positions are written to the target buffer.
+ * Then source and target buffers are swapped.
+ *
+ * update coords and draw particles programs will use this class.
+ */
+export class PingPongBufferManager {
+    gl;
+    length;
+    _inPositionLocation;
+    _buffers;
+    _tfs;
+    _vaos;
+    _index;
+    constructor(gl, particleCount, inPositionLocation = 0) {
+        this.gl = gl;
+        this._inPositionLocation = inPositionLocation;
+        this._buffers = [gl.createBuffer(), gl.createBuffer()];
+        this._tfs = this._createTransformFeedbacksAndBindBuffers();
+        this._vaos = this._createVaos();
+        this.length = 0;
+        this.setParticleCount(particleCount);
+        this._index = 0;
+    }
+    setParticleCount(count) {
+        const gl = this.gl;
+        this.length = count;
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[0]);
+        gl.bufferData(gl.ARRAY_BUFFER, randomNumbers(this.length * 2), gl.DYNAMIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[1]);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(this.length * 2), gl.DYNAMIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this._index = 0;
+    }
+    _createTransformFeedbacksAndBindBuffers() {
+        const gl = this.gl;
+        const tfs = [
+            gl.createTransformFeedback(),
+            gl.createTransformFeedback()
+        ];
+        tfs.forEach((tf, idx) => {
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this._buffers[idx]);
+        });
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        return tfs;
+    }
+    _createVaos() {
+        const gl = this.gl;
+        const vaos = [
+            gl.createVertexArray(),
+            gl.createVertexArray()
+        ];
+        vaos.forEach((vao, idx) => {
+            gl.bindVertexArray(vao);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[idx]);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+            gl.vertexAttribDivisor(0, 1);
+            gl.enableVertexAttribArray(this._inPositionLocation);
+            gl.bindVertexArray(null);
+        });
+        return vaos;
+    }
+    getSourceVao() {
+        return this._vaos[this._index];
+    }
+    getTargetVao() {
+        return this._vaos[1 - this._index];
+    }
+    sourceBuffer() {
+        return this._buffers[this._index];
+    }
+    targetBuffer() {
+        return this._buffers[1 - this._index];
+    }
+    getTargetTF() {
+        return this._tfs[1 - this._index];
+    }
+    swap() {
+        this._index = 1 - this._index;
+    }
+    free() {
+        this.gl.deleteBuffer(this._buffers[0]);
+        this.gl.deleteBuffer(this._buffers[1]);
+        this.gl.deleteTransformFeedback(this._tfs[0]);
+        this.gl.deleteTransformFeedback(this._tfs[1]);
+        this.gl.deleteVertexArray(this._vaos[0]);
+        this.gl.deleteVertexArray(this._vaos[1]);
+    }
+}
+function randomNumbers(count) {
+    const result = new Float32Array(count);
+    const random = Math.random;
+    for (let i = 0; i < count; i++) {
+        result[i] = random() * 2 - 1;
+    }
+    return result;
+}

package/{range-tools-on-terrain/bearing-line/adapters.ts → webglobeplugins/range-tools-on-terrain/bearing-line/adapters.js}

@@ -1,154 +1,114 @@
-import { ImplicitBearingLineInput } from './types';
-
-
-import { LineInput } from "../../semiplugins/lightweight/line-plugin";
-import { PieceOfPiePluginInput } from "../../semiplugins/lightweight/piece-of-pie-plugin";
-import { CircleInput } from "../../semiplugins/shape-on-terrain/circle-plugin";
-import { ArcInput } from "../../semiplugins/shape-on-terrain/arc-plugin";
-import { Globe, Color } from "../../types";
-
-
-const radian = (degree: number) => degree * Math.PI / 180;
-
-const calculateStartAngle = (long: number, lat: number, endLong: number, endLat: number) => {
-    const dLat = (integralSec(endLat) - integralSec(lat)); // Because lines are strectes toward poles.
-    const dLong = endLong - long;
-    let angle = -Math.atan2(dLat, dLong);
-    return angle;
-}
-
-const integralSec = (angle: number) => {
-    return Math.log(Math.tan(angle / 2 + Math.PI / 4));
-}
-
-
-export const flatLinesInputAdapter = (bearingLine: ImplicitBearingLineInput): LineInput => {
-    const { long, lat, endLong, endLat, rgba } = bearingLine;
-    return {
-        key: bearingLine.key,
-        start: [long, lat],
-        end: [endLong, endLat],
-        color: rgba as Color,
-    };
-}
-
-
-
-export const flatLinesBearingInputAdapter = (bearingLine: ImplicitBearingLineInput): LineInput => {
-    const { long, lat, rgba, key, bearingLat = 0, bearingLong = 0 } = bearingLine;
-    return {
-        key: key,
-        start: [long, lat],
-        end: [bearingLong, bearingLat],
-        color: rgba as Color,
-    };
-}
-
-
-
-export const bearingLineToCircleInputAdapter = (globe: Globe) => (bearingLine: ImplicitBearingLineInput): CircleInput => {
-    const { long, lat, endLong, endLat, rgba, altitude = 0,
-        msl = null } = bearingLine;
-
-    if (bearingLine.radius === undefined || bearingLine.radius === null) {
-        const radius = globe.Math.GetDist2D(long, lat, endLong, endLat);
-        bearingLine.radius = radius;
-    }
-    return {
-        key: bearingLine.key,
-        center: [long, lat],
-        radius: bearingLine.radius,
-        height: altitude,
-        color: rgba,
-        msl
-    };
-}
-
-
-
-export const bearingLineToArcInputAdapter = (bearingLine: ImplicitBearingLineInput): ArcInput => {
-    const { long, lat, endLong, endLat, rgba, altitude = 0, msl } = bearingLine;
-    return {
-        key: bearingLine.key,
-        start: [long, lat],
-        end: [endLong, endLat],
-        height: altitude,
-        color: rgba as Color,
-        msl: msl
-    };
-}
-
-
-
-export const bearingLineToBearingArcInputAdapter = (globe: Globe, bearingLine: ImplicitBearingLineInput): ArcInput => {
-    const { long, lat, bearingAngle, rgba, altitude = 0, key, msl } = bearingLine;
-
-    if (bearingLine.radius === undefined || bearingLine.radius === null) {
-        throw new Error("Bearing line radius is not defined. Please calculate it before converting to ArcInput.");
-    }
-
-    const { long: endLong, lat: endLat } = globe.Math.FindPointByPolar(long, lat, bearingLine.radius, bearingAngle);
-
-    bearingLine.bearingLong = endLong;
-    bearingLine.bearingLat = endLat;
-
-    return {
-        key: key,
-        start: [long, lat],
-        end: [endLong, endLat],
-        height: altitude,
-        color: rgba as Color,
-        msl,
-    };
-}
-
-
-
-export const bearingLineToPieceOfPieInputAdapter = (globe: Globe, item: ImplicitBearingLineInput): PieceOfPiePluginInput => {
-    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);
-    const radius = item.radius ? item.radius * 0.2 : 10;
-    // @ts-ignore 
-    const { long: bearingLong, lat: bearingLat } = globe.Math.FindPointByPolar(item.long, item.lat, item.radius, 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 startAngleReal = globe.Math.GetAzimuthAngle(item.long, item.lat, item.endLong, item.endLat) //startAngle2d * 180 / Math.PI;
-    const startAngle3d = radian(startAngleReal - 90);
-    let tailAngle3d = bearingAngle - startAngle3d;
-    if (tailAngle3d > 0) {
-        tailAngle3d -= Math.PI * 2;
-    }
-    return {
-        key: item.key,
-        center: [item.long, item.lat],
-        radius: radius,
-        altitude: altitude + 230,
-        color: item.rgba,
-        startAngle2D: startAngle2d * 180 / Math.PI,
-        coverAngle2D: tailAngle2d * 180 / Math.PI,
-        startAngle3D: startAngle3d * 180 / Math.PI,
-        coverAngle3D: tailAngle3d * 180 / Math.PI,
-        fillingMode: item.pieFillingMode ?? 1,
-    };
-}
-
-
-
-export const pieceOfPieOpacityAdaptor = (lod: number, tiltAngle: number): number => {
-    const lodThreshold = 7.5;
-    const lodFactor = Math.exp(-Math.max(0, lod - lodThreshold));
-    tiltAngle += 5;
-    const tiltFactor = Math.min(1, 1 / Math.tan(radian(tiltAngle)));
-    const opacity = Math.max(Math.min(lodFactor * tiltFactor, 1), 0);
-    return opacity < 0.1 ? 0 : opacity; // Ensure opacity is not less than 0.1
-}
-
-
+const radian = (degree) => degree * Math.PI / 180;
+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;
+};
+const integralSec = (angle) => {
+    return Math.log(Math.tan(angle / 2 + Math.PI / 4));
+};
+export const flatLinesInputAdapter = (bearingLine) => {
+    const { long, lat, endLong, endLat, rgba } = bearingLine;
+    return {
+        key: bearingLine.key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        color: rgba,
+    };
+};
+export const flatLinesBearingInputAdapter = (bearingLine) => {
+    const { long, lat, rgba, key, bearingLat = 0, bearingLong = 0 } = bearingLine;
+    return {
+        key: key,
+        start: [long, lat],
+        end: [bearingLong, bearingLat],
+        color: rgba,
+    };
+};
+export const bearingLineToCircleInputAdapter = (globe) => (bearingLine) => {
+    const { long, lat, endLong, endLat, rgba, altitude = 0, msl = null } = bearingLine;
+    if (bearingLine.radius === undefined || bearingLine.radius === null) {
+        const radius = globe.Math.GetDist2D(long, lat, endLong, endLat);
+        bearingLine.radius = radius;
+    }
+    return {
+        key: bearingLine.key,
+        center: [long, lat],
+        radius: bearingLine.radius,
+        height: altitude,
+        color: rgba,
+        msl
+    };
+};
+export const bearingLineToArcInputAdapter = (bearingLine) => {
+    const { long, lat, endLong, endLat, rgba, altitude = 0, msl } = bearingLine;
+    return {
+        key: bearingLine.key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        height: altitude,
+        color: rgba,
+        msl: msl
+    };
+};
+export const bearingLineToBearingArcInputAdapter = (globe, bearingLine) => {
+    const { long, lat, bearingAngle, rgba, altitude = 0, key, msl } = bearingLine;
+    if (bearingLine.radius === undefined || bearingLine.radius === null) {
+        throw new Error("Bearing line radius is not defined. Please calculate it before converting to ArcInput.");
+    }
+    const { long: endLong, lat: endLat } = globe.Math.FindPointByPolar(long, lat, bearingLine.radius, bearingAngle);
+    bearingLine.bearingLong = endLong;
+    bearingLine.bearingLat = endLat;
+    return {
+        key: key,
+        start: [long, lat],
+        end: [endLong, endLat],
+        height: altitude,
+        color: rgba,
+        msl,
+    };
+};
+export const bearingLineToPieceOfPieInputAdapter = (globe, item) => {
+    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);
+    const radius = item.radius ? item.radius * 0.2 : 10;
+    // @ts-ignore 
+    const { long: bearingLong, lat: bearingLat } = globe.Math.FindPointByPolar(item.long, item.lat, item.radius, 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 startAngleReal = globe.Math.GetAzimuthAngle(item.long, item.lat, item.endLong, item.endLat); //startAngle2d * 180 / Math.PI;
+    const startAngle3d = radian(startAngleReal - 90);
+    let tailAngle3d = bearingAngle - startAngle3d;
+    if (tailAngle3d > 0) {
+        tailAngle3d -= Math.PI * 2;
+    }
+    return {
+        key: item.key,
+        center: [item.long, item.lat],
+        radius: radius,
+        altitude: altitude + 230,
+        color: item.rgba,
+        startAngle2D: startAngle2d * 180 / Math.PI,
+        coverAngle2D: tailAngle2d * 180 / Math.PI,
+        startAngle3D: startAngle3d * 180 / Math.PI,
+        coverAngle3D: tailAngle3d * 180 / Math.PI,
+        fillingMode: item.pieFillingMode ?? 1,
+    };
+};
+export const pieceOfPieOpacityAdaptor = (lod, tiltAngle) => {
+    const lodThreshold = 7.5;
+    const lodFactor = Math.exp(-Math.max(0, lod - lodThreshold));
+    tiltAngle += 5;
+    const tiltFactor = Math.min(1, 1 / Math.tan(radian(tiltAngle)));
+    const opacity = Math.max(Math.min(lodFactor * tiltFactor, 1), 0);
+    return opacity < 0.1 ? 0 : opacity; // Ensure opacity is not less than 0.1
+};