@pirireis/webglobeplugins 0.9.1 → 0.9.3

package/tests/Math/quaternion.test.ts

@@ -1,98 +0,0 @@
-import { Quaternion } from '../../Math/quaternion';
-import { Vector3D } from '../../Math/vector3d';
-
-
-let _0vector: Vector3D;
-let _0quaternion: Quaternion;
-let _1quaternion: Quaternion;
-
-
-beforeAll(() => {
-    _0vector = new Vector3D(0, 0, 0);
-    _0quaternion = new Quaternion(0, 0, 0, 1);
-    _1quaternion = new Quaternion(0, 0, 0, 1);
-});
-
-test('Quaternion constructor and normalization', () => {
-    const quaternion = new Quaternion(1, 2, 3, 4);
-    expect(quaternion.x).toBe(1);
-    expect(quaternion.y).toBe(2);
-    expect(quaternion.z).toBe(3);
-    expect(quaternion.w).toBe(4);
-
-    const length = Math.sqrt(1 ** 2 + 2 ** 2 + 3 ** 2 + 4 ** 2);
-    expect(length).toBeCloseTo(length); // Check the length of the quaternion
-
-    quaternion.normalize();
-    expect(quaternion.x).toBeCloseTo(1 / length);
-    expect(quaternion.y).toBeCloseTo(2 / length);
-    expect(quaternion.z).toBeCloseTo(3 / length);
-    expect(quaternion.w).toBeCloseTo(4 / length);
-});
-
-
-test('Quaternion Vector3D rotation , Z axis', () => {
-
-    const xyByEuler = (angle: number) => new Vector3D(
-        Math.cos(angle),
-        Math.sin(angle),
-        0
-    );
-
-
-    let angle = 0;
-    let step = Math.PI / 10;
-    _0quaternion.setFromAxisAngle(_0vector.set(0, 0, 1).clone(), step);
-    _0vector.set(1, 0, 0);
-    while (angle < Math.PI * 2) {
-        const vector = xyByEuler(angle);
-        expect(_0vector.equals(vector)).toBe(true);
-        angle += step;
-        _0vector.applyQuaternion(_0quaternion);
-    }
-
-
-});
-
-test('Quaternion Vector3D rotation , Y axis', () => {
-
-    const xyByEuler = (angle: number) => new Vector3D(
-        Math.cos(angle),
-        0,
-        (angle <= Math.PI ? -1 : 1) * Math.abs(Math.sin(angle)) // because of right hand rule
-    );
-
-
-    let angle = 0;
-    let step = Math.PI / 10;
-    _0quaternion.setFromAxisAngle(_0vector.set(0, 1, 0).clone(), step);
-    _0vector.set(1, 0, 0);
-    while (angle < Math.PI * 2) {
-        const vector = xyByEuler(angle);
-        expect(_0vector.equals(vector)).toBe(true);
-        angle += step;
-        _0vector.applyQuaternion(_0quaternion);
-    }
-
-
-});
-
-
-
-
-test('Quaternion Multiply', () => {
-    _0quaternion.setFromAxisAngle(_0vector.set(0, 0, 1), Math.PI / 2);
-    _1quaternion.setFromAxisAngle(_0vector.set(0, 1, 0), Math.PI / 2);
-    _0quaternion.multiply(_1quaternion);
-    _0vector.set(1, 0, 0).applyQuaternion(_0quaternion);
-    _0vector.equals(new Vector3D(0, -1, 0));
-});
-
-
-test("Quaternion all Zeros", () => {
-
-    _0quaternion.setFromAxisAngle(_0vector.set(0, 0, 0), 0);
-    _0vector.set(1, 0, 0).applyQuaternion(_0quaternion);
-    expect(_0vector.equals(new Vector3D(1, 0, 0))).toBe(true);
-});
-

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

@@ -1,176 +0,0 @@
-import { Ray } from '../../Math/ray'
-import { Vector3D } from '../../Math/vector3d';
-import { Plane } from '../../Math/plane';
-
-
-
-const _0vector: Vector3D = new Vector3D(0, 0, 1);
-const _1vector: Vector3D = new Vector3D(0, 0, 1);
-const _3vector: Vector3D = new Vector3D(0, 0, 1);
-const _0ray: Ray = new Ray(new Vector3D(0, 0, 0), new Vector3D(1, 0, 0));;
-const _0plane: Plane = new Plane(new Vector3D(1, 0, 0), 0);;
-const _1plane: Plane = new Plane(new Vector3D(1, 0, 0), 0);;
-
-
-beforeAll(() => {
-    _0vector.randomUnit();
-    _1vector.randomUnit();
-    _3vector.randomUnit();
-    _0plane.setFromPoints(_0vector, _1vector, _3vector);
-    _3vector.randomUnit();
-    _1plane.setFromPoints(_0vector, _1vector, _3vector);
-});
-
-
-
-test("Plane Intersection => Ray", () => {
-    let result = Ray.fromTwoPlanes(_0plane, _1plane, _0ray);
-    expect(result).toBeInstanceOf(Ray);
-    if (result) {
-        expect(_0ray.contains(_0vector)).toBe(true);
-        expect(_0ray.contains(_1vector)).toBe(true);
-    }
-});
-
-
-test('Ray constructor', () => {
-    const origin = new Vector3D(1, 2, 3);
-    const direction = new Vector3D(4, 5, 6);
-    const ray = new Ray(origin, direction);
-
-    expect(ray.origin).toEqual(origin);
-    expect(ray.direction).toEqual(direction.normalize());
-});
-
-test('Ray from two planes 1', () => {
-    const plane1 = new Plane(new Vector3D(1, 0, 0), 5);
-    const plane2 = new Plane(new Vector3D(0, 1, 0), 10);
-    const ray = Ray.fromTwoPlanes(plane1, plane2)!;
-    const plane1copy = plane1.clone();
-    const plane2copy = plane2.clone();
-    expect(ray).toBeInstanceOf(Ray);
-    expect(ray.contains(new Vector3D(5, 10, 0))).toBe(true);
-    expect(ray.contains(new Vector3D(5, 10, 5))).toBe(true);
-    expect(ray.contains(new Vector3D(5, 10, -5))).toBe(true);
-    expect(plane1.equals(plane1copy)).toBe(true);
-    expect(plane2.equals(plane2copy)).toBe(true);
-});
-
-
-test('Ray from two planes 2 ', () => {
-    const plane1 = new Plane(new Vector3D(1, 1, 1).normalize(), 1 / Math.sqrt(3));
-    const plane2 = new Plane(new Vector3D(0, 0, 1).normalize(), 0);
-    const plane1copy = plane1.clone();
-    const plane2copy = plane2.clone();
-    const ray = Ray.fromTwoPlanes(plane1, plane2)!;
-    expect(ray).toBeInstanceOf(Ray);
-    expect(ray.contains(new Vector3D(0.5, 0.5, 0))).toBe(true);
-    expect(ray.contains(new Vector3D(1, 0, 0))).toBe(true);
-    expect(ray.contains(new Vector3D(0, 1, 0))).toBe(true);
-    expect(plane1.equals(plane1copy)).toBe(true);
-    expect(plane2.equals(plane2copy)).toBe(true);
-});
-
-describe('Ray from two planes with parallel planes', () => {
-    test(`Ray from two planes from random points, try:`, () => {
-        for (let i = 0; i < 100; i++) {
-            _0vector.randomUnit();
-            _1vector.randomUnit();
-            _3vector.randomUnit();
-            _0plane.setFromPoints(_0vector, _1vector, _3vector);
-
-            const n = _3vector.clone().randomUnit();
-            _1plane.setFromPoints(_0vector, _1vector, n);
-            const plane1copy = _1plane.clone();
-            const plane2copy = _0plane.clone();
-
-            const ray = Ray.fromTwoPlanes(_0plane, _1plane)!;
-            if (ray === null) {
-                console.log(_0plane, _1plane, ray);
-                console.log(_0vector, _1vector, _3vector, n);
-            }
-            expect(ray).toBeInstanceOf(Ray);
-
-            expect(ray.contains(_0vector)).toBe(true);
-            expect(ray.contains(_1vector)).toBe(true);
-            expect(plane1copy.equals(_1plane)).toBe(true);
-            expect(plane2copy.equals(_0plane)).toBe(true);
-        }
-    });
-});
-
-
-
-test('Ray intersection sphere', () => {
-    const ray = new Ray(new Vector3D(0, 0, 0), new Vector3D(0, 0, 1));
-    const sphereOrigin = new Vector3D(0, 0, 5);
-    const sphereRadius = 2;
-    const intersections = ray.intersectionSphere(sphereOrigin, sphereRadius)!;
-
-    expect(intersections).toBeInstanceOf(Array);
-    expect(intersections.length).toBe(2);
-    expect(intersections[0].equals(new Vector3D(0, 0, 3))).toBe(true);
-    expect(intersections[1].equals(new Vector3D(0, 0, 7))).toBe(true);
-});
-
-
-
-describe('Ray from 2 points intersection with Sphere', () => {
-    test(`Ray from 2 points intersection with Sphere, try:`, () => {
-        for (let i = 0; i < 100; i++) {
-            const center = _3vector.randomUnit().scale(Math.random() * 10 + 1).clone();
-            const radius = Math.random() * 10 + 1;
-            const angle = Math.acos(_0vector.randomUnit().dot(_1vector.randomUnit()));
-            const _0clone = _0vector.scale(radius).add(center).clone();
-            const _1clone = _1vector.scale(radius).add(center).clone();
-
-            Ray.fromTwoPoints(_0vector, _1vector, _0ray);
-
-
-            const intersections = _0ray.intersectionSphere(center, radius)!;
-            expect(_3vector.equals(center)).toBe(true);
-            expect(intersections).toBeInstanceOf(Array);
-
-            expect(_0clone.equals(_0vector)).toBe(true);
-            expect(_1clone.equals(_1vector)).toBe(true);
-
-            expect(intersections.length).toBe(2);
-
-            _0vector.subtract(center).normalize().scale(radius).add(center);
-            _1vector.subtract(center).normalize().scale(radius).add(center);
-
-            expect(intersections.some((v) => v.equals(_0vector))).toBe(true);
-            expect(intersections.some((v) => v.equals(_1vector))).toBe(true);
-
-
-            const radius2 = radius * (1 + Math.random() * 10);
-            const intersections2 = _0ray.intersectionSphere(center, radius2)!;
-            expect(intersections2).toBeInstanceOf(Array);
-            expect(intersections2.length).toBe(2);
-
-            intersections2.forEach((v) => v.subtract(center).normalize());
-
-            const angle2 = Math.acos(intersections2[0].dot(intersections2[1]));
-
-            const x1 = angle / 2;
-            const D1 = Math.cos(x1) * radius;
-            const x2 = angle2 / 2;
-            const D2 = Math.cos(x2) * radius2;
-
-            expect(Math.abs(D1 - D2)).toBeLessThan(0.000001);
-        }
-    });
-});
-
-
-
-test('Ray copy', () => {
-    const origin = new Vector3D(1, 2, 3);
-    const direction = new Vector3D(4, 5, 6);
-    const ray1 = new Ray(origin, direction);
-    const ray2 = new Ray(new Vector3D(), new Vector3D()).copy(ray1);
-
-    expect(ray2.origin.equals(origin)).toBe(true);
-    expect(ray2.direction.equals(direction)).toBe(true);
-});
-

package/tests/Math/vector3d.test.ts

@@ -1,104 +0,0 @@
-import { Vector3D } from '../../Math/vector3d';
-import { Quaternion } from '../../Math/quaternion';
-
-
-const toRadians = (degrees: number) => degrees * (Math.PI / 180);
-const toDegrees = (radians: number) => radians * (180 / Math.PI);
-
-let _0vector: Vector3D;
-let _1vector: Vector3D;
-let _0quaternion: Quaternion;
-
-beforeEach(() => {
-    _0vector = new Vector3D(0, 0, 0);
-    _1vector = new Vector3D(1, 1, 1);
-    _0quaternion = new Quaternion(0, 0, 0, 1);
-});
-
-
-test('add', () => {
-    expect(_0vector.add(_1vector).equals(new Vector3D(1, 1, 1))).toBe(true);
-});
-
-
-test('setFromLonLat - toLonLat 2', () => {
-    expect(_0vector.setFromLonLat(0, 0).toLonLat()).toEqual({ lon: 0, lat: 0 });
-});
-
-
-test(' applyQuaternion ', () => {
-
-    _0quaternion.setFromAxisAngle(new Vector3D(0, 0, 1), Math.PI / 2);
-    _0vector.setFromLonLat(toRadians(10), 0);
-    _0vector.applyQuaternion(_0quaternion);
-    const result = _0vector.toLonLat();
-    expect(result).toEqual({ lon: toRadians(100), lat: 0 });
-});
-
-
-test('setFromLonLat - toLonLat', () => {
-    const result = _0vector.setFromLonLat(0, 0).toLonLat();
-    expect(result.lon).toBeCloseTo(0, 1e-6);
-    expect(result.lat).toBeCloseTo(0, 1e-6);
-});
-
-
-test('scale', () => {
-    const scale = 2;
-    const result = _0vector.set(1, 2, 3).scale(scale);
-    expect(result.equals(new Vector3D(2, 4, 6))).toBe(true);
-});
-
-
-
-test('negate', () => {
-    _0vector.set(1, -2, 3).negate();
-    expect(_0vector.equals(new Vector3D(-1, 2, -3))).toBe(true);
-});
-
-
-
-test('cross same and negated', () => {
-
-    const negated = _0vector.randomUnit().clone().negate();
-    const result = _0vector.clone().cross(negated);
-    const resul2 = _0vector.clone().cross(_0vector);
-
-    expect(result.equals(new Vector3D(0, 0, 0))).toBe(true);
-    expect(resul2.equals(new Vector3D(0, 0, 0))).toBe(true);
-});
-
-
-// console.log
-// A Vector3D { x: 0.6389419688270773, y: -0.7692549385420794, z: 0 } B Vector3D { x: -0.6389419688270773, y: 0.7692549385420794, z: 0 } this.A Vector3D {
-//     x: -0.6002207824512262,
-//         y: -0.4133184680372552,
-//             z: 0.6847648182354102
-// }
-
-// at Arc.intersectionMedium(src / webglobeplugins / Math / arc.ts: 111: 17)
-
-// console.log
-// y < this._dot - 0.0655589757420102 0.0655589757420102 0.8489202601389976
-
-
-test('negated dot', () => {
-    const A = _0vector.randomUnit().clone();
-    const B = _0vector.randomUnit();
-
-    const result = A.dot(B);
-    const result2 = A.dot(B.negate());
-    expect(result).toBe(-result2);
-
-});
-
-
-
-
-test('cross', () => {
-    const A = _0vector.randomUnit().clone();
-    const B = _0vector.randomUnit();
-    const result = A.cross(B);
-    expect(result.equals(new Vector3D(0, 0, 0))).toBe(false);
-    expect(result.length()).toBeCloseTo(A.length() * B.length() * Math.sin(A.angle(B)), 1e-6);
-});

package/util/account/single-attribute-buffer-management/index.js

@@ -1,4 +0,0 @@
-import { BufferOrchestrator } from "./buffer-orchestrator";
-import { BufferManager } from "./buffer-manager";
-import { ObjectStore } from "./object-store";
-export { BufferOrchestrator, BufferManager, ObjectStore };

package/util/gl-util/uniform-block/types.js

@@ -1,7 +0,0 @@
-/**
- * @typedef {string} UniformBlockName
- *
- * @typedef {string} GLSLType | mat4, mat3, vec4, vec3, vec2, float, int, bool
- * @typedef {{name: string, type: GLSLType, null|Float32Array: value}} UniformBlockMember
- * 
- */