@aibee/owlly 1.0.26 → 1.0.29

package/lib/external/lines/line-segments-geometry.js

@@ -0,0 +1,140 @@
+/* eslint-disable max-len, no-continue, @typescript-eslint/no-explicit-any, no-underscore-dangle, func-names, @typescript-eslint/no-this-alias, no-console, consistent-return */
+import { Externals, NS_THREE } from '../../owlly/stage/externals';
+class LineSegmentsGeometry extends NS_THREE.InstancedBufferGeometry {
+    constructor() {
+        super();
+        const { THREE } = Externals.getInstance();
+        this.type = 'LineSegmentsGeometry';
+        const positions = [-1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0];
+        const uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2];
+        const index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5];
+        this.setIndex(index);
+        this.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+        this.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        const that = this;
+        this.computeBoundingBox = (function () {
+            const box = new THREE.Box3();
+            return function () {
+                if (that.boundingBox === null) {
+                    that.boundingBox = new THREE.Box3();
+                }
+                const start = that.attributes.instanceStart;
+                const end = that.attributes.instanceEnd;
+                if (start !== undefined && end !== undefined) {
+                    that.boundingBox.setFromBufferAttribute(start);
+                    box.setFromBufferAttribute(end);
+                    that.boundingBox.union(box);
+                }
+            };
+        }());
+        this.computeBoundingSphere = (function () {
+            const vector = new THREE.Vector3();
+            return function () {
+                if (that.boundingSphere === null) {
+                    that.boundingSphere = new THREE.Sphere();
+                }
+                if (that.boundingBox === null) {
+                    that.computeBoundingBox();
+                }
+                const start = that.attributes.instanceStart;
+                const end = that.attributes.instanceEnd;
+                if (start !== undefined && end !== undefined) {
+                    const { center } = that.boundingSphere;
+                    that.boundingBox.getCenter(center);
+                    let maxRadiusSq = 0;
+                    for (let i = 0, il = start.count; i < il; i++) {
+                        vector.fromBufferAttribute(start, i);
+                        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+                        vector.fromBufferAttribute(end, i);
+                        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+                    }
+                    that.boundingSphere.radius = Math.sqrt(maxRadiusSq);
+                    if (Number.isNaN(that.boundingSphere.radius)) {
+                        console.error('THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', that);
+                    }
+                }
+            };
+        }());
+    }
+    applyMatrix4(matrix) {
+        const start = this.attributes.instanceStart;
+        const end = this.attributes.instanceEnd;
+        if (start !== undefined) {
+            start.applyMatrix4(matrix);
+            end.applyMatrix4(matrix);
+            start.needsUpdate = true;
+        }
+        if (this.boundingBox !== null) {
+            this.computeBoundingBox();
+        }
+        if (this.boundingSphere !== null) {
+            this.computeBoundingSphere();
+        }
+        return this;
+    }
+    setPositions(array) {
+        let lineSegments;
+        if (array instanceof Float32Array) {
+            lineSegments = array;
+        }
+        else if (Array.isArray(array)) {
+            lineSegments = new Float32Array(array);
+        }
+        const { THREE } = Externals.getInstance();
+        const instanceBuffer = new THREE.InstancedInterleavedBuffer(lineSegments, 6, 1); // xyz, xyz
+        this.setAttribute('instanceStart', new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 0)); // xyz
+        this.setAttribute('instanceEnd', new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 3)); // xyz
+        //
+        this.computeBoundingBox();
+        this.computeBoundingSphere();
+        return this;
+    }
+    setColors(array) {
+        let colors;
+        if (array instanceof Float32Array) {
+            colors = array;
+        }
+        else if (Array.isArray(array)) {
+            colors = new Float32Array(array);
+        }
+        const { THREE } = Externals.getInstance();
+        const instanceColorBuffer = new THREE.InstancedInterleavedBuffer(colors, 6, 1); // rgb, rgb
+        this.setAttribute('instanceColorStart', new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 0)); // rgb
+        this.setAttribute('instanceColorEnd', new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 3)); // rgb
+        return this;
+    }
+    fromWireframeGeometry(geometry) {
+        this.setPositions(geometry.attributes.position.array);
+        return this;
+    }
+    fromEdgesGeometry(geometry) {
+        this.setPositions(geometry.attributes.position.array);
+        return this;
+    }
+    fromMesh(mesh) {
+        const { THREE } = Externals.getInstance();
+        this.fromWireframeGeometry(new THREE.WireframeGeometry(mesh.geometry));
+        // set colors, maybe
+        return this;
+    }
+    fromLineSegments(lineSegments) {
+        const { geometry } = lineSegments;
+        if (geometry.isGeometry) {
+            console.error('THREE.LineSegmentsGeometry no longer supports Geometry. Use THREE.BufferGeometry instead.');
+            return;
+        }
+        if (geometry.isBufferGeometry) {
+            this.setPositions(geometry.attributes.position.array); // assumes non-indexed
+        }
+        // set colors, maybe
+        return this;
+    }
+    toJSON() {
+        // todo
+    }
+    applyMatrix(matrix) {
+        console.warn('THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().');
+        return this.applyMatrix4(matrix);
+    }
+}
+export { LineSegmentsGeometry };

package/lib/external/loaders/gltf-loader.d.ts

@@ -0,0 +1,77 @@
+import { NS_THREE } from '../../owlly/stage/externals';
+declare class GLTFParser {
+    json: any;
+    extensions: any;
+    plugins: any;
+    options: any;
+    cache: any;
+    associations: any;
+    primitiveCache: any;
+    meshCache: any;
+    cameraCache: any;
+    lightCache: any;
+    nodeNamesUsed: any;
+    textureLoader: any;
+    fileLoader: any;
+    constructor(json: any, options: any);
+    setExtensions(extensions: any): any;
+    setPlugins(plugins: any): any;
+    parse(onLoad: any, onError: any): any;
+    _markDefs(): any;
+    _addNodeRef(cache: any, index: any): any;
+    _getNodeRef(cache: any, index: any, object: any): any;
+    _invokeOne(func: any): any;
+    _invokeAll(func: any): any;
+    getDependency(type: any, index: any): any;
+    getDependencies(type: any): any;
+    loadBuffer(bufferIndex: any): any;
+    loadBufferView(bufferViewIndex: any): any;
+    loadAccessor(accessorIndex: any): any;
+    loadTexture(textureIndex: any): any;
+    loadTextureImage(textureIndex: any, source: any, loader: any): any;
+    assignTexture(materialParams: any, mapName: any, mapDef: any): any;
+    assignFinalMaterial(mesh: any): any;
+    getMaterialType(): any;
+    loadMaterial(materialIndex: any): any;
+    createUniqueName(originalName: any): any;
+    loadGeometries(primitives: any): any;
+    loadMesh(meshIndex: any): any;
+    loadCamera(cameraIndex: any): any;
+    loadSkin(skinIndex: any): any;
+    loadAnimation(animationIndex: any): any;
+    loadNode(nodeIndex: any): any;
+    loadScene: any;
+}
+declare class GLTFLoader extends NS_THREE.Loader {
+    dracoLoader: any;
+    ktx2Loader: any;
+    meshoptDecoder: any;
+    pluginCallbacks: any;
+    withCredentials: any;
+    constructor(manager?: any);
+    load(url: any, onLoad?: any, onProgress?: any, onError?: any): any;
+    setDRACOLoader(dracoLoader: any): any;
+    setDDSLoader(): any;
+    setKTX2Loader(ktx2Loader: any): any;
+    setMeshoptDecoder(meshoptDecoder: any): any;
+    register(callback: any): any;
+    unregister(callback: any): any;
+    parse(data: any, path: any, onLoad: any, onError: any): any;
+}
+export interface GLTF {
+    animations: NS_THREE.AnimationClip[];
+    scene: NS_THREE.Group;
+    scenes: NS_THREE.Group[];
+    cameras: NS_THREE.Camera[];
+    asset: {
+        copyright?: string;
+        generator?: string;
+        version?: string;
+        minVersion?: string;
+        extensions?: any;
+        extras?: any;
+    };
+    parser: GLTFParser;
+    userData: any;
+}
+export { GLTFLoader };