@aibee/owlly 1.0.26 → 1.0.29

package/lib/external/lines/line-geometry.d.ts

@@ -0,0 +1,9 @@
+import { LineSegmentsGeometry } from './line-segments-geometry';
+declare class LineGeometry extends LineSegmentsGeometry {
+    isLineGeometry: true;
+    constructor();
+    setPositions(array: any[]): any;
+    setColors(array: any[]): any;
+    fromLine(line: any): any;
+}
+export { LineGeometry };

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

@@ -0,0 +1,51 @@
+/* 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, no-param-reassign, no-shadow */
+import { LineSegmentsGeometry } from './line-segments-geometry';
+class LineGeometry extends LineSegmentsGeometry {
+    constructor() {
+        super();
+        this.type = 'LineGeometry';
+    }
+    setPositions(array) {
+        // converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
+        const length = array.length - 3;
+        const points = new Float32Array(2 * length);
+        for (let i = 0; i < length; i += 3) {
+            points[2 * i] = array[i];
+            points[2 * i + 1] = array[i + 1];
+            points[2 * i + 2] = array[i + 2];
+            points[2 * i + 3] = array[i + 3];
+            points[2 * i + 4] = array[i + 4];
+            points[2 * i + 5] = array[i + 5];
+        }
+        super.setPositions(points);
+        return this;
+    }
+    setColors(array) {
+        // converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
+        const length = array.length - 3;
+        const colors = new Float32Array(2 * length);
+        for (let i = 0; i < length; i += 3) {
+            colors[2 * i] = array[i];
+            colors[2 * i + 1] = array[i + 1];
+            colors[2 * i + 2] = array[i + 2];
+            colors[2 * i + 3] = array[i + 3];
+            colors[2 * i + 4] = array[i + 4];
+            colors[2 * i + 5] = array[i + 5];
+        }
+        super.setColors(colors);
+        return this;
+    }
+    fromLine(line) {
+        const { geometry } = line;
+        if (geometry.isGeometry) {
+            console.error('THREE.LineGeometry 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;
+    }
+}
+export { LineGeometry };

package/lib/external/lines/line-material.d.ts

@@ -0,0 +1,10 @@
+import { NS_THREE } from '../../owlly/stage/externals';
+declare class LineMaterial extends NS_THREE.ShaderMaterial {
+    isLineMaterial: boolean;
+    dashed: boolean;
+    resolution: any;
+    linewidth: any;
+    color: any;
+    constructor(parameters: any);
+}
+export { LineMaterial };

package/lib/external/lines/line-material.js

@@ -0,0 +1,376 @@
+/* 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, no-param-reassign */
+import { Externals, NS_THREE } from '../../owlly/stage/externals';
+function getUniformsLibLine() {
+    const { THREE } = Externals.getInstance();
+    return {
+        linewidth: { value: 1 },
+        resolution: { value: new THREE.Vector2(1, 1) },
+        dashScale: { value: 1 },
+        dashSize: { value: 1 },
+        dashOffset: { value: 0 },
+        gapSize: { value: 1 },
+        opacity: { value: 1 },
+    };
+}
+function getShaderLibLine() {
+    const { THREE } = Externals.getInstance();
+    return {
+        uniforms: THREE.UniformsUtils.merge([
+            THREE.UniformsLib.common,
+            THREE.UniformsLib.fog,
+            getUniformsLibLine(),
+        ]),
+        vertexShader: `
+            #include <common>
+            #include <color_pars_vertex>
+            #include <fog_pars_vertex>
+            #include <logdepthbuf_pars_vertex>
+            #include <clipping_planes_pars_vertex>
+
+            uniform float linewidth;
+            uniform vec2 resolution;
+
+            attribute vec3 instanceStart;
+            attribute vec3 instanceEnd;
+
+            attribute vec3 instanceColorStart;
+            attribute vec3 instanceColorEnd;
+
+            varying vec2 vUv;
+
+            #ifdef USE_DASH
+
+                uniform float dashScale;
+                attribute float instanceDistanceStart;
+                attribute float instanceDistanceEnd;
+                varying float vLineDistance;
+
+            #endif
+
+            void trimSegment( const in vec4 start, inout vec4 end ) {
+
+                // trim end segment so it terminates between the camera plane and the near plane
+
+                // conservative estimate of the near plane
+                float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
+                float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
+                float nearEstimate = - 0.5 * b / a;
+
+                float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
+
+                end.xyz = mix( start.xyz, end.xyz, alpha );
+
+            }
+
+            void main() {
+
+                #ifdef USE_COLOR
+
+                    vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd;
+
+                #endif
+
+                #ifdef USE_DASH
+
+                    vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
+
+                #endif
+
+                float aspect = resolution.x / resolution.y;
+
+                vUv = uv;
+
+                // camera space
+                vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
+                vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
+
+                // special case for perspective projection, and segments that terminate either in, or behind, the camera plane
+                // clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
+                // but we need to perform ndc-space calculations in the shader, so we must address this issue directly
+                // perhaps there is a more elegant solution -- WestLangley
+
+                bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column
+
+                if ( perspective ) {
+
+                    if ( start.z < 0.0 && end.z >= 0.0 ) {
+
+                        trimSegment( start, end );
+
+                    } else if ( end.z < 0.0 && start.z >= 0.0 ) {
+
+                        trimSegment( end, start );
+
+                    }
+
+                }
+
+                // clip space
+                vec4 clipStart = projectionMatrix * start;
+                vec4 clipEnd = projectionMatrix * end;
+
+                // ndc space
+                vec2 ndcStart = clipStart.xy / clipStart.w;
+                vec2 ndcEnd = clipEnd.xy / clipEnd.w;
+
+                // direction
+                vec2 dir = ndcEnd - ndcStart;
+
+                // account for clip-space aspect ratio
+                dir.x *= aspect;
+                dir = normalize( dir );
+
+                // perpendicular to dir
+                vec2 offset = vec2( dir.y, - dir.x );
+
+                // undo aspect ratio adjustment
+                dir.x /= aspect;
+                offset.x /= aspect;
+
+                // sign flip
+                if ( position.x < 0.0 ) offset *= - 1.0;
+
+                // endcaps
+                if ( position.y < 0.0 ) {
+
+                    offset += - dir;
+
+                } else if ( position.y > 1.0 ) {
+
+                    offset += dir;
+
+                }
+
+                // adjust for linewidth
+                offset *= linewidth;
+
+                // adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
+                offset /= resolution.y;
+
+                // select end
+                vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
+
+                // back to clip space
+                offset *= clip.w;
+
+                clip.xy += offset;
+
+                gl_Position = clip;
+
+                vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation
+
+                #include <logdepthbuf_vertex>
+                #include <clipping_planes_vertex>
+                #include <fog_vertex>
+
+            }
+            `,
+        fragmentShader: `
+            uniform vec3 diffuse;
+            uniform float opacity;
+
+            #ifdef USE_DASH
+
+                uniform float dashSize;
+                uniform float dashOffset;
+                uniform float gapSize;
+
+            #endif
+
+            varying float vLineDistance;
+
+            #include <common>
+            #include <color_pars_fragment>
+            #include <fog_pars_fragment>
+            #include <logdepthbuf_pars_fragment>
+            #include <clipping_planes_pars_fragment>
+
+            varying vec2 vUv;
+
+            void main() {
+
+                #include <clipping_planes_fragment>
+
+                #ifdef USE_DASH
+
+                    if ( vUv.y < - 1.0 || vUv.y > 1.0 ) discard; // discard endcaps
+
+                    if ( mod( vLineDistance + dashOffset, dashSize + gapSize ) > dashSize ) discard; // todo - FIX
+
+                #endif
+
+                float alpha = opacity;
+
+                #ifdef ALPHA_TO_COVERAGE
+
+                // artifacts appear on some hardware if a derivative is taken within a conditional
+                float a = vUv.x;
+                float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+                float len2 = a * a + b * b;
+                float dlen = fwidth( len2 );
+
+                if ( abs( vUv.y ) > 1.0 ) {
+
+                    alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 );
+
+                }
+
+                #else
+
+                if ( abs( vUv.y ) > 1.0 ) {
+
+                    float a = vUv.x;
+                    float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+                    float len2 = a * a + b * b;
+
+                    if ( len2 > 1.0 ) discard;
+
+                }
+
+                #endif
+
+                vec4 diffuseColor = vec4( diffuse, alpha );
+
+                #include <logdepthbuf_fragment>
+                #include <color_fragment>
+
+                gl_FragColor = vec4( diffuseColor.rgb, alpha );
+
+                #include <tonemapping_fragment>
+                #include <encodings_fragment>
+                #include <fog_fragment>
+                #include <premultiplied_alpha_fragment>
+
+            }
+        `,
+    };
+}
+class LineMaterial extends NS_THREE.ShaderMaterial {
+    constructor(parameters) {
+        super((() => {
+            const { THREE } = Externals.getInstance();
+            const shaderLibLine = getShaderLibLine();
+            return {
+                type: 'LineMaterial',
+                uniforms: THREE.UniformsUtils.clone(shaderLibLine.uniforms),
+                vertexShader: shaderLibLine.vertexShader,
+                fragmentShader: shaderLibLine.fragmentShader,
+                clipping: true,
+            };
+        })());
+        this.isLineMaterial = true;
+        this.dashed = false;
+        Object.defineProperties(this, {
+            color: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.diffuse.value;
+                },
+                set(value) {
+                    this.uniforms.diffuse.value = value;
+                },
+            },
+            linewidth: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.linewidth.value;
+                },
+                set(value) {
+                    this.uniforms.linewidth.value = value;
+                },
+            },
+            dashed: {
+                enumerable: true,
+                get() {
+                    return Boolean('USE_DASH' in this.defines);
+                },
+                set(value) {
+                    if (Boolean(value) !== Boolean('USE_DASH' in this.defines)) {
+                        this.needsUpdate = true;
+                    }
+                    if (value === true) {
+                        this.defines.USE_DASH = '';
+                    }
+                    else {
+                        delete this.defines.USE_DASH;
+                    }
+                },
+            },
+            dashScale: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.dashScale.value;
+                },
+                set(value) {
+                    this.uniforms.dashScale.value = value;
+                },
+            },
+            dashSize: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.dashSize.value;
+                },
+                set(value) {
+                    this.uniforms.dashSize.value = value;
+                },
+            },
+            dashOffset: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.dashOffset.value;
+                },
+                set(value) {
+                    this.uniforms.dashOffset.value = value;
+                },
+            },
+            gapSize: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.gapSize.value;
+                },
+                set(value) {
+                    this.uniforms.gapSize.value = value;
+                },
+            },
+            opacity: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.opacity.value;
+                },
+                set(value) {
+                    this.uniforms.opacity.value = value;
+                },
+            },
+            resolution: {
+                enumerable: true,
+                get() {
+                    return this.uniforms.resolution.value;
+                },
+                set(value) {
+                    this.uniforms.resolution.value.copy(value);
+                },
+            },
+            alphaToCoverage: {
+                enumerable: true,
+                get() {
+                    return Boolean('ALPHA_TO_COVERAGE' in this.defines);
+                },
+                set(value) {
+                    if (Boolean(value) !== Boolean('ALPHA_TO_COVERAGE' in this.defines)) {
+                        this.needsUpdate = true;
+                    }
+                    if (value) {
+                        this.defines.ALPHA_TO_COVERAGE = '';
+                        this.extensions.derivatives = true;
+                    }
+                    else {
+                        delete this.defines.ALPHA_TO_COVERAGE;
+                        this.extensions.derivatives = false;
+                    }
+                },
+            },
+        });
+        this.setValues(parameters);
+    }
+}
+export { LineMaterial };

package/lib/external/lines/line-segments-2.d.ts

@@ -0,0 +1,7 @@
+import { NS_THREE } from '../../owlly/stage/externals';
+declare class LineSegments2 extends NS_THREE.Mesh {
+    isLineSegments2: boolean;
+    computeLineDistances: Function;
+    constructor(geometry: any, material: any);
+}
+export { LineSegments2 };

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

@@ -0,0 +1,143 @@
+/* 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, no-param-reassign, no-shadow */
+import { Externals, NS_THREE } from '../../owlly/stage/externals';
+import { LineSegmentsGeometry } from './line-segments-geometry';
+import { LineMaterial } from './line-material';
+class LineSegments2 extends NS_THREE.Mesh {
+    constructor(geometry, material) {
+        super(geometry || new LineSegmentsGeometry(), material || new LineMaterial({ color: Math.random() * 0xffffff }));
+        this.isLineSegments2 = true;
+        const { THREE } = Externals.getInstance();
+        this.type = 'LineSegments2';
+        const that = this;
+        this.computeLineDistances = (function () {
+            const start = new THREE.Vector3();
+            const end = new THREE.Vector3();
+            return function () {
+                const { geometry } = that;
+                const { instanceStart } = geometry.attributes;
+                const { instanceEnd } = geometry.attributes;
+                const lineDistances = new Float32Array(2 * instanceStart.count);
+                for (let i = 0, j = 0, l = instanceStart.count; i < l; i += 1, j += 2) {
+                    start.fromBufferAttribute(instanceStart, i);
+                    end.fromBufferAttribute(instanceEnd, i);
+                    lineDistances[j] = (j === 0) ? 0 : lineDistances[j - 1];
+                    lineDistances[j + 1] = lineDistances[j] + start.distanceTo(end);
+                }
+                const instanceDistanceBuffer = new THREE.InstancedInterleavedBuffer(lineDistances, 2, 1); // d0, d1
+                geometry.setAttribute('instanceDistanceStart', new THREE.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0)); // d0
+                geometry.setAttribute('instanceDistanceEnd', new THREE.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1)); // d1
+                return that;
+            };
+        }());
+        this.raycast = (function () {
+            const start = new THREE.Vector4();
+            const end = new THREE.Vector4();
+            const ssOrigin = new THREE.Vector4();
+            const ssOrigin3 = new THREE.Vector3();
+            const mvMatrix = new THREE.Matrix4();
+            const line = new THREE.Line3();
+            const closestPoint = new THREE.Vector3();
+            return function (raycaster, intersects) {
+                if (raycaster.camera === null) {
+                    console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2.');
+                }
+                const threshold = (raycaster.params.Line2 !== undefined) ? raycaster.params.Line2.threshold || 0 : 0;
+                const { ray } = raycaster;
+                const { camera } = raycaster;
+                const { projectionMatrix } = camera;
+                const { geometry } = that;
+                const { material } = that;
+                const { resolution } = material;
+                const lineWidth = material.linewidth + threshold;
+                const { instanceStart } = geometry.attributes;
+                const { instanceEnd } = geometry.attributes;
+                // camera forward is negative
+                const near = -camera.near;
+                // pick a point 1 unit out along the ray to avoid the ray origin
+                // sitting at the camera origin which will cause "w" to be 0 when
+                // applying the projection matrix.
+                ray.at(1, ssOrigin);
+                // ndc space [ - 1.0, 1.0 ]
+                ssOrigin.w = 1;
+                ssOrigin.applyMatrix4(camera.matrixWorldInverse);
+                ssOrigin.applyMatrix4(projectionMatrix);
+                ssOrigin.multiplyScalar(1 / ssOrigin.w);
+                // screen space
+                ssOrigin.x *= resolution.x / 2;
+                ssOrigin.y *= resolution.y / 2;
+                ssOrigin.z = 0;
+                ssOrigin3.copy(new THREE.Vector3(ssOrigin.x, ssOrigin.y, ssOrigin.z));
+                const { matrixWorld } = that;
+                mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld);
+                for (let i = 0, l = instanceStart.count; i < l; i++) {
+                    start.fromBufferAttribute(instanceStart, i);
+                    end.fromBufferAttribute(instanceEnd, i);
+                    start.w = 1;
+                    end.w = 1;
+                    // camera space
+                    start.applyMatrix4(mvMatrix);
+                    end.applyMatrix4(mvMatrix);
+                    // skip the segment if it's entirely behind the camera
+                    const isBehindCameraNear = start.z > near && end.z > near;
+                    if (isBehindCameraNear) {
+                        continue;
+                    }
+                    // trim the segment if it extends behind camera near
+                    if (start.z > near) {
+                        const deltaDist = start.z - end.z;
+                        const t = (start.z - near) / deltaDist;
+                        start.lerp(end, t);
+                    }
+                    else if (end.z > near) {
+                        const deltaDist = end.z - start.z;
+                        const t = (end.z - near) / deltaDist;
+                        end.lerp(start, t);
+                    }
+                    // clip space
+                    start.applyMatrix4(projectionMatrix);
+                    end.applyMatrix4(projectionMatrix);
+                    // ndc space [ - 1.0, 1.0 ]
+                    start.multiplyScalar(1 / start.w);
+                    end.multiplyScalar(1 / end.w);
+                    // screen space
+                    start.x *= resolution.x / 2;
+                    start.y *= resolution.y / 2;
+                    end.x *= resolution.x / 2;
+                    end.y *= resolution.y / 2;
+                    // create 2d segment
+                    line.start.set(start.x, start.y, line.start.z);
+                    line.start.z = 0;
+                    line.end.set(end.x, end.y, line.end.z);
+                    line.end.z = 0;
+                    // get closest point on ray to segment
+                    const param = line.closestPointToPointParameter(ssOrigin3, true);
+                    line.at(param, closestPoint);
+                    // check if the intersection point is within clip space
+                    const zPos = THREE.MathUtils.lerp(start.z, end.z, param);
+                    const isInClipSpace = zPos >= -1 && zPos <= 1;
+                    const isInside = ssOrigin3.distanceTo(closestPoint) < lineWidth * 0.5;
+                    if (isInClipSpace && isInside) {
+                        line.start.fromBufferAttribute(instanceStart, i);
+                        line.end.fromBufferAttribute(instanceEnd, i);
+                        line.start.applyMatrix4(matrixWorld);
+                        line.end.applyMatrix4(matrixWorld);
+                        const pointOnLine = new THREE.Vector3();
+                        const point = new THREE.Vector3();
+                        ray.distanceSqToSegment(line.start, line.end, point, pointOnLine);
+                        intersects.push({
+                            point,
+                            pointOnLine,
+                            distance: ray.origin.distanceTo(point),
+                            object: that,
+                            face: null,
+                            faceIndex: i,
+                            uv: null,
+                            uv2: null,
+                        });
+                    }
+                }
+            };
+        }());
+    }
+}
+export { LineSegments2 };

package/lib/external/lines/line-segments-geometry.d.ts

@@ -0,0 +1,15 @@
+import { NS_THREE } from '../../owlly/stage/externals';
+declare class LineSegmentsGeometry extends NS_THREE.InstancedBufferGeometry {
+    isLineSegmentsGeometry: true;
+    constructor();
+    applyMatrix4(matrix: any): this;
+    setPositions(array: any): this;
+    setColors(array: any): this;
+    fromWireframeGeometry(geometry: any): this;
+    fromEdgesGeometry(geometry: any): this;
+    fromMesh(mesh: any): this;
+    fromLineSegments(lineSegments: any): any;
+    toJSON(): any;
+    applyMatrix(matrix: any): any;
+}
+export { LineSegmentsGeometry };