@myned-ai/gsplat-flame-avatar-renderer 1.0.6 → 1.0.7

package/src/raycaster/Hit.js

@@ -1,37 +0,0 @@
-/**
- * Hit
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * This file is functionally identical to the original.
- */
-
-import * as THREE from 'three';
-
-export class Hit {
-
-    constructor() {
-        this.origin = new THREE.Vector3();
-        this.normal = new THREE.Vector3();
-        this.distance = 0;
-        this.splatIndex = 0;
-    }
-
-    set(origin, normal, distance, splatIndex) {
-        this.origin.copy(origin);
-        this.normal.copy(normal);
-        this.distance = distance;
-        this.splatIndex = splatIndex;
-    }
-
-    clone() {
-        const hitClone = new Hit();
-        hitClone.origin.copy(this.origin);
-        hitClone.normal.copy(this.normal);
-        hitClone.distance = this.distance;
-        hitClone.splatIndex = this.splatIndex;
-        return hitClone;
-    }
-
-}

package/src/raycaster/Ray.js

@@ -1,123 +0,0 @@
-/**
- * Ray
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * This file is functionally identical to the original.
- */
-
-import * as THREE from 'three';
-
-const VectorRight = new THREE.Vector3(1, 0, 0);
-const VectorUp = new THREE.Vector3(0, 1, 0);
-const VectorBackward = new THREE.Vector3(0, 0, 1);
-
-export class Ray {
-
-    constructor(origin = new THREE.Vector3(), direction = new THREE.Vector3()) {
-        this.origin = new THREE.Vector3();
-        this.direction = new THREE.Vector3();
-        this.setParameters(origin, direction);
-    }
-
-    setParameters(origin, direction) {
-        this.origin.copy(origin);
-        this.direction.copy(direction).normalize();
-    }
-
-    boxContainsPoint(box, point, epsilon) {
-        return point.x < box.min.x - epsilon || point.x > box.max.x + epsilon ||
-               point.y < box.min.y - epsilon || point.y > box.max.y + epsilon ||
-               point.z < box.min.z - epsilon || point.z > box.max.z + epsilon ? false : true;
-    }
-
-    intersectBox = function() {
-
-        const planeIntersectionPoint = new THREE.Vector3();
-        const planeIntersectionPointArray = [];
-        const originArray = [];
-        const directionArray = [];
-
-        return function(box, outHit) {
-
-            originArray[0] = this.origin.x;
-            originArray[1] = this.origin.y;
-            originArray[2] = this.origin.z;
-            directionArray[0] = this.direction.x;
-            directionArray[1] = this.direction.y;
-            directionArray[2] = this.direction.z;
-
-            if (this.boxContainsPoint(box, this.origin, 0.0001)) {
-                if (outHit) {
-                    outHit.origin.copy(this.origin);
-                    outHit.normal.set(0, 0, 0);
-                    outHit.distance = -1;
-                }
-                return true;
-            }
-
-            for (let i = 0; i < 3; i++) {
-                if (directionArray[i] == 0.0) continue;
-
-                const hitNormal = i == 0 ? VectorRight : i == 1 ? VectorUp : VectorBackward;
-                const extremeVec = directionArray[i] < 0 ? box.max : box.min;
-                let multiplier = -Math.sign(directionArray[i]);
-                planeIntersectionPointArray[0] = i == 0 ? extremeVec.x : i == 1 ? extremeVec.y : extremeVec.z;
-                let toSide = planeIntersectionPointArray[0] - originArray[i];
-
-                if (toSide * multiplier < 0) {
-                    const idx1 = (i + 1) % 3;
-                    const idx2 = (i + 2) % 3;
-                    planeIntersectionPointArray[2] = directionArray[idx1] / directionArray[i] * toSide + originArray[idx1];
-                    planeIntersectionPointArray[1] = directionArray[idx2] / directionArray[i] * toSide + originArray[idx2];
-                    planeIntersectionPoint.set(planeIntersectionPointArray[i],
-                                               planeIntersectionPointArray[idx2],
-                                               planeIntersectionPointArray[idx1]);
-                    if (this.boxContainsPoint(box, planeIntersectionPoint, 0.0001)) {
-                        if (outHit) {
-                            outHit.origin.copy(planeIntersectionPoint);
-                            outHit.normal.copy(hitNormal).multiplyScalar(multiplier);
-                            outHit.distance = planeIntersectionPoint.sub(this.origin).length();
-                        }
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        };
-
-    }();
-
-    intersectSphere = function() {
-
-        const toSphereCenterVec = new THREE.Vector3();
-
-        return function(center, radius, outHit) {
-            toSphereCenterVec.copy(center).sub(this.origin);
-            const toClosestApproach = toSphereCenterVec.dot(this.direction);
-            const toClosestApproachSq = toClosestApproach * toClosestApproach;
-            const toSphereCenterSq = toSphereCenterVec.dot(toSphereCenterVec);
-            const diffSq = toSphereCenterSq - toClosestApproachSq;
-            const radiusSq = radius * radius;
-
-            if (diffSq > radiusSq) return false;
-
-            const thc = Math.sqrt(radiusSq - diffSq);
-            const t0 = toClosestApproach - thc;
-            const t1 = toClosestApproach + thc;
-
-            if (t1 < 0) return false;
-            let t = t0 < 0 ? t1 : t0;
-
-            if (outHit) {
-                outHit.origin.copy(this.origin).addScaledVector(this.direction, t);
-                outHit.normal.copy(outHit.origin).sub(center).normalize();
-                outHit.distance = t;
-            }
-            return true;
-        };
-
-    }();
-}

package/src/raycaster/Raycaster.js

@@ -1,175 +0,0 @@
-/**
- * Raycaster
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- * https://github.com/mkkellogg/GaussianSplats3D
- * 
- * Import paths adjusted for gsplat-flame-avatar package structure.
- */
-
-import * as THREE from 'three';
-import { Ray } from './Ray.js';
-import { Hit } from './Hit.js';
-import { SplatRenderMode } from '../enums/index.js';
-
-export class Raycaster {
-
-    constructor(origin, direction, raycastAgainstTrueSplatEllipsoid = false) {
-        this.ray = new Ray(origin, direction);
-        this.raycastAgainstTrueSplatEllipsoid = raycastAgainstTrueSplatEllipsoid;
-    }
-
-    setFromCameraAndScreenPosition = function() {
-
-        const ndcCoords = new THREE.Vector2();
-
-        return function(camera, screenPosition, screenDimensions) {
-            ndcCoords.x = screenPosition.x / screenDimensions.x * 2.0 - 1.0;
-            ndcCoords.y = (screenDimensions.y - screenPosition.y) / screenDimensions.y * 2.0 - 1.0;
-            if (camera.isPerspectiveCamera) {
-                this.ray.origin.setFromMatrixPosition(camera.matrixWorld);
-                this.ray.direction.set(ndcCoords.x, ndcCoords.y, 0.5 ).unproject(camera).sub(this.ray.origin).normalize();
-                this.camera = camera;
-            } else if (camera.isOrthographicCamera) {
-                this.ray.origin.set(ndcCoords.x, ndcCoords.y,
-                                   (camera.near + camera.far) / (camera.near - camera.far)).unproject(camera);
-                this.ray.direction.set(0, 0, -1).transformDirection(camera.matrixWorld);
-                this.camera = camera;
-            } else {
-                throw new Error('Raycaster::setFromCameraAndScreenPosition() -> Unsupported camera type');
-            }
-        };
-
-    }();
-
-    intersectSplatMesh = function() {
-
-        const toLocal = new THREE.Matrix4();
-        const fromLocal = new THREE.Matrix4();
-        const sceneTransform = new THREE.Matrix4();
-        const localRay = new Ray();
-        const tempPoint = new THREE.Vector3();
-
-        return function(splatMesh, outHits = []) {
-            const splatTree = splatMesh.getSplatTree();
-
-            if (!splatTree) return;
-
-            for (let s = 0; s < splatTree.subTrees.length; s++) {
-                const subTree = splatTree.subTrees[s];
-
-                fromLocal.copy(splatMesh.matrixWorld);
-                if (splatMesh.dynamicMode) {
-                    splatMesh.getSceneTransform(s, sceneTransform);
-                    fromLocal.multiply(sceneTransform);
-                }
-                toLocal.copy(fromLocal).invert();
-
-                localRay.origin.copy(this.ray.origin).applyMatrix4(toLocal);
-                localRay.direction.copy(this.ray.origin).add(this.ray.direction);
-                localRay.direction.applyMatrix4(toLocal).sub(localRay.origin).normalize();
-
-                const outHitsForSubTree = [];
-                if (subTree.rootNode) {
-                    this.castRayAtSplatTreeNode(localRay, splatTree, subTree.rootNode, outHitsForSubTree);
-                }
-
-                outHitsForSubTree.forEach((hit) => {
-                    hit.origin.applyMatrix4(fromLocal);
-                    hit.normal.applyMatrix4(fromLocal).normalize();
-                    hit.distance = tempPoint.copy(hit.origin).sub(this.ray.origin).length();
-                });
-
-                outHits.push(...outHitsForSubTree);
-            }
-
-            outHits.sort((a, b) => {
-                if (a.distance > b.distance) return 1;
-                else return -1;
-            });
-
-            return outHits;
-        };
-
-    }();
-
-    castRayAtSplatTreeNode = function() {
-
-        const tempColor = new THREE.Vector4();
-        const tempCenter = new THREE.Vector3();
-        const tempScale = new THREE.Vector3();
-        const tempRotation = new THREE.Quaternion();
-        const tempHit = new Hit();
-        const scaleEpsilon = 0.0000001;
-
-        const origin = new THREE.Vector3(0, 0, 0);
-        const uniformScaleMatrix = new THREE.Matrix4();
-        const scaleMatrix = new THREE.Matrix4();
-        const rotationMatrix = new THREE.Matrix4();
-        const toSphereSpace = new THREE.Matrix4();
-        const fromSphereSpace = new THREE.Matrix4();
-        const tempRay = new Ray();
-
-        return function(ray, splatTree, node, outHits = []) {
-            if (!ray.intersectBox(node.boundingBox)) {
-                return;
-            }
-            if (node.data && node.data.indexes && node.data.indexes.length > 0) {
-                for (let i = 0; i < node.data.indexes.length; i++) {
-
-                    const splatGlobalIndex = node.data.indexes[i];
-                    const splatSceneIndex = splatTree.splatMesh.getSceneIndexForSplat(splatGlobalIndex);
-                    const splatScene = splatTree.splatMesh.getScene(splatSceneIndex);
-                    if (!splatScene.visible) continue;
-
-                    splatTree.splatMesh.getSplatColor(splatGlobalIndex, tempColor);
-                    splatTree.splatMesh.getSplatCenter(splatGlobalIndex, tempCenter);
-                    splatTree.splatMesh.getSplatScaleAndRotation(splatGlobalIndex, tempScale, tempRotation);
-
-                    if (tempScale.x <= scaleEpsilon || tempScale.y <= scaleEpsilon ||
-                        splatTree.splatMesh.splatRenderMode === SplatRenderMode.ThreeD && tempScale.z <= scaleEpsilon) {
-                        continue;
-                    }
-
-                    if (!this.raycastAgainstTrueSplatEllipsoid) {
-                        let radius = (tempScale.x + tempScale.y);
-                        let componentCount = 2;
-                        if (splatTree.splatMesh.splatRenderMode === SplatRenderMode.ThreeD) {
-                            radius += tempScale.z;
-                            componentCount = 3;
-                        }
-                        radius = radius / componentCount;
-                        if (ray.intersectSphere(tempCenter, radius, tempHit)) {
-                            const hitClone = tempHit.clone();
-                            hitClone.splatIndex = splatGlobalIndex;
-                            outHits.push(hitClone);
-                        }
-                    } else {
-                        scaleMatrix.makeScale(tempScale.x, tempScale.y, tempScale.z);
-                        rotationMatrix.makeRotationFromQuaternion(tempRotation);
-                        const uniformScale = Math.log10(tempColor.w) * 2.0;
-                        uniformScaleMatrix.makeScale(uniformScale, uniformScale, uniformScale);
-                        fromSphereSpace.copy(uniformScaleMatrix).multiply(rotationMatrix).multiply(scaleMatrix);
-                        toSphereSpace.copy(fromSphereSpace).invert();
-                        tempRay.origin.copy(ray.origin).sub(tempCenter).applyMatrix4(toSphereSpace);
-                        tempRay.direction.copy(ray.origin).add(ray.direction).sub(tempCenter);
-                        tempRay.direction.applyMatrix4(toSphereSpace).sub(tempRay.origin).normalize();
-                        if (tempRay.intersectSphere(origin, 1.0, tempHit)) {
-                            const hitClone = tempHit.clone();
-                            hitClone.splatIndex = splatGlobalIndex;
-                            hitClone.origin.applyMatrix4(fromSphereSpace).add(tempCenter);
-                            outHits.push(hitClone);
-                        }
-                    }
-                }
-             }
-            if (node.children && node.children.length > 0) {
-                for (let child of node.children) {
-                    this.castRayAtSplatTreeNode(ray, splatTree, child, outHits);
-                }
-            }
-            return outHits;
-        };
-
-    }();
-}

package/src/raycaster/index.js

@@ -1,10 +0,0 @@
-/**
- * gsplat-flame-avatar - Raycaster Module
- * Intersection testing for splat picking/selection.
- * 
- * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
- */
-
-export { Ray } from './Ray.js';
-export { Hit } from './Hit.js';
-export { Raycaster } from './Raycaster.js';