@pirireis/webglobeplugins 0.16.0 → 0.16.1

package/tests/Math/junction/plane-plane.test.ts

@@ -1,91 +0,0 @@
-import { Plane, Line, Vec3, Quaternion } from '../../../Math/types';
-import * as plane from '../../../Math/plane';
-import * as line from '../../../Math/line';
-import * as vec3 from '../../../Math/vec3';
-import * as quaternion from '../../../Math/quaternion';
-import { planePlaneJuction } from '../../../Math/juction/plane-plane';
-
-
-let plane1: Plane;
-let plane2: Plane;
-let intersectionLine: Line;
-let quaternion1: Quaternion;
-
-beforeAll(() => {
-    plane1 = plane.create();
-    plane2 = plane.create();
-    intersectionLine = line.create();
-    quaternion1 = quaternion.create();
-});
-
-
-test('plane-plane intersection - parallel planes', () => {
-    plane.fromValues(plane1, 0, 0, 1, 5); // Plane: z = 5
-    plane.fromValues(plane2, 0, 0, 1, 10); // Plane: z = 10
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(false);
-});
-
-test('plane-plane intersection - intersecting planes', () => {
-    plane.fromValues(plane1, 0, 0, 1, 5); // Plane: z = 5
-    plane.fromValues(plane2, 1, 0, 0, 3); // Plane: x = 3
-
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, 1, 0))).toBe(true);
-    expect(vec3.equals(intersectionLine.origin, vec3.create(3, 0, 5))).toBe(true);
-});
-
-
-test('plane-plane intersection - rotating a plane', () => {
-    // plane1 z = 5
-    plane.fromValues(plane1, 0, 0, 1, 5);
-
-    // plane2 x = 3, for the start
-    vec3.randomUnit(plane2.normal);
-    plane2.distance = 3;
-
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    const quaRotateLine = line.clone(intersectionLine);
-
-    const step = 90;
-    quaternion.fromAxisAngle(quaternion1, plane1.normal, Math.PI / step); // Rotate 90 degrees around Y-axis
-
-
-    for (let i = 0; i < step; i++) {
-
-        vec3.applyQuaternion(plane2.normal, plane2.normal, quaternion1);
-
-        const result = planePlaneJuction(intersectionLine, plane1, plane2);
-
-
-        line.applyQuaternion(quaRotateLine, quaRotateLine, quaternion1);
-
-        expect(result).toBe(true);
-        expect(vec3.equals(intersectionLine.direction, quaRotateLine.direction)).toBe(true);
-        expect(line.contains(intersectionLine, quaRotateLine.origin)).toBe(true);
-    }
-});
-
-test("plane-plane intersection 1", () => {
-    const r2 = Math.sqrt(2) / 2;
-    plane.fromValues(plane1, 1, 0, 0, 0);
-    plane.fromValues(plane2, 0, -r2, r2, 0);
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-
-    expect(result).toBe(true);
-    console.log(intersectionLine);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, r2, r2)) || vec3.equals(intersectionLine.direction, vec3.create(0, -r2, -r2))
-    ).toBe(true);
-    expect(line.contains(intersectionLine, vec3.create(0, 0, 0))).toBe(true);
-});
-
-test("plane-plane intersection 2", () => {
-    plane.fromValues(plane1, 1, 0, 0, 1);
-    plane.fromValues(plane2, 0, 1, 0, 1);
-    const result = planePlaneJuction(intersectionLine, plane1, plane2);
-    expect(result).toBe(true);
-    expect(vec3.equals(intersectionLine.direction, vec3.create(0, 0, 1))).toBe(true);
-    expect(line.contains(intersectionLine, vec3.create(1, 1, 0))).toBe(true);
-});

package/tests/Math/plane-test.ts

@@ -1,17 +0,0 @@
-import { Vec3, Plane } from '../../Math/types';
-import * as vec3 from '../../Math/vec3';
-import * as plane from '../../Math/plane';
-
-
-const EPSILON = 1e-6;
-
-const _0plane = plane.create(vec3.create(0, 0, 1), 0);
-const _1plane = plane.create(vec3.create(1, 1, 1), 0);
-
-beforeAll(() => {
-    // Initialize any necessary data or state before running the tests
-    plane.set(_0plane, vec3.create(0, 0, 1), 0);
-    plane.set(_1plane, vec3.create(1, 1, 1), 0);
-});
-
-

package/tests/Math/plane.test.ts

@@ -1,43 +0,0 @@
-import { Plane, Vec3 } from "../../Math/types";
-import * as vec3 from "../../Math/vec3";
-import * as plane from "../../Math/plane";
-
-
-const _planeA = /*@__PURE__*/ plane.create(vec3.create(1, 0, 0), 0);
-const _planeB = /*@__PURE__*/ plane.create(vec3.create(0, 1, 0), 0);
-const _vecA = /*@__PURE__*/ vec3.create(1, 0, 0);
-
-beforeAll(() => {
-    vec3.set(_vecA, 1, 0, 0);
-    plane.set(_planeA, vec3.create(1, 0, 0), 0);
-    plane.set(_planeB, vec3.create(0, 1, 0), 0);
-});
-
-test("Plane: getUnitSphereRadiusAngle", () => {
-    const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-    const angleB = plane.getUnitSphereRadiusAngle(_planeB);
-
-    expect(angleA).toBeCloseTo(Math.PI / 2, 5); // 90 degrees
-    expect(angleB).toBeCloseTo(Math.PI / 2, 5); // 90 degrees
-});
-
-
-test("Plane: getUnitSphereRadiusAngle 1", () => {
-
-    vec3.set(_vecA, 1, 1, 0);
-    vec3.normalize(_vecA, _vecA);
-    const distance = Math.sqrt(2) / 2; // Distance from origin to the plane
-    plane.set(_planeA, _vecA, distance);
-    const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-    expect(angleA).toBeCloseTo(Math.PI / 4, 5); // 45 degrees
-
-    for (let i = 0; i < 100; i++) {
-        const distance = Math.random();
-
-        const angle = Math.acos(distance);
-        vec3.randomUnit(_vecA)
-        plane.set(_planeA, _vecA, distance);
-        const angleA = plane.getUnitSphereRadiusAngle(_planeA);
-        expect(angleA).toBeCloseTo(angle, 5); // Check if the angle is close to the expected value
-    }
-});  

package/tests/Math/vec3.test.ts

@@ -1,14 +0,0 @@
-import { Vec3 } from "../../Math/types";
-import * as vec3 from "../../Math/vec3";
-
-test("vec3.create", () => {
-    const v = vec3.create(1, 2, 3);
-    expect(v).toEqual([1, 2, 3]);
-});
-
-
-test("vec3.length", () => {
-    const v = vec3.create(3, 4, 0);
-    const length = vec3.length(v);
-    expect(length).toBe(5);
-});

package/timetracks/readme.md

@@ -1 +0,0 @@
-TODO: delete program, programpoint, maybe adaptors. which are related to the old version of this plugin.

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es2022",
-        "module": "es2015",
-        "outDir": "./dist",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "allowJs": true,
-        "declaration": false
-    },
-    "include": [
-        "**/*.ts", // Include all .ts files in the current directory and subdirectories
-        "**/*.js" // Include all .js files in the current directory and subdirectories
-    ],
-    "exclude": [
-        "node_modules",
-        "dist", // Exclude the output directory itself
-        "./tests/**/*" // Exclude tests directory
-    ]
-}

package/types.ts

@@ -1,265 +0,0 @@
-
-
-export type TypedArray =
-    Float32Array | Float64Array |
-    Int32Array | Int16Array | Int8Array |
-    Uint32Array | Uint16Array | Uint8Array | Uint8ClampedArray;
-
-
-export type Color = [number, number, number, number] | Float32Array; // RGBA color format 0-1 
-export type LongLat = [number, number]; // [longitude, latitude]
-export type CentigradeDegree = number;
-export type Meter = number;
-export type Radians = number;
-
-export type ColorRatio = {
-    color: Color;
-    ratio: CentigradeDegree;
-};
-
-export type BUFFER_TYPE = "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW";
-
-
-export type DRAW_MODE = 'LINE_STRIP' | 'TRIANGLE_FAN' | 'TRIANGLES' | 'POINTS' | 'LINES' | 'LINE_LOOP' | 'TRIANGLE_STRIP' | 'LINE_STRIP_ADJACENCY' | 'TRIANGLE_STRIP_ADJACENCY' | 'LINES_ADJACENCY' | 'PATCHES';
-
-
-export type GlobeLookInfo = {
-    CenterLong: CentigradeDegree;
-    CenterLat: CentigradeDegree;
-    Distance: Meter;
-    Tilt: CentigradeDegree;
-    NorthAng: CentigradeDegree;
-}
-
-
-
-interface GlobeMath {
-    FindPointByPolar(
-        centerLong: CentigradeDegree,
-        centerLat: CentigradeDegree,
-        distance: Meter,
-        azimuth: CentigradeDegree
-    ): { long: CentigradeDegree, lat: CentigradeDegree };
-    GetDist2D(
-        long1: CentigradeDegree,
-        lat1: CentigradeDegree,
-        long2: CentigradeDegree,
-        lat2: CentigradeDegree
-    ): Meter;
-    GetAzimuthAngle(
-        long1: CentigradeDegree,
-        lat1: CentigradeDegree,
-        long2: CentigradeDegree,
-        lat2: CentigradeDegree
-    ): CentigradeDegree;
-}
-
-
-
-
-
-
-export interface TextFont {
-    name: string;
-    textColor: string;
-    hollowColor: string;
-    size: number;
-    hollow: boolean;
-    bold: boolean;
-    italic: boolean;
-    position?: string;
-}
-
-
-export interface Globe {
-    DrawRender(): void;
-    api_ScrW(): number;
-    api_ScrH(): number;
-    api_GetCurrentGeometry(): 0 | 1;
-    api_GetCurrentLODWithDecimal(): number;
-    api_GetCurrentWorldWH(): { width: number; height: number };
-    api_GetCurrentLookInfo(): GlobeLookInfo;
-    api_GetCartesian3DPoint: (long: number, lat: number, height: number, msl: boolean) => [number, number, number];
-    api_GetMercator2DPoint: (long: number, lat: number) => [number, number];
-    api_IsScreenMoving(): boolean;
-    api_GetMouseDeg(): { long: number; lat: number } | null;
-    api_GetZScale(): number;
-    api_SetZScale(zScale: number): void; // Max 4 
-    api_DrawContextTextMultiLine(text: string, textFont: TextFont, opacity: number, position: 
-        { x: number; y: number }, angleIsOn: boolean, angle: number | null): void;
-    api_GetScreenPointFromGeo(coords: { long: number; lat: number; z: number }, isMSL: boolean): 
-        { x: number | null; y: number | null };
-    api_GetCurrentWorldLimit(): { ur: { x: number; y: number }; ll: { x: number; y: number } };
-    gl: WebGL2RenderingContext;
-    Fp: { x: number; y: number; z: number };
-    FUPos: { x: number; y: number; z: number };
-    Math: GlobeMath;
-    ObjectArray: ObjectArray;
-}
-
-
-
-export type GlobeChanges = {
-    geometry: boolean;
-    look: boolean;
-    lod: boolean;
-    lod2DWheel: boolean;
-    elevationScale: boolean;
-    screenMoved: boolean;
-}
-
-export type ChargerInput = {
-    totalTime: number;
-    ratio: number;
-    acceleration: number;
-}
-
-
-export type DrawRange = {
-    first: number;
-    count: number;
-};
-
-
-export type DrawRangeIndexParams = {
-    drawRange: DrawRange;
-    elementBuffer?: WebGLBuffer;
-    elementBufferIndexType?: number;
-    drawMode?: number;
-};
-
-
-export interface ProgramInterface {
-    draw(vao: WebGLVertexArrayObject, drawOptions: DrawRangeIndexParams, opacity: number, flexibleUBO: UBOHandler | null): void;
-    createUBO(bufferReadType?: "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW"): UBOHandler;
-    createVAO(...inputs: (BufferAndReadInfo | null)[]): WebGLVertexArrayObject;
-    free(): void;
-}
-
-
-export interface PluginInterface {
-    id: string;
-    init(globe: Globe, gl: WebGL2RenderingContext): void;
-    draw3D(projectionMatrix: Float32Array, modelViewMatrix: Float32Array, transPosition: { x: number, y: number, z: number }): void;
-    free(): void;
-}
-
-
-
-export type BufferAndReadInfo = {
-    buffer: WebGLBuffer;
-    stride: number;
-    offset: number;
-} | null;
-
-
-export type AttributeLoaderOptions = {
-    divisor?: number | null;
-    type?: number | null;
-    escapeValues?: Array<number> | null;
-    normalized?: boolean;
-}
-
-export type UBOHandler = {
-    ubo: WebGLBuffer;
-    update: (nameValueMap: Map<string, any>) => void;
-    updateSingle: (name: string, value: Float32Array | Int32Array | DataView | ArrayBuffer) => void;
-    bind: () => void;
-    unbind: () => void;
-    free: () => void;
-};
-
-
-export type PluginAttachmentParameters = {
-    plugin: PluginInterface;
-    freeOnUnregister?: boolean;
-}
-
-
-
-export interface ElevationMode {
-    setElevationMode(mode: "agl" | "msl"): void;
-}
-
-export interface UpdateColor {
-    updateColors(keyColorCouples: { key: string, color: Color }[], drawRender: boolean): void;
-}
-
-
-// OBJECT ARRAY START
-
-
-export interface ObjectArray {
-    Add(object: LayerObjectObjectArray): void;
-    Delete(id: string): void;
-    GetDefaultStyle(): StyleObjectArray;
-    StyleChanged(object: LayerObjectObjectArray): void;
-    UpdateData(object: LayerObjectObjectArray, mode: any, buckets: DataBucketObjectArray[], options: { attribs: boolean; icon: boolean; text: boolean }): void;
-    SetData(object: LayerObjectObjectArray, data: DataBucketObjectArray): void;
-}
-
-export interface StyleObjectArray {
-    fidKey: string;
-    opacity: number;
-    labels: LabelObjectArray[];
-}
-
-export interface LabelObjectArray {
-    offset: { x: number; y: number };
-    fontFamily: { hollowWidth: number };
-    vAlignment: number;
-    hAlignment: number;
-    size: number;
-    text: string;
-}
-
-export interface LayerObjectObjectArray {
-    displayName: string;
-    layerType: number;
-    wkbGeom: null;
-    wfsLayerName: null;
-    objectType: string;
-    bbox: null;
-    startLod: number;
-    endLod: number;
-    continuousLOD: boolean;
-    MVTXYZName: string;
-    rasterize: boolean;
-    style: StyleObjectArray;
-    id: string;
-}
-
-export interface DataBucketObjectArray {
-    coords: number[];
-    coordsZ: number[];
-    attribs: Record<string, any>[];
-}
-
-
-
-// OBJECT ARRAY FINISH
-
-
-//  GLOBE MANAGER
-
-interface GlobeManager {
-    /**
-     * When mesh service is not working call this method with (false, true) it fixes issues
-     * @param retry 
-     * @param divideMeshFurther 
-     */
-  api_ReTryAtMeshTimeout(retry: boolean, divideMeshFurther: boolean): void; 
-}
-
-export enum CSMeasureTextPositionTypes {
-    CENTER= 'center',
-    LEFT= 'left',
-    RIGHT= 'right',
-    TOP= 'bottom',
-    BOTTOM= 'top',
-    TOP_LEFT= 'bottom_left',
-    TOP_RIGHT= 'bottom_right',
-    BOTTOM_LEFT= 'top_left',
-    BOTTOM_RIGHT= 'top_right',
-};
-

package/util/account/create-buffermap-orchastration.ts

@@ -1,85 +0,0 @@
-// IN construction
-
-
-import { BufferManagersMap } from "./single-attribute-buffer-management/types";
-import { BufferManager } from "./single-attribute-buffer-management/buffer-manager";
-import { BufferOrchestrator } from "./single-attribute-buffer-management/buffer-orchestrator";
-
-
-
-export type BufferDetails = {
-    bufferType: "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW";
-    itemSize: number;
-    adaptor: (x: any) => Float32Array;
-}
-
-
-export type BufferDetailsMap = Map<string, BufferDetails>;
-
-
-export class BufferMapOrchestrator {
-    gl: WebGL2RenderingContext;
-    bufferManagersMap: BufferManagersMap;
-    bufferOrchestrator: BufferOrchestrator;
-
-
-
-    constructor(
-        gl: WebGL2RenderingContext,
-        bufferDetailsMap: BufferDetailsMap,
-        initialCapacity: number = 10
-    ) {
-        this.gl = gl;
-        this.bufferManagersMap = new Map();
-        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
-
-        for (const [key, details] of bufferDetailsMap) {
-            const { itemSize, bufferType, adaptor } = details;
-            const bufferManager = new BufferManager(gl, itemSize, { bufferType, initialCapacity });
-            this.bufferManagersMap.set(key, { bufferManager, adaptor });
-        }
-
-
-    }
-
-
-    insertBulk<T>(items: T[]): void {
-        // @ts-ignore
-        this.bufferOrchestrator.insertBulk(
-            items,
-            this.bufferManagersMap
-        );
-    }
-
-
-    updateBulk<T>(items: T[], bufferKeys: string[] = []): void {
-        // @ts-ignore
-        this.bufferOrchestrator.updateBulk(
-            items,
-            this.bufferManagersMap,
-            bufferKeys
-        );
-    }
-
-
-    deleteBulk(keys: string[]): void {
-        // @ts-ignore
-        this.bufferOrchestrator.deleteBulk(
-            keys,
-            this.bufferManagersMap
-        );
-    }
-
-
-    resetWithCapacity(capacity: number): void {
-        this.bufferOrchestrator.resetWithCapacity(this.bufferManagersMap, capacity);
-    }
-
-
-    free(): void {
-        for (const [key, { bufferManager }] of this.bufferManagersMap) {
-            bufferManager.free();
-        }
-        this.bufferManagersMap.clear();
-    }
-}

package/util/account/single-attribute-buffer-management/buffer-manager.ts

@@ -1,149 +0,0 @@
-/**
- * BufferOffsetManager
- * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer. 
- * ------------------------------------------------------------------------------------------------------------------------------------------- * Functions:
- * 1. getOffet(key) : return the offset of the key if not found return false.
- * 2. setOffset(key, offset) : set the offset of the key.
- * 3. nextOffset() : return the next available offset if not return false.
- * 4. delete(key) : delete the key and return true if not found return false.
- * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
- * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
- * -------------------------------------------------------------------------------------------------------------------------------------------
- * What this class does NOT do:
- * ADD, DELETE, READ
- * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
- * DELETE, might be a set to single byte to indicate the tombstone.
- * READ, most of the time is not needed to be read, unless for defraging.
- * This unpredicatable behavior is not handled by this class.
- */
-
-
-import { TypedArray } from "../../../types"
-
-
-
-type BufferManagerOptions = {
-    bufferType?: string;
-    buffer?: WebGLBuffer | null;
-    initialCapacity?: number;
-};
-
-
-export class BufferManager {
-    gl: WebGL2RenderingContext;
-    buffer: WebGLBuffer;
-    itemSize: number;
-    bufferType: string;
-    isFreed: boolean = false;
-
-    constructor(gl: WebGL2RenderingContext, itemSize: number, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = 10 }: BufferManagerOptions = {}) {
-        this.gl = gl;
-        this.itemSize = itemSize;
-        this.bufferType = bufferType;
-        this.buffer = buffer === null ? gl.createBuffer() : buffer;
-        this.resetWithCapacity(initialCapacity);
-    }
-
-    resetWithCapacity(capacity: number) {
-        const { gl, buffer, bufferType, itemSize } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-    deleteBulk(offsets: number[]) {
-        const { gl, buffer, itemSize } = this;
-        const emptyBlock = new Float32Array(this.itemSize).fill(NaN)
-        const offsetMultiplier = itemSize * 4;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        for (let offset of offsets) {
-            if (offset !== undefined) {
-                gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
-            }
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-    insertBulk(blocks: any[], offsets: number[]) {
-        const { gl, buffer, itemSize } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        const offsetMultiplier = itemSize * 4;
-        for (let i = 0; i < blocks.length; i++) {
-            const block = blocks[i];
-            const offset = offsets[i] * offsetMultiplier;
-            if (offset !== undefined) gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-
-    insertBlock<T extends TypedArray>(
-        items: any[],
-        offset: number,
-        adapter: (item: any) => ArrayLike<number>,
-        Constructor: { new(length: number): T } = Float32Array as any
-    ) {
-        const { gl, buffer, itemSize } = this;
-        const cpuBuffer = new Constructor(itemSize * items.length);
-        for (let i = 0; i < items.length; i++) {
-            cpuBuffer.set(adapter(items[i]), i * itemSize);
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferSubData(gl.ARRAY_BUFFER, offset * itemSize * 4, cpuBuffer as ArrayBufferView);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-
-    // TODO: this is broken
-    defrag(offsetValues: MapIterator<number> | number[], occupiedCapacity: number, newCapacity: number) {
-        const { gl, buffer, bufferType, itemSize } = this;
-
-        const newArray = new Float32Array(newCapacity * itemSize);
-        const bufferData = this._getBufferData(occupiedCapacity);
-        let newOffset = 0;
-        for (const offset of offsetValues) {
-            const itemOffset = offset * itemSize;
-            newArray.set(bufferData.slice(itemOffset, itemOffset + itemSize), newOffset);
-            newOffset += itemSize;
-        }
-
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-
-    }
-
-    extendBuffer(occupiedCapacity: number, newCapacity: number) {
-        const { gl, buffer, bufferType } = this;
-        const itemSize = this.itemSize;
-        const bufferData = this._getBufferData(occupiedCapacity);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        // @ts-ignore
-        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
-        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    }
-
-    _getBufferData(occupiedCapacity: number): Float32Array {
-        const { gl, buffer } = this;
-        const size = occupiedCapacity * this.itemSize;
-        const bufferData = new Float32Array(size);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return bufferData;
-    }
-
-    free() {
-        if (this.isFreed) return;
-        this.gl.deleteBuffer(this.buffer);
-        // this.buffer = null;
-        // this.gl = null;
-        this.isFreed = true;
-    }
-}