@pirireis/webglobeplugins 0.17.0 → 1.0.2

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

@@ -1,73 +1,113 @@
-/**
- * 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 {
-    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.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;
-}
+/**
+ * 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;
+}

package/publish.bat

@@ -0,0 +1,62 @@
+@echo off
+REM Define the source and destination directories
+set SOURCE_DIR=D:\webglobeplugins\webglobePlugin\src\webglobeplugins
+set DEST_DIR=D:\webglobeplugins\npmpub\webglobeplugins
+
+REM --- Start: Prepare and Compile Package for Publishing ---
+
+REM Check if the destination directory exists and clean it if it does
+if exist "%DEST_DIR%" (
+    echo Cleaning temporary publication directory: "%DEST_DIR%"
+    rd /s /q "%DEST_DIR%"
+)
+
+REM Create the temporary destination directory if it doesn't exist
+if not exist "%DEST_DIR%" (
+    echo Creating temporary publication directory: "%DEST_DIR%"
+    mkdir "%DEST_DIR%"
+)
+
+REM Copy the entire package folder (including package.json, tsconfig.json, source files)
+REM to the temporary destination. /E copies directories and subdirectories, /I assumes DEST_DIR is a directory.
+REM /Y suppresses prompts to confirm overwriting existing files.
+echo Copying source files to temporary publication directory...
+xcopy /E /I /Y "%SOURCE_DIR%" "%DEST_DIR%\"
+
+REM Change to the temporary publication directory (this is the package root)
+cd /d "%DEST_DIR%"
+
+REM Install dependencies (this is crucial for TypeScript to be available for compilation)
+REM Using 'call' ensures that control returns to the batch script after npm finishes.
+echo Installing package dependencies for compilation...
+call npm install
+
+REM Compile TypeScript files into JavaScript
+REM This assumes you have a "build" script in your package.json (e.g., "build": "tsc")
+REM The compiled output (e.g., JS files) will typically go into a 'dist' folder inside %DEST_DIR%.
+echo Compiling TypeScript files...
+call npm run build
+REM If there is an error during the build, exit the script
+if %errorlevel% neq 0 (
+    echo Build failed. Exiting script.
+    exit /b %errorlevel%
+)
+REM --- End: Prepare and Compile Package for Publishing ---
+
+REM COPY PACKAGE JSON TO DIST
+xcopy /Y "%DEST_DIR%\package.json" "%DEST_DIR%\dist\"
+
+
+
+REM Run npm publish from the package root directory (%DEST_DIR%).
+REM Because package.json's "files" is set to ["dist"], only the compiled output will be published.
+echo Running npm publish from the compiled package root...
+cd /d "%DEST_DIR%\dist"
+npm publish
+
+REM Return to the original directory
+cd /d "%SOURCE_DIR%"
+
+echo Folder copied, compiled, and npm publish executed successfully.
+
+set /p exitkey= "Press any key to continue..."

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

@@ -1,114 +1,154 @@
-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
-};
+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
+}
+
+