Spaces:

jbilcke-hf
/

GenCity

Running

App Files Files Community

jbilcke-hf HF staff commited on 15 days ago

Commit

a28eca3

verified ·

1 Parent(s): 48f9320

Upload 372 files

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

index.html +740 -18
libs/gradio-client.js/1.10.0/gradio-client.js +8 -0
libs/three.js/0.172.0/jsm/Addons.js +287 -0
libs/three.js/0.172.0/jsm/animation/AnimationClipCreator.js +116 -0
libs/three.js/0.172.0/jsm/animation/CCDIKSolver.js +485 -0
libs/three.js/0.172.0/jsm/capabilities/WebGL.js +114 -0
libs/three.js/0.172.0/jsm/capabilities/WebGPU.js +48 -0
libs/three.js/0.172.0/jsm/controls/ArcballControls.js +3253 -0
libs/three.js/0.172.0/jsm/controls/DragControls.js +410 -0
libs/three.js/0.172.0/jsm/controls/FirstPersonControls.js +337 -0
libs/three.js/0.172.0/jsm/controls/FlyControls.js +332 -0
libs/three.js/0.172.0/jsm/controls/MapControls.js +28 -0
libs/three.js/0.172.0/jsm/controls/OrbitControls.js +1556 -0
libs/three.js/0.172.0/jsm/controls/PointerLockControls.js +168 -0
libs/three.js/0.172.0/jsm/controls/TrackballControls.js +849 -0
libs/three.js/0.172.0/jsm/controls/TransformControls.js +1624 -0
libs/three.js/0.172.0/jsm/csm/CSM.js +384 -0
libs/three.js/0.172.0/jsm/csm/CSMFrustum.js +155 -0
libs/three.js/0.172.0/jsm/csm/CSMHelper.js +195 -0
libs/three.js/0.172.0/jsm/csm/CSMShader.js +295 -0
libs/three.js/0.172.0/jsm/csm/CSMShadowNode.js +442 -0
libs/three.js/0.172.0/jsm/curves/CurveExtras.js +422 -0
libs/three.js/0.172.0/jsm/curves/NURBSCurve.js +111 -0
libs/three.js/0.172.0/jsm/curves/NURBSSurface.js +52 -0
libs/three.js/0.172.0/jsm/curves/NURBSUtils.js +545 -0
libs/three.js/0.172.0/jsm/curves/NURBSVolume.js +62 -0
libs/three.js/0.172.0/jsm/effects/AnaglyphEffect.js +147 -0
libs/three.js/0.172.0/jsm/effects/AsciiEffect.js +263 -0
libs/three.js/0.172.0/jsm/effects/OutlineEffect.js +539 -0
libs/three.js/0.172.0/jsm/effects/ParallaxBarrierEffect.js +125 -0
libs/three.js/0.172.0/jsm/effects/PeppersGhostEffect.js +153 -0
libs/three.js/0.172.0/jsm/effects/StereoEffect.js +60 -0
libs/three.js/0.172.0/jsm/environments/DebugEnvironment.js +52 -0
libs/three.js/0.172.0/jsm/environments/RoomEnvironment.js +144 -0
libs/three.js/0.172.0/jsm/exporters/DRACOExporter.js +269 -0
libs/three.js/0.172.0/jsm/exporters/EXRExporter.js +587 -0
libs/three.js/0.172.0/jsm/exporters/GLTFExporter.js +3460 -0
libs/three.js/0.172.0/jsm/exporters/KTX2Exporter.js +323 -0
libs/three.js/0.172.0/jsm/exporters/OBJExporter.js +288 -0
libs/three.js/0.172.0/jsm/exporters/PLYExporter.js +530 -0
libs/three.js/0.172.0/jsm/exporters/STLExporter.js +199 -0
libs/three.js/0.172.0/jsm/exporters/USDZExporter.js +782 -0
libs/three.js/0.172.0/jsm/geometries/BoxLineGeometry.js +69 -0
libs/three.js/0.172.0/jsm/geometries/ConvexGeometry.js +53 -0
libs/three.js/0.172.0/jsm/geometries/DecalGeometry.js +408 -0
libs/three.js/0.172.0/jsm/geometries/ParametricGeometries.js +254 -0
libs/three.js/0.172.0/jsm/geometries/ParametricGeometry.js +139 -0
libs/three.js/0.172.0/jsm/geometries/RoundedBoxGeometry.js +155 -0
libs/three.js/0.172.0/jsm/geometries/TeapotGeometry.js +704 -0
libs/three.js/0.172.0/jsm/geometries/TextGeometry.js +54 -0

index.html CHANGED Viewed

@@ -1,19 +1,741 @@
-<!doctype html>
 <html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

+<!DOCTYPE html>
 <html>
+<head>
+    <title>Text to Terrain Generator</title>
+    <style>
+        body { margin: 0; }
+        canvas { display: block; }
+        #prompt-input {
+            position: absolute;
+            top: 10px;
+            left: 10px;
+            padding: 8px;
+            width: 200px;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            font-size: 14px;
+        }
+        #camera-toggle {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            padding: 8px 16px;
+            background-color: #3498db;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: background-color 0.3s;
+        }
+        #camera-toggle:hover {
+            background-color: #2980b9;
+        }
+        #heightmap {
+            display: none;
+        }
+        #loadingOverlay {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0, 0, 0, 0.7);
+            z-index: 9999;
+            justify-content: center;
+            align-items: center;
+        }
+        .loader {
+            border: 5px solid #f3f3f3;
+            border-top: 5px solid #3498db;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            animation: spin 1s linear infinite;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+    </style>
+</head>
+<body>
+    <input type="text" id="prompt-input" placeholder="Countryside house with trees..">
+    <button id="camera-toggle">Toggle Camera</button>
+    <div id="loadingOverlay">
+        <div class="loader"></div>
+    </div>
+    <canvas id="heightmap" width="256" height="256"></canvas>
+    <script type="importmap">
+        {
+            "imports": {
+                "three": "/libs/three.js/0.172.0/three.module.min.js",
+                "three/addons/": "/libs/three.js/0.172.0/jsm/",
+                "@gradio/client": "/libs/gradio-client.js/1.10.0/gradio-client.js"
+            }
+        }
+    </script>
+    <script type="module">
+        import * as THREE from 'three';
+        import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+        import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+        import { Client } from "@gradio/client";
+        let isLoading = false;
+        let lastPromptInputValue = "";
+        let isDragging = false;
+        let mouseDownPosition = new THREE.Vector2();
+        const objectCountByType = new Map();
+        let terrainInstances;
+        let objectInstances = new Map();
+        const TILE_SIZE = 4;
+        const GRID_SIZE = 10;
+        let currentTileType = null;
+        let hoveredTileIndex = -1;
+        const raycaster = new THREE.Raycaster();
+        const mouse = new THREE.Vector2();
+        let highlightMesh = null;
+        const tileTypes = new Map();
+        const gltfLoader = new GLTFLoader();
+        // Scene setup
+        const scene = new THREE.Scene();
+        scene.background = new THREE.Color(0x87CEEB);
+        // Camera setup with both perspectives
+        const frustumSize = 40;
+        const aspect = window.innerWidth / window.innerHeight;
+        const orthoCamera = new THREE.OrthographicCamera(
+            -20, 20, 20, -20,
+            0.1, 2000
+        );
+        orthoCamera.position.set(20, 20, -20);
+        orthoCamera.lookAt(0, 0, 0);
+        const perspCamera = new THREE.PerspectiveCamera(
+            75, window.innerWidth / window.innerHeight, 0.1, 2000
+        );
+        perspCamera.position.set(20, 20, -20);
+        perspCamera.lookAt(0, 0, 0);
+        let currentCamera = orthoCamera;
+        let isOrthographic = true;
+        // Renderer setup
+        const renderer = new THREE.WebGLRenderer({ antialias: true });
+        renderer.setSize(window.innerWidth, window.innerHeight);
+        renderer.shadowMap.enabled = true;
+        renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+        document.body.appendChild(renderer.domElement);
+        // Controls
+        let controls = new OrbitControls(currentCamera, renderer.domElement);
+        controls.enableDamping = true;
+       // Lighting
+        const directionalLight = new THREE.DirectionalLight(0xffffff, 4.5); // Increased from 1.5 to 4.5
+        directionalLight.position.set(20, 30, 20);
+        directionalLight.castShadow = true;
+        // Improve shadow quality
+        directionalLight.shadow.mapSize.width = 2048;
+        directionalLight.shadow.mapSize.height = 2048;
+        directionalLight.shadow.camera.near = 0.1;
+        directionalLight.shadow.camera.far = 100;
+        directionalLight.shadow.camera.left = -30;
+        directionalLight.shadow.camera.right = 30;
+        directionalLight.shadow.camera.top = 30;
+        directionalLight.shadow.camera.bottom = -30;
+        directionalLight.shadow.bias = -0.001;
+        // Add a brighter ambient light
+        scene.add(new THREE.AmbientLight(0x404040, 1.2));
+        // Add lighter fog
+        scene.fog = new THREE.FogExp2(0x87CEEB, 0.015);
+        // Enable shadow mapping in the renderer
+        renderer.shadowMap.enabled = true;
+        renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+        scene.add(directionalLight);
+        // Height map generation
+        const canvasH = document.getElementById('heightmap');
+        const ctx = canvasH.getContext('2d');
+        const heightMap = new THREE.CanvasTexture(canvasH);
+        function createSeamlessNoise(size, octaves) {
+            const noise = new Array(size * size).fill(0);
+            function smoothStep(t) {
+                return t * t * (3 - 2 * t);
+            }
+            function interpolate(a, b, t) {
+                return a + (b - a) * smoothStep(t);
+            }
+            for (let octave = 0; octave < octaves; octave++) {
+                const frequency = 1 << octave;
+                const amplitude = 1 / (1 << octave);
+                const grid = new Array((frequency + 1) * (frequency + 1));
+                for (let i = 0; i <= frequency; i++) {
+                    for (let j = 0; j <= frequency; j++) {
+                        grid[i * (frequency + 1) + j] = Math.random();
+                    }
+                }
+                for (let i = 0; i <= frequency; i++) {
+                    grid[i * (frequency + 1) + frequency] = grid[i * (frequency + 1)];
+                }
+                for (let j = 0; j <= frequency; j++) {
+                    grid[frequency * (frequency + 1) + j] = grid[j];
+                }
+                grid[frequency * (frequency + 1) + frequency] = grid[0];
+                const cellSize = size / frequency;
+                for (let y = 0; y < size; y++) {
+                    for (let x = 0; x < size; x++) {
+                        const gridX = Math.floor(x / cellSize);
+                        const gridY = Math.floor(y / cellSize);
+                        const fracX = (x % cellSize) / cellSize;
+                        const fracY = (y % cellSize) / cellSize;
+                        const v1 = grid[gridY * (frequency + 1) + gridX];
+                        const v2 = grid[gridY * (frequency + 1) + (gridX + 1)];
+                        const v3 = grid[(gridY + 1) * (frequency + 1) + gridX];
+                        const v4 = grid[(gridY + 1) * (frequency + 1) + (gridX + 1)];
+                        const i1 = interpolate(v1, v2, fracX);
+                        const i2 = interpolate(v3, v4, fracX);
+                        const value = interpolate(i1, i2, fracY);
+                        noise[y * size + x] += value * amplitude;
+                    }
+                }
+            }
+            return noise;
+        }
+        function createHeightMap() {
+            const size = 256;
+            const noise = createSeamlessNoise(size, 8);
+            const imageData = ctx.createImageData(size, size);
+            let min = Infinity, max = -Infinity;
+            for (let i = 0; i < noise.length; i++) {
+                min = Math.min(min, noise[i]);
+                max = Math.max(max, noise[i]);
+            }
+            for (let i = 0; i < noise.length; i++) {
+                const normalized = Math.floor(((noise[i] - min) / (max - min)) * 255);
+                imageData.data[i * 4] = normalized;
+                imageData.data[i * 4 + 1] = normalized;
+                imageData.data[i * 4 + 2] = normalized;
+                imageData.data[i * 4 + 3] = 255;
+            }
+            ctx.putImageData(imageData, 0, 0);
+            heightMap.needsUpdate = true;
+            if (terrainInstances?.material) {
+                terrainInstances.material.displacementMap = heightMap;
+                terrainInstances.material.needsUpdate = true;
+            }
+        }
+        // Create base terrain type
+        function createBaseTileType() {
+            const geometry = new THREE.PlaneGeometry(TILE_SIZE, TILE_SIZE, 64, 64);
+            const material = new THREE.MeshStandardMaterial({
+                color: 0x46732a,
+                displacementMap: heightMap,
+                displacementScale: 0.8,
+                flatShading: false,
+                side: THREE.DoubleSide,
+                shadowSide: THREE.DoubleSide
+            });
+            tileTypes.set('base', { geometry, material });
+        }
+        function createHighlightMesh() {
+            const geometry = new THREE.PlaneGeometry(TILE_SIZE, TILE_SIZE);
+            const edges = new THREE.EdgesGeometry(geometry);
+            const material = new THREE.LineBasicMaterial({
+                color: 0xffff00,
+                linewidth: 2,
+                transparent: true,
+                opacity: 0.9
+            });
+            highlightMesh = new THREE.LineSegments(edges, material);
+            highlightMesh.rotation.x = -Math.PI / 2;
+            highlightMesh.visible = false;
+            scene.add(highlightMesh);
+        }
+        function initializeTerrain() {
+            createBaseTileType();
+            createHighlightMesh();
+            const baseTile = tileTypes.get('base');
+            const instanceCount = GRID_SIZE * GRID_SIZE;
+            terrainInstances = new THREE.InstancedMesh(
+                baseTile.geometry,
+                baseTile.material,
+                instanceCount
+            );
+            terrainInstances.castShadow = true;
+            terrainInstances.receiveShadow = true;
+            const matrix = new THREE.Matrix4();
+            const position = new THREE.Vector3();
+            const rotation = new THREE.Euler();
+            const quaternion = new THREE.Quaternion();
+            const scale = new THREE.Vector3(1, 1, 1);
+            let index = 0;
+            const offset = (GRID_SIZE * TILE_SIZE) / 2 - TILE_SIZE / 2;
+            for (let x = 0; x < GRID_SIZE; x++) {
+                for (let z = 0; z < GRID_SIZE; z++) {
+                    position.set(
+                        x * TILE_SIZE - offset,
+                        0,
+                        z * TILE_SIZE - offset
+                    );
+                    rotation.set(-Math.PI / 2, 0, 0);
+                    quaternion.setFromEuler(rotation);
+                    matrix.compose(position, quaternion, scale);
+                    terrainInstances.setMatrixAt(index, matrix);
+                    index++;
+                }
+            }
+            scene.add(terrainInstances);
+        }
+        async function createGLBTileType(modelUrl, typeName) {
+            return new Promise((resolve, reject) => {
+                gltfLoader.load(modelUrl, (gltf) => {
+                    const model = gltf.scene;
+                    const box = new THREE.Box3().setFromObject(model);
+                    const size = box.getSize(new THREE.Vector3());
+                    const geometry = new THREE.BoxGeometry(1, 1, 1);
+                    const material = new THREE.MeshStandardMaterial({ visible: false });
+                    tileTypes.set(typeName, {
+                        geometry,
+                        material,
+                        model: model.clone()
+                    });
+                    resolve();
+                }, undefined, reject);
+            });
+        }
+        // First, create a function to find the Y position of the widest cross-section
+        function findWidestCrossSection(mesh) {
+        // Track the maximum width/depth we find and its Y position
+        let maxArea = 0;
+        let maxAreaY = 0;
+        // Get all vertices from the mesh and its children
+        const vertices = [];
+        mesh.traverse((child) => {
+        if (child.isMesh && child.geometry) {
+            const positions = child.geometry.attributes.position;
+            const vertexCount = positions.count;
+            // Transform vertices to world space
+            const matrix = child.matrixWorld;
+            for (let i = 0; i < vertexCount; i++) {
+            const vertex = new THREE.Vector3();
+            vertex.fromBufferAttribute(positions, i);
+            vertex.applyMatrix4(matrix);
+            vertices.push(vertex);
+            }
+        }
+        });
+        if (vertices.length === 0) return 0;
+        // Find Y range to analyze
+        const yValues = vertices.map(v => v.y);
+        const minY = Math.min(...yValues);
+        const maxY = Math.max(...yValues);
+        // Sample Y positions at regular intervals
+        const steps = 128; // Number of cross-sections to check
+        const yStep = (maxY - minY) / steps;
+        for (let i = 0; i <= steps; i++) {
+        const currentY = minY + (i * yStep);
+        // Find vertices near this Y level (within small threshold)
+        const threshold = yStep / 2;
+        const sectionVertices = vertices.filter(v =>
+            Math.abs(v.y - currentY) < threshold
+        );
+        if (sectionVertices.length > 0) {
+            // Calculate bounding area of this cross-section
+            const xValues = sectionVertices.map(v => v.x);
+            const zValues = sectionVertices.map(v => v.z);
+            const width = Math.max(...xValues) - Math.min(...xValues);
+            const depth = Math.max(...zValues) - Math.min(...zValues);
+            const area = width * depth;
+            if (area > maxArea) {
+            maxArea = area;
+            maxAreaY = currentY;
+            }
+        }
+        }
+        return maxAreaY;
+    }
+    function replaceTileInstance(instanceIndex, newTypeName) {
+        const newType = tileTypes.get(newTypeName);
+        if (!newType) return;
+        // Get original transformation matrix from terrain instance
+        const matrix = new THREE.Matrix4();
+        terrainInstances.getMatrixAt(instanceIndex, matrix);
+        // Extract position from matrix
+        const position = new THREE.Vector3();
+        const rotation = new THREE.Quaternion();
+        const scale = new THREE.Vector3();
+        matrix.decompose(position, rotation, scale);
+        // Check if there's an existing object of the same type
+        if (objectInstances.has(instanceIndex)) {
+            const existing = objectInstances.get(instanceIndex);
+            if (existing.typeName === newTypeName) {
+                // Rotate existing object's rotation group by 90 degrees
+                const currentRotationY = (existing.rotationY || 0) + Math.PI / 2;
+                const normalizedRotation = currentRotationY % (Math.PI * 2);
+                existing.rotationGroup.rotation.y = (Math.PI / 4) + normalizedRotation;
+                existing.rotationY = normalizedRotation;
+                return; // Exit early as we just rotated the existing object
+            } else {
+                // Remove existing object if it's a different type
+                scene.remove(existing.rotationGroup);
+            }
+        }
+        // Create new mesh from model
+        const newMesh = newType.model.clone();
+        // Create hierarchy of groups for different transformations
+        const rotationGroup = new THREE.Group();    // Handles user-controlled Y rotation
+        const orientationGroup = new THREE.Group(); // Handles initial orientation
+        // Build hierarchy
+        scene.add(rotationGroup);
+        rotationGroup.add(orientationGroup);
+        orientationGroup.add(newMesh);
+        // Position the top-level group at the tile location
+        rotationGroup.position.copy(position);
+        // Enable shadows
+        newMesh.traverse((child) => {
+            if (child.isMesh) {
+                child.castShadow = true;
+                child.receiveShadow = true;
+            }
+            if (child.material) {
+                child.material.shadowSide = THREE.DoubleSide;
+                child.material.needsUpdate = true;
+            }
+        });
+        // Create a bounding box to calculate the mesh's dimensions
+        const bbox = new THREE.Box3().setFromObject(newMesh);
+        const meshCenter = bbox.getCenter(new THREE.Vector3());
+        // Center the mesh on its local origin
+        newMesh.position.sub(meshCenter);
+        // Apply initial orientation using clean, separate rotations
+        orientationGroup.rotation.x = 0.6; // fix mesh generation tiling
+        orientationGroup.rotation.y = 0;
+        orientationGroup.rotation.z = 0;
+        // Find the Y position of widest cross-section and adjust position
+        const baseY = findWidestCrossSection(newMesh);
+        newMesh.position.y -= baseY;
+        newMesh.position.y += 1.2;
+        rotationGroup.rotation.y = Math.PI / 4;
+             // Apply scale to the mesh
+             newMesh.scale.set(5.6, 5.6, 5.6);
+        // Adjust XZ position to ensure centering after rotation
+        bbox.setFromObject(newMesh);
+        const rotatedCenter = bbox.getCenter(new THREE.Vector3());
+        //newMesh.position.x -= 1.0;//rotatedCenter.x;
+        //newMesh.position.z -= 0;//rotatedCenter.z;
+        // Add new object to scene and track it with metadata
+        objectInstances.set(instanceIndex, {
+            rotationGroup: rotationGroup,
+            orientationGroup: orientationGroup,
+            mesh: newMesh,
+            typeName: newTypeName,
+            rotationY: 0 // Start with 0 rotation for the group
+        });
+        const currentCount = objectCountByType.get(newTypeName) || 0;
+        objectCountByType.set(newTypeName, currentCount + 1);
+    }
+        let gradioClient = null;
+        async function initializeGradioClient() {
+            try {
+                gradioClient = await Client.connect("jbilcke-hf/text-to-3d");
+            } catch (error) {
+                console.error("Failed to connect to Gradio:", error);
+            }
+        }
+        async function generateTile(prompt) {
+            if (!gradioClient) {
+                await initializeGradioClient();
+            }
+            if (!gradioClient) {
+                console.error("Gradio client not initialized");
+                return;
+            }
+            if (prompt === lastPromptInputValue) {
+                return;
+            }
+            lastPromptInputValue = prompt;
+            try {
+                isLoading = true;
+                loadingOverlay.style.display = 'flex';
+                const result = await gradioClient.predict("/generate", {
+                    prompt: `isometric videogame asset, ${prompt.trim()}`,
+                });
+                const modelUrl = result.data[0].url;
+                //const modelUrl = "/models/eiffel_tower.glb";
+                const tileTypeName = `custom_${Date.now()}`;
+                await createGLBTileType(modelUrl, tileTypeName);
+                // Instead of random placement, store the current tile type
+                currentTileType = tileTypeName;
+                // Optional: place one instance to show the new type
+                replaceTileInstance(Math.floor(GRID_SIZE * GRID_SIZE / 2), tileTypeName);
+            } catch (error) {
+                console.error("Failed to generate/load terrain:", error);
+            } finally {
+                isLoading = false;
+                loadingOverlay.style.display = 'none';
+            }
+        }
+        // Handle window resize
+        window.addEventListener('resize', () => {
+            const aspect = window.innerWidth / window.innerHeight;
+            const frustumSize = 40;
+            camera.left = -frustumSize * aspect / 2;
+            camera.right = frustumSize * aspect / 2;
+            camera.top = frustumSize / 2;
+            camera.bottom = -frustumSize / 2;
+            camera.updateProjectionMatrix();
+            renderer.setSize(window.innerWidth, window.innerHeight);
+        });
+        // Text input handling
+        const promptInput = document.getElementById('prompt-input');
+        // Event listeners
+        promptInput.addEventListener('keypress', async (e) => {
+            if (e.key === 'Enter') {
+                await generateTile(promptInput.value);
+            }
+        });
+        promptInput.addEventListener('blur', async () => {
+            await generateTile(promptInput.value);
+        });
+        canvasH.addEventListener('click', createHeightMap);
+        // Initialize and start
+        createHeightMap();
+        initializeTerrain();
+        function onMouseDown(event) {
+            if (event.button === 0) { // Left click
+                mouseDownPosition.x = event.clientX;
+                mouseDownPosition.y = event.clientY;
+                isDragging = false;
+            }
+        }
+        // Update raycasting to use current camera
+        function onMouseMove(event) {
+            if (event.buttons === 1) {
+                const deltaX = Math.abs(event.clientX - mouseDownPosition.x);
+                const deltaY = Math.abs(event.clientY - mouseDownPosition.y);
+                if (deltaX > 5 || deltaY > 5) {
+                    isDragging = true;
+                }
+            }
+            mouse.x = (event.clientX / window.innerWidth) * 2 - 1;
+            mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
+            raycaster.setFromCamera(mouse, currentCamera);
+            const intersects = raycaster.intersectObject(terrainInstances);
+            if (intersects.length > 0) {
+                const instanceId = intersects[0].instanceId;
+                if (instanceId !== hoveredTileIndex) {
+                    hoveredTileIndex = instanceId;
+                    const matrix = new THREE.Matrix4();
+                    terrainInstances.getMatrixAt(instanceId, matrix);
+                    const position = new THREE.Vector3();
+                    matrix.decompose(position, new THREE.Quaternion(), new THREE.Vector3());
+                    highlightMesh.position.set(position.x, 0.4, position.z);
+                    highlightMesh.visible = true;
+                }
+            } else {
+                hoveredTileIndex = -1;
+                highlightMesh.visible = false;
+            }
+        }
+        function onMouseUp(event) {
+            if (event.button === 0) { // Left click
+                if (!isDragging && hoveredTileIndex !== -1 && currentTileType) {
+                    replaceTileInstance(hoveredTileIndex, currentTileType);
+                }
+            }
+        }
+        function onClick(event) {
+            if (event.button === 2) { // Right click
+                if (hoveredTileIndex !== -1 && objectInstances.has(hoveredTileIndex)) {
+                    const existing = objectInstances.get(hoveredTileIndex);
+                    const typeName = existing.typeName;
+                    if (typeName) {
+                        const currentCount = objectCountByType.get(typeName) || 0;
+                        if (currentCount > 1) {
+                            objectCountByType.set(typeName, currentCount - 1);
+                        } else {
+                            objectCountByType.delete(typeName);
+                        }
+                    }
+                    scene.remove(existing.rotationGroup);
+                    objectInstances.delete(hoveredTileIndex);
+                }
+            }
+        }
+        // Add camera toggle button handler
+        const cameraToggle = document.getElementById('camera-toggle');
+        cameraToggle.addEventListener('click', () => {
+            isOrthographic = !isOrthographic;
+            currentCamera = isOrthographic ? orthoCamera : perspCamera;
+            // Update controls
+            controls.dispose();
+            controls = new OrbitControls(currentCamera, renderer.domElement);
+            controls.enableDamping = true;
+            // Sync camera positions
+            const oldPos = isOrthographic ? perspCamera.position : orthoCamera.position;
+            currentCamera.position.copy(oldPos);
+            currentCamera.lookAt(controls.target);
+            // Update projection if needed
+            if (!isOrthographic) {
+                perspCamera.aspect = window.innerWidth / window.innerHeight;
+                perspCamera.updateProjectionMatrix();
+            }
+        });
+        // Update window resize handler
+        window.addEventListener('resize', () => {
+            const aspect = window.innerWidth / window.innerHeight;
+            if (isOrthographic) {
+                const frustumSize = 40;
+                orthoCamera.left = -frustumSize * aspect / 2;
+                orthoCamera.right = frustumSize * aspect / 2;
+                orthoCamera.top = frustumSize / 2;
+                orthoCamera.bottom = -frustumSize / 2;
+                orthoCamera.updateProjectionMatrix();
+            } else {
+                perspCamera.aspect = aspect;
+                perspCamera.updateProjectionMatrix();
+            }
+            renderer.setSize(window.innerWidth, window.innerHeight);
+        });
+        renderer.domElement.removeEventListener('click', onClick);
+        renderer.domElement.addEventListener('mousedown', onMouseDown);
+        renderer.domElement.addEventListener('mousemove', onMouseMove);
+        renderer.domElement.addEventListener('mouseup', onMouseUp);
+        renderer.domElement.addEventListener('contextmenu', (event) => {
+            event.preventDefault();
+            onClick(event);
+        });
+        function animate() {
+            requestAnimationFrame(animate);
+            controls.update();
+            renderer.render(scene, currentCamera);
+        }
+        animate();
+    </script>
+</body>
+</html>

libs/gradio-client.js/1.10.0/gradio-client.js ADDED Viewed

	@@ -0,0 +1,8 @@

+/**
+ * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.37.0.
+ * Original file: /npm/@gradio/[email protected]/dist/index.js
+ *
+ * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
+ */
+var t="undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{};function e(){throw new Error("setTimeout has not been defined")}function n(){throw new Error("clearTimeout has not been defined")}var r=e,i=n;function o(t){if(r===setTimeout)return setTimeout(t,0);if((r===e||!r)&&setTimeout)return r=setTimeout,setTimeout(t,0);try{return r(t,0)}catch(e){try{return r.call(null,t,0)}catch(e){return r.call(this,t,0)}}}"function"==typeof t.setTimeout&&(r=setTimeout),"function"==typeof t.clearTimeout&&(i=clearTimeout);var s,a=[],u=!1,c=-1;function h(){u&&s&&(u=!1,s.length?a=s.concat(a):c=-1,a.length&&l())}function l(){if(!u){var t=o(h);u=!0;for(var e=a.length;e;){for(s=a,a=[];++c<e;)s&&s[c].run();c=-1,e=a.length}s=null,u=!1,function(t){if(i===clearTimeout)return clearTimeout(t);if((i===n||!i)&&clearTimeout)return i=clearTimeout,clearTimeout(t);try{return i(t)}catch(e){try{return i.call(null,t)}catch(e){return i.call(this,t)}}}(t)}}function f(t,e){this.fun=t,this.array=e}f.prototype.run=function(){this.fun.apply(null,this.array)};function p(){}var d=p,g=p,w=p,m=p,_=p,y=p,v=p;var b=t.performance||{},E=b.now||b.mozNow||b.msNow||b.oNow||b.webkitNow||function(){return(new Date).getTime()};var S=new Date;var A={nextTick:function(t){var e=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)e[n-1]=arguments[n];a.push(new f(t,e)),1!==a.length||u||o(l)},title:"browser",browser:!0,env:{},argv:[],version:"",versions:{},on:d,addListener:g,once:w,off:m,removeListener:_,removeAllListeners:y,emit:v,binding:function(t){throw new Error("process.binding is not supported")},cwd:function(){return"/"},chdir:function(t){throw new Error("process.chdir is not supported")},umask:function(){return 0},hrtime:function(t){var e=.001*E.call(b),n=Math.floor(e),r=Math.floor(e%1*1e9);return t&&(n-=t[0],(r-=t[1])<0&&(n--,r+=1e9)),[n,r]},platform:"browser",release:{},config:{},uptime:function(){return(new Date-S)/1e3}},T=[],P=[],R="undefined"!=typeof Uint8Array?Uint8Array:Array,x=!1;function k(){x=!0;for(var t="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",e=0;e<64;++e)T[e]=t[e],P[t.charCodeAt(e)]=e;P["-".charCodeAt(0)]=62,P["_".charCodeAt(0)]=63}function $(t,e,n){for(var r,i,o=[],s=e;s<n;s+=3)r=(t[s]<<16)+(t[s+1]<<8)+t[s+2],o.push(T[(i=r)>>18&63]+T[i>>12&63]+T[i>>6&63]+T[63&i]);return o.join("")}function U(t){var e;x||k();for(var n=t.length,r=n%3,i="",o=[],s=16383,a=0,u=n-r;a<u;a+=s)o.push($(t,a,a+s>u?u:a+s));return 1===r?(e=t[n-1],i+=T[e>>2],i+=T[e<<4&63],i+="=="):2===r&&(e=(t[n-2]<<8)+t[n-1],i+=T[e>>10],i+=T[e>>4&63],i+=T[e<<2&63],i+="="),o.push(i),o.join("")}function O(t,e,n,r,i){var o,s,a=8*i-r-1,u=(1<<a)-1,c=u>>1,h=-7,l=n?i-1:0,f=n?-1:1,p=t[e+l];for(l+=f,o=p&(1<<-h)-1,p>>=-h,h+=a;h>0;o=256*o+t[e+l],l+=f,h-=8);for(s=o&(1<<-h)-1,o>>=-h,h+=r;h>0;s=256*s+t[e+l],l+=f,h-=8);if(0===o)o=1-c;else{if(o===u)return s?NaN:1/0*(p?-1:1);s+=Math.pow(2,r),o-=c}return(p?-1:1)*s*Math.pow(2,o-r)}function B(t,e,n,r,i,o){var s,a,u,c=8*o-i-1,h=(1<<c)-1,l=h>>1,f=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=r?0:o-1,d=r?1:-1,g=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(a=isNaN(e)?1:0,s=h):(s=Math.floor(Math.log(e)/Math.LN2),e*(u=Math.pow(2,-s))<1&&(s--,u*=2),(e+=s+l>=1?f/u:f*Math.pow(2,1-l))*u>=2&&(s++,u/=2),s+l>=h?(a=0,s=h):s+l>=1?(a=(e*u-1)*Math.pow(2,i),s+=l):(a=e*Math.pow(2,l-1)*Math.pow(2,i),s=0));i>=8;t[n+p]=255&a,p+=d,a/=256,i-=8);for(s=s<<i|a,c+=i;c>0;t[n+p]=255&s,p+=d,s/=256,c-=8);t[n+p-d]|=128*g}var C={}.toString,D=Array.isArray||function(t){return"[object Array]"==C.call(t)};function I(){return j.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function N(t,e){if(I()<e)throw new RangeError("Invalid typed array length");return j.TYPED_ARRAY_SUPPORT?(t=new Uint8Array(e)).__proto__=j.prototype:(null===t&&(t=new j(e)),t.length=e),t}function j(t,e,n){if(!(j.TYPED_ARRAY_SUPPORT||this instanceof j))return new j(t,e,n);if("number"==typeof t){if("string"==typeof e)throw new Error("If encoding is specified then the first argument must be a string");return q(this,t)}return L(this,t,e,n)}function L(t,e,n,r){if("number"==typeof e)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&e instanceof ArrayBuffer?function(t,e,n,r){if(e.byteLength,n<0||e.byteLength<n)throw new RangeError("'offset' is out of bounds");if(e.byteLength<n+(r||0))throw new RangeError("'length' is out of bounds");e=void 0===n&&void 0===r?new Uint8Array(e):void 0===r?new Uint8Array(e,n):new Uint8Array(e,n,r);j.TYPED_ARRAY_SUPPORT?(t=e).__proto__=j.prototype:t=Y(t,e);return t}(t,e,n,r):"string"==typeof e?function(t,e,n){"string"==typeof n&&""!==n||(n="utf8");if(!j.isEncoding(n))throw new TypeError('"encoding" must be a valid string encoding');var r=0|W(e,n);t=N(t,r);var i=t.write(e,n);i!==r&&(t=t.slice(0,i));return t}(t,e,n):function(t,e){if(F(e)){var n=0|M(e.length);return 0===(t=N(t,n)).length||e.copy(t,0,0,n),t}if(e){if("undefined"!=typeof ArrayBuffer&&e.buffer instanceof ArrayBuffer||"length"in e)return"number"!=typeof e.length||(r=e.length)!=r?N(t,0):Y(t,e);if("Buffer"===e.type&&D(e.data))return Y(t,e.data)}var r;throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}(t,e)}function z(t){if("number"!=typeof t)throw new TypeError('"size" argument must be a number');if(t<0)throw new RangeError('"size" argument must not be negative')}function q(t,e){if(z(e),t=N(t,e<0?0:0|M(e)),!j.TYPED_ARRAY_SUPPORT)for(var n=0;n<e;++n)t[n]=0;return t}function Y(t,e){var n=e.length<0?0:0|M(e.length);t=N(t,n);for(var r=0;r<n;r+=1)t[r]=255&e[r];return t}function M(t){if(t>=I())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+I().toString(16)+" bytes");return 0|t}function F(t){return!(null==t||!t._isBuffer)}function W(t,e){if(F(t))return t.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(t)||t instanceof ArrayBuffer))return t.byteLength;"string"!=typeof t&&(t=""+t);var n=t.length;if(0===n)return 0;for(var r=!1;;)switch(e){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return _t(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return yt(t).length;default:if(r)return _t(t).length;e=(""+e).toLowerCase(),r=!0}}function J(t,e,n){var r=!1;if((void 0===e||e<0)&&(e=0),e>this.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(e>>>=0))return"";for(t||(t="utf8");;)switch(t){case"hex":return at(this,e,n);case"utf8":case"utf-8":return rt(this,e,n);case"ascii":return ot(this,e,n);case"latin1":case"binary":return st(this,e,n);case"base64":return nt(this,e,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return ut(this,e,n);default:if(r)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),r=!0}}function G(t,e,n){var r=t[e];t[e]=t[n],t[n]=r}function H(t,e,n,r,i){if(0===t.length)return-1;if("string"==typeof n?(r=n,n=0):n>2147483647?n=2147483647:n<-2147483648&&(n=-2147483648),n=+n,isNaN(n)&&(n=i?0:t.length-1),n<0&&(n=t.length+n),n>=t.length){if(i)return-1;n=t.length-1}else if(n<0){if(!i)return-1;n=0}if("string"==typeof e&&(e=j.from(e,r)),F(e))return 0===e.length?-1:V(t,e,n,r,i);if("number"==typeof e)return e&=255,j.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(t,e,n):Uint8Array.prototype.lastIndexOf.call(t,e,n):V(t,[e],n,r,i);throw new TypeError("val must be string, number or Buffer")}function V(t,e,n,r,i){var o,s=1,a=t.length,u=e.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(t.length<2||e.length<2)return-1;s=2,a/=2,u/=2,n/=2}function c(t,e){return 1===s?t[e]:t.readUInt16BE(e*s)}if(i){var h=-1;for(o=n;o<a;o++)if(c(t,o)===c(e,-1===h?0:o-h)){if(-1===h&&(h=o),o-h+1===u)return h*s}else-1!==h&&(o-=o-h),h=-1}else for(n+u>a&&(n=a-u),o=n;o>=0;o--){for(var l=!0,f=0;f<u;f++)if(c(t,o+f)!==c(e,f)){l=!1;break}if(l)return o}return-1}function Z(t,e,n,r){n=Number(n)||0;var i=t.length-n;r?(r=Number(r))>i&&(r=i):r=i;var o=e.length;if(o%2!=0)throw new TypeError("Invalid hex string");r>o/2&&(r=o/2);for(var s=0;s<r;++s){var a=parseInt(e.substr(2*s,2),16);if(isNaN(a))return s;t[n+s]=a}return s}function K(t,e,n,r){return vt(_t(e,t.length-n),t,n,r)}function Q(t,e,n,r){return vt(function(t){for(var e=[],n=0;n<t.length;++n)e.push(255&t.charCodeAt(n));return e}(e),t,n,r)}function X(t,e,n,r){return Q(t,e,n,r)}function tt(t,e,n,r){return vt(yt(e),t,n,r)}function et(t,e,n,r){return vt(function(t,e){for(var n,r,i,o=[],s=0;s<t.length&&!((e-=2)<0);++s)r=(n=t.charCodeAt(s))>>8,i=n%256,o.push(i),o.push(r);return o}(e,t.length-n),t,n,r)}function nt(t,e,n){return 0===e&&n===t.length?U(t):U(t.slice(e,n))}function rt(t,e,n){n=Math.min(t.length,n);for(var r=[],i=e;i<n;){var o,s,a,u,c=t[i],h=null,l=c>239?4:c>223?3:c>191?2:1;if(i+l<=n)switch(l){case 1:c<128&&(h=c);break;case 2:128==(192&(o=t[i+1]))&&(u=(31&c)<<6|63&o)>127&&(h=u);break;case 3:o=t[i+1],s=t[i+2],128==(192&o)&&128==(192&s)&&(u=(15&c)<<12|(63&o)<<6|63&s)>2047&&(u<55296||u>57343)&&(h=u);break;case 4:o=t[i+1],s=t[i+2],a=t[i+3],128==(192&o)&&128==(192&s)&&128==(192&a)&&(u=(15&c)<<18|(63&o)<<12|(63&s)<<6|63&a)>65535&&u<1114112&&(h=u)}null===h?(h=65533,l=1):h>65535&&(h-=65536,r.push(h>>>10&1023|55296),h=56320|1023&h),r.push(h),i+=l}return function(t){var e=t.length;if(e<=it)return String.fromCharCode.apply(String,t);var n="",r=0;for(;r<e;)n+=String.fromCharCode.apply(String,t.slice(r,r+=it));return n}(r)}j.TYPED_ARRAY_SUPPORT=void 0===t.TYPED_ARRAY_SUPPORT||t.TYPED_ARRAY_SUPPORT,I(),j.poolSize=8192,j._augment=function(t){return t.__proto__=j.prototype,t},j.from=function(t,e,n){return L(null,t,e,n)},j.TYPED_ARRAY_SUPPORT&&(j.prototype.__proto__=Uint8Array.prototype,j.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&j[Symbol.species]),j.alloc=function(t,e,n){return function(t,e,n,r){return z(e),e<=0?N(t,e):void 0!==n?"string"==typeof r?N(t,e).fill(n,r):N(t,e).fill(n):N(t,e)}(null,t,e,n)},j.allocUnsafe=function(t){return q(null,t)},j.allocUnsafeSlow=function(t){return q(null,t)},j.isBuffer=function(t){return null!=t&&(!!t._isBuffer||bt(t)||function(t){return"function"==typeof t.readFloatLE&&"function"==typeof t.slice&&bt(t.slice(0,0))}(t))},j.compare=function(t,e){if(!F(t)||!F(e))throw new TypeError("Arguments must be Buffers");if(t===e)return 0;for(var n=t.length,r=e.length,i=0,o=Math.min(n,r);i<o;++i)if(t[i]!==e[i]){n=t[i],r=e[i];break}return n<r?-1:r<n?1:0},j.isEncoding=function(t){switch(String(t).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},j.concat=function(t,e){if(!D(t))throw new TypeError('"list" argument must be an Array of Buffers');if(0===t.length)return j.alloc(0);var n;if(void 0===e)for(e=0,n=0;n<t.length;++n)e+=t[n].length;var r=j.allocUnsafe(e),i=0;for(n=0;n<t.length;++n){var o=t[n];if(!F(o))throw new TypeError('"list" argument must be an Array of Buffers');o.copy(r,i),i+=o.length}return r},j.byteLength=W,j.prototype._isBuffer=!0,j.prototype.swap16=function(){var t=this.length;if(t%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var e=0;e<t;e+=2)G(this,e,e+1);return this},j.prototype.swap32=function(){var t=this.length;if(t%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var e=0;e<t;e+=4)G(this,e,e+3),G(this,e+1,e+2);return this},j.prototype.swap64=function(){var t=this.length;if(t%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var e=0;e<t;e+=8)G(this,e,e+7),G(this,e+1,e+6),G(this,e+2,e+5),G(this,e+3,e+4);return this},j.prototype.toString=function(){var t=0|this.length;return 0===t?"":0===arguments.length?rt(this,0,t):J.apply(this,arguments)},j.prototype.equals=function(t){if(!F(t))throw new TypeError("Argument must be a Buffer");return this===t||0===j.compare(this,t)},j.prototype.inspect=function(){var t="";return this.length>0&&(t=this.toString("hex",0,50).match(/.{2}/g).join(" "),this.length>50&&(t+=" ... ")),"<Buffer "+t+">"},j.prototype.compare=function(t,e,n,r,i){if(!F(t))throw new TypeError("Argument must be a Buffer");if(void 0===e&&(e=0),void 0===n&&(n=t?t.length:0),void 0===r&&(r=0),void 0===i&&(i=this.length),e<0||n>t.length||r<0||i>this.length)throw new RangeError("out of range index");if(r>=i&&e>=n)return 0;if(r>=i)return-1;if(e>=n)return 1;if(this===t)return 0;for(var o=(i>>>=0)-(r>>>=0),s=(n>>>=0)-(e>>>=0),a=Math.min(o,s),u=this.slice(r,i),c=t.slice(e,n),h=0;h<a;++h)if(u[h]!==c[h]){o=u[h],s=c[h];break}return o<s?-1:s<o?1:0},j.prototype.includes=function(t,e,n){return-1!==this.indexOf(t,e,n)},j.prototype.indexOf=function(t,e,n){return H(this,t,e,n,!0)},j.prototype.lastIndexOf=function(t,e,n){return H(this,t,e,n,!1)},j.prototype.write=function(t,e,n,r){if(void 0===e)r="utf8",n=this.length,e=0;else if(void 0===n&&"string"==typeof e)r=e,n=this.length,e=0;else{if(!isFinite(e))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");e|=0,isFinite(n)?(n|=0,void 0===r&&(r="utf8")):(r=n,n=void 0)}var i=this.length-e;if((void 0===n||n>i)&&(n=i),t.length>0&&(n<0||e<0)||e>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var o=!1;;)switch(r){case"hex":return Z(this,t,e,n);case"utf8":case"utf-8":return K(this,t,e,n);case"ascii":return Q(this,t,e,n);case"latin1":case"binary":return X(this,t,e,n);case"base64":return tt(this,t,e,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return et(this,t,e,n);default:if(o)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),o=!0}},j.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var it=4096;function ot(t,e,n){var r="";n=Math.min(t.length,n);for(var i=e;i<n;++i)r+=String.fromCharCode(127&t[i]);return r}function st(t,e,n){var r="";n=Math.min(t.length,n);for(var i=e;i<n;++i)r+=String.fromCharCode(t[i]);return r}function at(t,e,n){var r=t.length;(!e||e<0)&&(e=0),(!n||n<0||n>r)&&(n=r);for(var i="",o=e;o<n;++o)i+=mt(t[o]);return i}function ut(t,e,n){for(var r=t.slice(e,n),i="",o=0;o<r.length;o+=2)i+=String.fromCharCode(r[o]+256*r[o+1]);return i}function ct(t,e,n){if(t%1!=0||t<0)throw new RangeError("offset is not uint");if(t+e>n)throw new RangeError("Trying to access beyond buffer length")}function ht(t,e,n,r,i,o){if(!F(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>i||e<o)throw new RangeError('"value" argument is out of bounds');if(n+r>t.length)throw new RangeError("Index out of range")}function lt(t,e,n,r){e<0&&(e=65535+e+1);for(var i=0,o=Math.min(t.length-n,2);i<o;++i)t[n+i]=(e&255<<8*(r?i:1-i))>>>8*(r?i:1-i)}function ft(t,e,n,r){e<0&&(e=4294967295+e+1);for(var i=0,o=Math.min(t.length-n,4);i<o;++i)t[n+i]=e>>>8*(r?i:3-i)&255}function pt(t,e,n,r,i,o){if(n+r>t.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function dt(t,e,n,r,i){return i||pt(t,0,n,4),B(t,e,n,r,23,4),n+4}function gt(t,e,n,r,i){return i||pt(t,0,n,8),B(t,e,n,r,52,8),n+8}j.prototype.slice=function(t,e){var n,r=this.length;if((t=~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),(e=void 0===e?r:~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),e<t&&(e=t),j.TYPED_ARRAY_SUPPORT)(n=this.subarray(t,e)).__proto__=j.prototype;else{var i=e-t;n=new j(i,void 0);for(var o=0;o<i;++o)n[o]=this[o+t]}return n},j.prototype.readUIntLE=function(t,e,n){t|=0,e|=0,n||ct(t,e,this.length);for(var r=this[t],i=1,o=0;++o<e&&(i*=256);)r+=this[t+o]*i;return r},j.prototype.readUIntBE=function(t,e,n){t|=0,e|=0,n||ct(t,e,this.length);for(var r=this[t+--e],i=1;e>0&&(i*=256);)r+=this[t+--e]*i;return r},j.prototype.readUInt8=function(t,e){return e||ct(t,1,this.length),this[t]},j.prototype.readUInt16LE=function(t,e){return e||ct(t,2,this.length),this[t]|this[t+1]<<8},j.prototype.readUInt16BE=function(t,e){return e||ct(t,2,this.length),this[t]<<8|this[t+1]},j.prototype.readUInt32LE=function(t,e){return e||ct(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},j.prototype.readUInt32BE=function(t,e){return e||ct(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},j.prototype.readIntLE=function(t,e,n){t|=0,e|=0,n||ct(t,e,this.length);for(var r=this[t],i=1,o=0;++o<e&&(i*=256);)r+=this[t+o]*i;return r>=(i*=128)&&(r-=Math.pow(2,8*e)),r},j.prototype.readIntBE=function(t,e,n){t|=0,e|=0,n||ct(t,e,this.length);for(var r=e,i=1,o=this[t+--r];r>0&&(i*=256);)o+=this[t+--r]*i;return o>=(i*=128)&&(o-=Math.pow(2,8*e)),o},j.prototype.readInt8=function(t,e){return e||ct(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},j.prototype.readInt16LE=function(t,e){e||ct(t,2,this.length);var n=this[t]|this[t+1]<<8;return 32768&n?4294901760|n:n},j.prototype.readInt16BE=function(t,e){e||ct(t,2,this.length);var n=this[t+1]|this[t]<<8;return 32768&n?4294901760|n:n},j.prototype.readInt32LE=function(t,e){return e||ct(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},j.prototype.readInt32BE=function(t,e){return e||ct(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},j.prototype.readFloatLE=function(t,e){return e||ct(t,4,this.length),O(this,t,!0,23,4)},j.prototype.readFloatBE=function(t,e){return e||ct(t,4,this.length),O(this,t,!1,23,4)},j.prototype.readDoubleLE=function(t,e){return e||ct(t,8,this.length),O(this,t,!0,52,8)},j.prototype.readDoubleBE=function(t,e){return e||ct(t,8,this.length),O(this,t,!1,52,8)},j.prototype.writeUIntLE=function(t,e,n,r){(t=+t,e|=0,n|=0,r)||ht(this,t,e,n,Math.pow(2,8*n)-1,0);var i=1,o=0;for(this[e]=255&t;++o<n&&(i*=256);)this[e+o]=t/i&255;return e+n},j.prototype.writeUIntBE=function(t,e,n,r){(t=+t,e|=0,n|=0,r)||ht(this,t,e,n,Math.pow(2,8*n)-1,0);var i=n-1,o=1;for(this[e+i]=255&t;--i>=0&&(o*=256);)this[e+i]=t/o&255;return e+n},j.prototype.writeUInt8=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,1,255,0),j.TYPED_ARRAY_SUPPORT||(t=Math.floor(t)),this[e]=255&t,e+1},j.prototype.writeUInt16LE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,2,65535,0),j.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8):lt(this,t,e,!0),e+2},j.prototype.writeUInt16BE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,2,65535,0),j.TYPED_ARRAY_SUPPORT?(this[e]=t>>>8,this[e+1]=255&t):lt(this,t,e,!1),e+2},j.prototype.writeUInt32LE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,4,4294967295,0),j.TYPED_ARRAY_SUPPORT?(this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t):ft(this,t,e,!0),e+4},j.prototype.writeUInt32BE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,4,4294967295,0),j.TYPED_ARRAY_SUPPORT?(this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t):ft(this,t,e,!1),e+4},j.prototype.writeIntLE=function(t,e,n,r){if(t=+t,e|=0,!r){var i=Math.pow(2,8*n-1);ht(this,t,e,n,i-1,-i)}var o=0,s=1,a=0;for(this[e]=255&t;++o<n&&(s*=256);)t<0&&0===a&&0!==this[e+o-1]&&(a=1),this[e+o]=(t/s|0)-a&255;return e+n},j.prototype.writeIntBE=function(t,e,n,r){if(t=+t,e|=0,!r){var i=Math.pow(2,8*n-1);ht(this,t,e,n,i-1,-i)}var o=n-1,s=1,a=0;for(this[e+o]=255&t;--o>=0&&(s*=256);)t<0&&0===a&&0!==this[e+o+1]&&(a=1),this[e+o]=(t/s|0)-a&255;return e+n},j.prototype.writeInt8=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,1,127,-128),j.TYPED_ARRAY_SUPPORT||(t=Math.floor(t)),t<0&&(t=255+t+1),this[e]=255&t,e+1},j.prototype.writeInt16LE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,2,32767,-32768),j.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8):lt(this,t,e,!0),e+2},j.prototype.writeInt16BE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,2,32767,-32768),j.TYPED_ARRAY_SUPPORT?(this[e]=t>>>8,this[e+1]=255&t):lt(this,t,e,!1),e+2},j.prototype.writeInt32LE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,4,2147483647,-2147483648),j.TYPED_ARRAY_SUPPORT?(this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24):ft(this,t,e,!0),e+4},j.prototype.writeInt32BE=function(t,e,n){return t=+t,e|=0,n||ht(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),j.TYPED_ARRAY_SUPPORT?(this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t):ft(this,t,e,!1),e+4},j.prototype.writeFloatLE=function(t,e,n){return dt(this,t,e,!0,n)},j.prototype.writeFloatBE=function(t,e,n){return dt(this,t,e,!1,n)},j.prototype.writeDoubleLE=function(t,e,n){return gt(this,t,e,!0,n)},j.prototype.writeDoubleBE=function(t,e,n){return gt(this,t,e,!1,n)},j.prototype.copy=function(t,e,n,r){if(n||(n=0),r||0===r||(r=this.length),e>=t.length&&(e=t.length),e||(e=0),r>0&&r<n&&(r=n),r===n)return 0;if(0===t.length||0===this.length)return 0;if(e<0)throw new RangeError("targetStart out of bounds");if(n<0||n>=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),t.length-e<r-n&&(r=t.length-e+n);var i,o=r-n;if(this===t&&n<e&&e<r)for(i=o-1;i>=0;--i)t[i+e]=this[i+n];else if(o<1e3||!j.TYPED_ARRAY_SUPPORT)for(i=0;i<o;++i)t[i+e]=this[i+n];else Uint8Array.prototype.set.call(t,this.subarray(n,n+o),e);return o},j.prototype.fill=function(t,e,n,r){if("string"==typeof t){if("string"==typeof e?(r=e,e=0,n=this.length):"string"==typeof n&&(r=n,n=this.length),1===t.length){var i=t.charCodeAt(0);i<256&&(t=i)}if(void 0!==r&&"string"!=typeof r)throw new TypeError("encoding must be a string");if("string"==typeof r&&!j.isEncoding(r))throw new TypeError("Unknown encoding: "+r)}else"number"==typeof t&&(t&=255);if(e<0||this.length<e||this.length<n)throw new RangeError("Out of range index");if(n<=e)return this;var o;if(e>>>=0,n=void 0===n?this.length:n>>>0,t||(t=0),"number"==typeof t)for(o=e;o<n;++o)this[o]=t;else{var s=F(t)?t:_t(new j(t,r).toString()),a=s.length;for(o=0;o<n-e;++o)this[o+e]=s[o%a]}return this};var wt=/[^+\/0-9A-Za-z-_]/g;function mt(t){return t<16?"0"+t.toString(16):t.toString(16)}function _t(t,e){var n;e=e||1/0;for(var r=t.length,i=null,o=[],s=0;s<r;++s){if((n=t.charCodeAt(s))>55295&&n<57344){if(!i){if(n>56319){(e-=3)>-1&&o.push(239,191,189);continue}if(s+1===r){(e-=3)>-1&&o.push(239,191,189);continue}i=n;continue}if(n<56320){(e-=3)>-1&&o.push(239,191,189),i=n;continue}n=65536+(i-55296<<10|n-56320)}else i&&(e-=3)>-1&&o.push(239,191,189);if(i=null,n<128){if((e-=1)<0)break;o.push(n)}else if(n<2048){if((e-=2)<0)break;o.push(n>>6|192,63&n|128)}else if(n<65536){if((e-=3)<0)break;o.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((e-=4)<0)break;o.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return o}function yt(t){return function(t){var e,n,r,i,o,s;x||k();var a=t.length;if(a%4>0)throw new Error("Invalid string. Length must be a multiple of 4");o="="===t[a-2]?2:"="===t[a-1]?1:0,s=new R(3*a/4-o),r=o>0?a-4:a;var u=0;for(e=0,n=0;e<r;e+=4,n+=3)i=P[t.charCodeAt(e)]<<18|P[t.charCodeAt(e+1)]<<12|P[t.charCodeAt(e+2)]<<6|P[t.charCodeAt(e+3)],s[u++]=i>>16&255,s[u++]=i>>8&255,s[u++]=255&i;return 2===o?(i=P[t.charCodeAt(e)]<<2|P[t.charCodeAt(e+1)]>>4,s[u++]=255&i):1===o&&(i=P[t.charCodeAt(e)]<<10|P[t.charCodeAt(e+1)]<<4|P[t.charCodeAt(e+2)]>>2,s[u++]=i>>8&255,s[u++]=255&i),s}(function(t){if((t=function(t){return t.trim?t.trim():t.replace(/^\s+|\s+$/g,"")}(t).replace(wt,"")).length<2)return"";for(;t.length%4!=0;)t+="=";return t}(t))}function vt(t,e,n,r){for(var i=0;i<r&&!(i+n>=e.length||i>=t.length);++i)e[i+n]=t[i];return i}function bt(t){return!!t.constructor&&"function"==typeof t.constructor.isBuffer&&t.constructor.isBuffer(t)}var Et,St=Object.defineProperty,At=(t,e,n)=>(((t,e,n)=>{e in t?St(t,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):t[e]=n})(t,"symbol"!=typeof e?e+"":e,n),n),Tt=(t,e,n)=>{if(!e.has(t))throw TypeError("Cannot "+n)},Pt=(t,e,n)=>(Tt(t,e,"read from private field"),n?n.call(t):e.get(t)),Rt=new Intl.Collator(0,{numeric:1}).compare;function xt(t,e,n){return t=t.split("."),e=e.split("."),Rt(t[0],e[0])||Rt(t[1],e[1])||(e[2]=e.slice(2).join("."),(n=/[.-]/.test(t[2]=t.slice(2).join(".")))==/[.-]/.test(e[2])?Rt(t[2],e[2]):n?-1:1)}const kt="queue/data",$t="upload",Ut="This application is currently busy. Please try again. ",Ot="Connection errored out. ",Bt="Could not resolve app config. ",Ct="Space metadata could not be loaded. ",Dt="Invalid credentials. Could not login. ",It="Root URL not found in client config";function Nt(t,e,n){return e.startsWith("http://")||e.startsWith("https://")?n?t:e:t+e}async function jt(t,e,n){try{const r=await fetch(`https://huggingface.co/api/spaces/${t}/jwt`,{headers:{Authorization:`Bearer ${e}`,...n?{Cookie:n}:{}}});return(await r.json()).token||!1}catch(t){return!1}}async function Lt(t){var e;const n=this.options.hf_token?{Authorization:`Bearer ${this.options.hf_token}`}:{};if(n["Content-Type"]="application/json","undefined"!=typeof window&&window.gradio_config&&"http://localhost:9876"!==location.origin&&!window.gradio_config.dev_mode){const e=window.gradio_config.root,n=window.gradio_config;let r=Nt(t,n.root,!1);return n.root=r,{...n,path:e}}if(t){const r=Gt(t,"config"),i=await this.fetch(r,{headers:n,credentials:"include"});if(401===(null==i?void 0:i.status)&&!this.options.auth)throw new Error("Login credentials are required to access this space.");if(401===(null==i?void 0:i.status)&&this.options.auth)throw new Error(Dt);if(200===(null==i?void 0:i.status)){let n=await i.json();return n.path=n.path??"",n.root=t,null==(e=n.dependencies)||e.forEach(((t,e)=>{void 0===t.id&&(t.id=e)})),n}if(401===(null==i?void 0:i.status))throw new Error("Not authorized to access this space. ");throw new Error(Bt)}throw new Error(Bt)}async function zt(){const{http_protocol:t,host:e}=await Jt(this.app_reference,this.options.hf_token);try{if(this.options.auth){const n=await qt(t,e,this.options.auth,this.fetch,this.options.hf_token);n&&this.set_cookies(n)}}catch(t){throw Error(t.message)}}async function qt(t,e,n,r,i){const o=new FormData;o.append("username",null==n?void 0:n[0]),o.append("password",null==n?void 0:n[1]);let s={};i&&(s.Authorization=`Bearer ${i}`);const a=await r(`${t}//${e}/login`,{headers:s,method:"POST",body:o,credentials:"include"});if(200===a.status)return a.headers.get("set-cookie");throw 401===a.status?new Error(Dt):new Error(Ct)}function Yt(t){if(t.startsWith("http")){const{protocol:e,host:n,pathname:r}=new URL(t);return{ws_protocol:"https:"===e?"wss":"ws",http_protocol:e,host:n+("/"!==r?r:"")}}return t.startsWith("file:")?{ws_protocol:"ws",http_protocol:"http:",host:"lite.local"}:{ws_protocol:"wss",http_protocol:"https:",host:new URL(t).host}}const Mt=t=>{let e=[];return t.split(/,(?=\s*[^\s=;]+=[^\s=;]+)/).forEach((t=>{const[n,r]=t.split(";")[0].split("=");n&&r&&e.push(`${n.trim()}=${r.trim()}`)})),e},Ft=/^[a-zA-Z0-9_\-\.]+\/[a-zA-Z0-9_\-\.]+$/,Wt=/.*hf\.space\/{0,1}.*$/;async function Jt(t,e){const n={};e&&(n.Authorization=`Bearer ${e}`);const r=t.trim().replace(/\/$/,"");if(Ft.test(r))try{const e=await fetch(`https://huggingface.co/api/spaces/${r}/host`,{headers:n});return{space_id:t,...Yt((await e.json()).host)}}catch(t){throw new Error(Ct)}if(Wt.test(r)){const{ws_protocol:t,http_protocol:e,host:n}=Yt(r);return{space_id:n.split("/")[0].replace(".hf.space",""),ws_protocol:t,http_protocol:e,host:n}}return{space_id:!1,...Yt(r)}}const Gt=(...t)=>{try{return t.reduce(((t,e)=>(t=t.replace(/\/+$/,""),e=e.replace(/^\/+/,""),new URL(e,t+"/").toString())))}catch(t){throw new Error("Invalid URL. A full URL path is required.")}};function Ht(t,e,n,r){if("Api"===e)return t.type;switch(null==t?void 0:t.type){case"string":return"string";case"boolean":return"boolean";case"number":return"number"}return"JSONSerializable"===n||"StringSerializable"===n?"any":"ListStringSerializable"===n?"string[]":"Image"===e?"parameter"===r?"Blob | File | Buffer":"string":"FileSerializable"===n?"array"===(null==t?void 0:t.type)?"parameter"===r?"(Blob | File | Buffer)[]":"{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}[]":"parameter"===r?"Blob | File | Buffer":"{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}":"GallerySerializable"===n?"parameter"===r?"[(Blob | File | Buffer), (string | null)][]":"[{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}, (string | null))][]":void 0}function Vt(t,e){return"GallerySerializable"===e?"array of [file, label] tuples":"ListStringSerializable"===e?"array of strings":"FileSerializable"===e?"array of files or single file":null==t?void 0:t.description}function Zt(t,e){const n=!0;switch(t.msg){case"send_data":return{type:"data"};case"send_hash":return{type:"hash"};case"queue_full":return{type:"update",status:{queue:n,message:Ut,stage:"error",code:t.code,success:t.success}};case"heartbeat":return{type:"heartbeat"};case"unexpected_error":return{type:"unexpected_error",status:{queue:n,message:t.message,stage:"error",success:!1}};case"estimation":return{type:"update",status:{queue:n,stage:e||"pending",code:t.code,size:t.queue_size,position:t.rank,eta:t.rank_eta,success:t.success}};case"progress":return{type:"update",status:{queue:n,stage:"pending",code:t.code,progress_data:t.progress_data,success:t.success}};case"log":return{type:"log",data:t};case"process_generating":return{type:"generating",status:{queue:n,message:t.success?null:t.output.error,stage:t.success?"generating":"error",code:t.code,progress_data:t.progress_data,eta:t.average_duration,changed_state_ids:t.success?t.output.changed_state_ids:void 0},data:t.success?t.output:null};case"process_streaming":return{type:"streaming",status:{queue:n,message:t.output.error,stage:"streaming",time_limit:t.time_limit,code:t.code,progress_data:t.progress_data,eta:t.eta},data:t.output};case"process_completed":return"error"in t.output?{type:"update",status:{queue:n,title:t.output.title,message:t.output.error,visible:t.output.visible,duration:t.output.duration,stage:"error",code:t.code,success:t.success}}:{type:"complete",status:{queue:n,message:t.success?void 0:t.output.error,stage:t.success?"complete":"error",code:t.code,progress_data:t.progress_data,changed_state_ids:t.success?t.output.changed_state_ids:void 0},data:t.success?t.output:null};case"process_starts":return{type:"update",status:{queue:n,stage:"pending",code:t.code,size:t.rank,position:0,success:t.success,eta:t.eta},original_msg:"process_starts"}}return{type:"none",status:{stage:"error",queue:n}}}async function Kt(){if(this.api_info)return this.api_info;const{hf_token:t}=this.options,{config:e}=this,n={"Content-Type":"application/json"};if(t&&(n.Authorization=`Bearer ${t}`),e)try{let t,r;if("undefined"!=typeof window&&window.gradio_api_info)r=window.gradio_api_info;else{if(xt((null==e?void 0:e.version)||"2.0.0","3.30")<0)t=await this.fetch("https://gradio-space-api-fetcher-v2.hf.space/api",{method:"POST",body:JSON.stringify({serialize:!1,config:JSON.stringify(e)}),headers:n,credentials:"include"});else{const r=Gt(e.root,this.api_prefix,"info");t=await this.fetch(r,{headers:n,credentials:"include"})}if(!t.ok)throw new Error(Ot);r=await t.json()}return"api"in r&&(r=r.api),r.named_endpoints["/predict"]&&!r.unnamed_endpoints[0]&&(r.unnamed_endpoints[0]=r.named_endpoints["/predict"]),function(t,e,n){const r={named_endpoints:{},unnamed_endpoints:{}};return Object.keys(t).forEach((i=>{"named_endpoints"!==i&&"unnamed_endpoints"!==i||(r[i]={},Object.entries(t[i]).forEach((([t,{parameters:o,returns:s}])=>{var a,u,c,h;const l=(null==(a=e.dependencies.find((e=>e.api_name===t||e.api_name===t.replace("/",""))))?void 0:a.id)||n[t.replace("/","")]||-1,f=-1!==l?null==(u=e.dependencies.find((t=>t.id==l)))?void 0:u.types:{generator:!1,cancel:!1};if(-1!==l&&(null==(h=null==(c=e.dependencies.find((t=>t.id==l)))?void 0:c.inputs)?void 0:h.length)!==o.length){const t=e.dependencies.find((t=>t.id==l)).inputs.map((t=>{var n;return null==(n=e.components.find((e=>e.id===t)))?void 0:n.type}));try{t.forEach(((t,e)=>{if("state"===t){const t={component:"state",example:null,parameter_default:null,parameter_has_default:!0,parameter_name:null,hidden:!0};o.splice(e,0,t)}}))}catch(t){console.error(t)}}const p=(t,e,n,r)=>({...t,description:Vt(null==t?void 0:t.type,n),type:Ht(null==t?void 0:t.type,e,n,r)||""});r[i][t]={parameters:o.map((t=>p(t,null==t?void 0:t.component,null==t?void 0:t.serializer,"parameter"))),returns:s.map((t=>p(t,null==t?void 0:t.component,null==t?void 0:t.serializer,"return"))),type:f}})))})),r}(r,e,this.api_map)}catch(t){t.message}}async function Qt(t,e,n){var r;const i={};(null==(r=null==this?void 0:this.options)?void 0:r.hf_token)&&(i.Authorization=`Bearer ${this.options.hf_token}`);const o=[];let s;for(let r=0;r<e.length;r+=1e3){const a=e.slice(r,r+1e3),u=new FormData;a.forEach((t=>{u.append("files",t)}));try{const e=n?`${t}${this.api_prefix}/${$t}?upload_id=${n}`:`${t}${this.api_prefix}/${$t}`;s=await this.fetch(e,{method:"POST",body:u,headers:i,credentials:"include"})}catch(t){throw new Error(Ot+t.message)}if(!s.ok){const t=await s.text();return{error:`HTTP ${s.status}: ${t}`}}const c=await s.json();c&&o.push(...c)}return{files:o}}async function Xt(t,e,n,r){let i=(Array.isArray(t)?t:[t]).map((t=>t.blob));const o=i.filter((t=>t.size>(r??1/0)));if(o.length)throw new Error(`File size exceeds the maximum allowed size of ${r} bytes: ${o.map((t=>t.name)).join(", ")}`);return await Promise.all(await this.upload_files(e,i,n).then((async n=>{if(n.error)throw new Error(n.error);return n.files?n.files.map(((n,r)=>new ee({...t[r],path:n,url:`${e}${this.api_prefix}/file=${n}`}))):[]})))}async function te(t,e){return t.map((t=>new ee({path:t.name,orig_name:t.name,blob:t,size:t.size,mime_type:t.type,is_stream:e})))}class ee{constructor({path:t,url:e,orig_name:n,size:r,blob:i,is_stream:o,mime_type:s,alt_text:a,b64:u}){At(this,"path"),At(this,"url"),At(this,"orig_name"),At(this,"size"),At(this,"blob"),At(this,"is_stream"),At(this,"mime_type"),At(this,"alt_text"),At(this,"b64"),At(this,"meta",{_type:"gradio.FileData"}),this.path=t,this.url=e,this.orig_name=n,this.size=r,this.blob=e?void 0:i,this.is_stream=o,this.mime_type=s,this.alt_text=a,this.b64=u}}class ne{constructor(t,e){At(this,"type"),At(this,"command"),At(this,"meta"),At(this,"fileData"),this.type="command",this.command=t,this.meta=e}}const re=void 0!==A&&A.versions&&A.versions.node;function ie(t,e,n){for(;n.length>1;){const e=n.shift();if("string"!=typeof e&&"number"!=typeof e)throw new Error("Invalid key type");t=t[e]}const r=n.shift();if("string"!=typeof r&&"number"!=typeof r)throw new Error("Invalid key type");t[r]=e}async function oe(t,e=void 0,n=[],r=!1,i=void 0){if(Array.isArray(t)){let o=[];return await Promise.all(t.map((async(s,a)=>{var u;let c=n.slice();c.push(String(a));const h=await oe(t[a],r?(null==(u=null==i?void 0:i.parameters[a])?void 0:u.component)||void 0:e,c,!1,i);o=o.concat(h)}))),o}if(globalThis.Buffer&&t instanceof globalThis.Buffer||t instanceof Blob)return[{path:n,blob:new Blob([t]),type:e}];if("object"==typeof t&&null!==t){let e=[];for(const r of Object.keys(t)){const o=[...n,r],s=t[r];e=e.concat(await oe(s,void 0,o,!1,i))}return e}return[]}function se(t){if("string"==typeof t){if(t.startsWith("http://")||t.startsWith("https://"))return{path:t,url:t,orig_name:t.split("/").pop()??"unknown",meta:{_type:"gradio.FileData"}};if(re)return new ne("upload_file",{path:t,name:t,orig_path:t})}else{if("undefined"!=typeof File&&t instanceof File)return new Blob([t]);if(t instanceof j)return new Blob([t]);if(t instanceof Blob)return t}throw new Error("Invalid input: must be a URL, File, Blob, or Buffer object.")}function ae(t,e,n,r,i=!1){if("input"===r&&!i)throw new Error("Invalid code path. Cannot skip state inputs for input.");if("output"===r&&i)return t;let o=[],s=0;const a="input"===r?e.inputs:e.outputs;for(let e=0;e<a.length;e++){const r=a[e],u=n.find((t=>t.id===r));if("state"!==(null==u?void 0:u.type)){const e=t[s];o.push(e),s++}else{if(!i){s++;continue}if(t.length===a.length){const e=t[s];o.push(e),s++}else o.push(null)}}return o}async function ue(t,e,n){const r=this;await async function(t,e){var n,r;if(!(null==(n=t.config)?void 0:n.root)&&!(null==(r=t.config)?void 0:r.root_url))throw new Error(It);await ce(t,e)}(r,e);const i=await oe(e,void 0,[],!0,n);return(await Promise.all(i.map((async({path:e,blob:n,type:i})=>{if(!n)return{path:e,type:i};const o=await r.upload_files(t,[n]);return{path:e,file_url:o.files&&o.files[0],type:i,name:"undefined"!=typeof File&&n instanceof File?null==n?void 0:n.name:void 0}})))).forEach((({path:t,file_url:n,type:r,name:i})=>{if("Gallery"===r)ie(e,n,t);else if(n){const r=new ee({path:n,orig_name:i});ie(e,r,t)}})),e}async function ce(t,e,n=[]){for(const r in e)e[r]instanceof ne?await he(t,e,r):"object"==typeof e[r]&&null!==e[r]&&await ce(t,e[r],[...n,r])}async function he(t,e,n){var r,i;let o=e[n];const s=(null==(r=t.config)?void 0:r.root)||(null==(i=t.config)?void 0:i.root_url);if(!s)throw new Error(It);try{let r,i;if(void 0===A||!A.versions||!A.versions.node)throw new Error("File system access is only available in Node.js environments");{const t=await import("/npm/fs/promises/+esm");i=(await import("/npm/path/+esm")).resolve(A.cwd(),o.meta.path),r=await t.readFile(i)}const a=new Blob([r],{type:"application/octet-stream"}),u=await t.upload_files(s,[a]),c=u.files&&u.files[0];if(c){const t=new ee({path:c,orig_name:o.meta.name||""});e[n]=t}}catch(t){console.error("Error uploading file",t)}}async function le(t,e,n){const r={"Content-Type":"application/json"};this.options.hf_token&&(r.Authorization=`Bearer ${this.options.hf_token}`);try{var i=await this.fetch(t,{method:"POST",body:JSON.stringify(e),headers:{...r,...n},credentials:"include"})}catch(t){return[{error:Ot},500]}let o,s;try{o=await i.json(),s=i.status}catch(t){o={error:`Could not parse server response: ${t}`},s=500}return[o,s]}async function fe(t,e={}){let n=!1,r=!1;if(!this.config)throw new Error("Could not resolve app config");if("number"==typeof t)this.config.dependencies.find((e=>e.id==t));else{const e=t.replace(/^\//,"");this.config.dependencies.find((t=>t.id==this.api_map[e]))}return new Promise((async(i,o)=>{const s=this.submit(t,e,null,null,!0);let a;for await(const t of s)"data"===t.type&&(r&&i(a),n=!0,a=t),"status"===t.type&&("error"===t.stage&&o(t),"complete"===t.stage&&(r=!0,n&&i(a)))}))}async function pe(t,e,n){let r,i,o="subdomain"===e?`https://huggingface.co/api/spaces/by-subdomain/${t}`:`https://huggingface.co/api/spaces/${t}`;try{if(r=await fetch(o),i=r.status,200!==i)throw new Error;r=await r.json()}catch(t){return void n({status:"error",load_status:"error",message:"Could not get space status. ",detail:"NOT_FOUND"})}if(!r||200!==i)return;const{runtime:{stage:s},id:a}=r;switch(s){case"STOPPED":case"SLEEPING":n({status:"sleeping",load_status:"pending",message:"Space is asleep. Waking it up...",detail:s}),setTimeout((()=>{pe(t,e,n)}),1e3);break;case"PAUSED":n({status:"paused",load_status:"error",message:"This space has been paused by the author. If you would like to try this demo, consider duplicating the space.",detail:s,discussions_enabled:await we(a)});break;case"RUNNING":case"RUNNING_BUILDING":n({status:"running",load_status:"complete",message:"Space is running.",detail:s});break;case"BUILDING":n({status:"building",load_status:"pending",message:"Space is building...",detail:s}),setTimeout((()=>{pe(t,e,n)}),1e3);break;case"APP_STARTING":n({status:"starting",load_status:"pending",message:"Space is starting...",detail:s}),setTimeout((()=>{pe(t,e,n)}),1e3);break;default:n({status:"space_error",load_status:"error",message:"This space is experiencing an issue.",detail:s,discussions_enabled:await we(a)})}}const de=async(t,e)=>{let n=0;return new Promise((r=>{pe(t,Ft.test(t)?"space_name":"subdomain",(i=>{e(i),"running"===i.status||"error"===i.status||"paused"===i.status||"space_error"===i.status?r():"sleeping"!==i.status&&"building"!==i.status||(n<12?(n++,setTimeout((()=>{de(t,e).then(r)}),5e3)):r())}))}))},ge=/^(?=[^]*\b[dD]iscussions{0,1}\b)(?=[^]*\b[dD]isabled\b)[^]*$/;async function we(t){try{const e=await fetch(`https://huggingface.co/api/spaces/${t}/discussions`,{method:"HEAD"}),n=e.headers.get("x-error-message");return!(!e.ok||n&&ge.test(n))}catch(t){return!1}}const me=["cpu-basic","cpu-upgrade","cpu-xl","t4-small","t4-medium","a10g-small","a10g-large","a10g-largex2","a10g-largex4","a100-large","zero-a10g","h100","h100x8"];async function _e(t,e){const{hf_token:n,private:r,hardware:i,timeout:o,auth:s}=e;if(i&&!me.includes(i))throw new Error(`Invalid hardware type provided. Valid types are: ${me.map((t=>`"${t}"`)).join(",")}.`);const{http_protocol:a,host:u}=await Jt(t,n);let c=null;if(s){const t=await qt(a,u,s,fetch);t&&(c=Mt(t))}const h={Authorization:`Bearer ${n}`,"Content-Type":"application/json",...c?{Cookie:c.join("; ")}:{}},l=(await(await fetch("https://huggingface.co/api/whoami-v2",{headers:h})).json()).name,f=t.split("/")[1],p={repository:`${l}/${f}`};let d;r&&(p.private=!0);try{i||(d=await async function(t,e){const n={};e&&(n.Authorization=`Bearer ${e}`);try{const e=await fetch(`https://huggingface.co/api/spaces/${t}/runtime`,{headers:n});if(200!==e.status)throw new Error("Space hardware could not be obtained.");const{hardware:r}=await e.json();return r.current}catch(t){throw new Error(t.message)}}(t,n))}catch(t){throw Error(Ct+t.message)}const g=i||d||"cpu-basic";p.hardware=g;try{const r=await fetch(`https://huggingface.co/api/spaces/${t}/duplicate`,{method:"POST",headers:h,body:JSON.stringify(p)});if(409===r.status)try{return await xe.connect(`${l}/${f}`,e)}catch(t){throw console.error("Failed to connect Client instance:",t),t}else if(200!==r.status)throw new Error(r.statusText);const i=await r.json();return await async function(t,e,n){const r={};n&&(r.Authorization=`Bearer ${n}`);const i={seconds:e};try{const e=await fetch(`https://huggingface.co/api/spaces/${t}/sleeptime`,{method:"POST",headers:{"Content-Type":"application/json",...r},body:JSON.stringify(i)});if(200!==e.status)throw new Error("Could not set sleep timeout on duplicated Space. Please visit *ADD HF LINK TO SETTINGS* to set a timeout manually to reduce billing charges.");return await e.json()}catch(t){throw new Error(t.message)}}(`${l}/${f}`,o||300,n),await xe.connect(function(t){const e=/https:\/\/huggingface.co\/spaces\/([^/]+\/[^/]+)/,n=t.match(e);if(n)return n[1]}(i.url),e)}catch(t){throw new Error(t)}}class ye extends TransformStream{constructor(t={allowCR:!1}){super({transform:(e,n)=>{for(e=Pt(this,Et)+e;;){const r=e.indexOf("\n"),i=t.allowCR?e.indexOf("\r"):-1;if(-1!==i&&i!==e.length-1&&(-1===r||r-1>i)){n.enqueue(e.slice(0,i)),e=e.slice(i+1);continue}if(-1===r)break;const o="\r"===e[r-1]?r-1:r;n.enqueue(e.slice(0,o)),e=e.slice(r+1)}var r,i,o,s;o=e,Tt(r=this,i=Et,"write to private field"),s?s.call(r,o):i.set(r,o)},flush:e=>{if(""===Pt(this,Et))return;const n=t.allowCR&&Pt(this,Et).endsWith("\r")?Pt(this,Et).slice(0,-1):Pt(this,Et);e.enqueue(n)}}),((t,e,n)=>{if(e.has(t))throw TypeError("Cannot add the same private member more than once");e instanceof WeakSet?e.add(t):e.set(t,n)})(this,Et,"")}}function ve(t){let e=/[:]\s*/.exec(t),n=e&&e.index;if(n)return[t.substring(0,n),t.substring(n+e[0].length)]}function be(t,e,n){t.get(e)||t.set(e,n)}async function*Ee(t,e){if(!t.body)return;let n,r,i=function(t){let e=new TextDecoderStream,n=new ye({allowCR:!0});return t.pipeThrough(e).pipeThrough(n)}(t.body).getReader();for(;;){if(e&&e.aborted)return i.cancel();if(n=await i.read(),n.done)return;if(!n.value){r&&(yield r),r=void 0;continue}let[t,o]=ve(n.value)||[];t&&("data"===t?(r||(r={}),r[t]=r[t]?r[t]+"\n"+o:o):"event"===t?(r||(r={}),r[t]=o):"id"===t?(r||(r={}),r[t]=+o||o):"retry"===t&&(r||(r={}),r[t]=+o||void 0))}}async function Se(){let{event_callbacks:t,unclosed_events:e,pending_stream_messages:n,stream_status:r,config:i,jwt:o}=this;const s=this;if(!i)throw new Error("Could not resolve app config");r.open=!0;let a=null,u=new URLSearchParams({session_hash:this.session_hash}).toString(),c=new URL(`${i.root}${this.api_prefix}/${kt}?${u}`);o&&c.searchParams.set("__sign",o),a=this.stream(c),a?(a.onmessage=async function(o){let a=JSON.parse(o.data);if("close_stream"===a.msg)return void Ae(r,s.abort_controller);const u=a.event_id;if(u)if(t[u]&&i){"process_completed"===a.msg&&["sse","sse_v1","sse_v2","sse_v2.1","sse_v3"].includes(i.protocol)&&e.delete(u);let n=t[u];"undefined"!=typeof window&&"undefined"!=typeof document?setTimeout(n,0,a):n(a)}else n[u]||(n[u]=[]),n[u].push(a);else await Promise.all(Object.keys(t).map((e=>t[e](a))))},a.onerror=async function(){await Promise.all(Object.keys(t).map((e=>t[e]({msg:"unexpected_error",message:Ot}))))}):console.warn("Cannot connect to SSE endpoint: "+c.toString())}function Ae(t,e){t&&(t.open=!1,null==e||e.abort())}function Te(t,e,n){!t[e]?(t[e]=[],n.data.forEach(((n,r)=>{t[e][r]=n}))):n.data.forEach(((r,i)=>{let o=(s=t[e][i],r.forEach((([t,e,n])=>{s=function(t,e,n,r){if(0===e.length){if("replace"===n)return r;if("append"===n)return t+r;throw new Error(`Unsupported action: ${n}`)}let i=t;for(let t=0;t<e.length-1;t++)i=i[e[t]];const o=e[e.length-1];switch(n){case"replace":i[o]=r;break;case"append":i[o]+=r;break;case"add":Array.isArray(i)?i.splice(Number(o),0,r):i[o]=r;break;case"delete":Array.isArray(i)?i.splice(Number(o),1):delete i[o];break;default:throw new Error(`Unknown action: ${n}`)}return t}(s,e,t,n)})),s);var s;t[e][i]=o,n.data[i]=o}))}function Pe(t,e={}){const n={close:()=>{console.warn("Method not implemented.")},onerror:null,onmessage:null,onopen:null,readyState:0,url:t.toString(),withCredentials:!1,CONNECTING:0,OPEN:1,CLOSED:2,addEventListener:()=>{throw new Error("Method not implemented.")},dispatchEvent:()=>{throw new Error("Method not implemented.")},removeEventListener:()=>{throw new Error("Method not implemented.")}};return async function(t,e){let n=new Request(t,e);be(n.headers,"Accept","text/event-stream"),be(n.headers,"Content-Type","application/json");let r=await fetch(n);if(!r.ok)throw r;return Ee(r,n.signal)}(t,e).then((async t=>{n.readyState=n.OPEN;try{for await(const e of t)n.onmessage&&n.onmessage(e);n.readyState=n.CLOSED}catch(t){n.onerror&&n.onerror(t),n.readyState=n.CLOSED}})).catch((t=>{console.error(t),n.onerror&&n.onerror(t),n.readyState=n.CLOSED})),n}function Re(t,e={},n,r,i){var o;try{let s=function(t){(i||M[t.type])&&h(t)},a=function(){for(G=!0;V.length>0;)V.shift()({value:void 0,done:!0})},u=function(t){G||(V.length>0?V.shift()(t):H.push(t))},c=function(t){u(function(t){return{then:(e,n)=>n(t)}}(t)),a()},h=function(t){u({value:t,done:!1})},l=function(){return H.length>0?Promise.resolve(H.shift()):G?Promise.resolve({value:void 0,done:!0}):new Promise((t=>V.push(t)))};const{hf_token:f}=this.options,{fetch:p,app_reference:d,config:g,session_hash:w,api_info:m,api_map:_,stream_status:y,pending_stream_messages:v,pending_diff_streams:b,event_callbacks:E,unclosed_events:S,post_data:A,options:T,api_prefix:P}=this,R=this;if(!m)throw new Error("No API found");if(!g)throw new Error("Could not resolve app config");let x,k,{fn_index:$,endpoint_info:U,dependency:O}=function(t,e,n,r){let i,o,s;if("number"==typeof e)i=e,o=t.unnamed_endpoints[i],s=r.dependencies.find((t=>t.id==e));else{const a=e.replace(/^\//,"");i=n[a],o=t.named_endpoints[e.trim()],s=r.dependencies.find((t=>t.id==n[a]))}if("number"!=typeof i)throw new Error("There is no endpoint matching that name of fn_index matching that number.");return{fn_index:i,endpoint_info:o,dependency:s}}(m,t,_,g),B=((t=[],e)=>{const n=e?e.parameters:[];if(Array.isArray(t))return t.length>n.length&&console.warn("Too many arguments provided for the endpoint."),t;const r=[],i=Object.keys(t);return n.forEach(((e,n)=>{if(t.hasOwnProperty(e.parameter_name))r[n]=t[e.parameter_name];else{if(!e.parameter_has_default)throw new Error(`No value provided for required parameter: ${e.parameter_name}`);r[n]=e.parameter_default}})),i.forEach((t=>{if(!n.some((e=>e.parameter_name===t)))throw new Error(`Parameter \`${t}\` is not a valid keyword argument. Please refer to the API for usage.`)})),r.forEach(((t,e)=>{if(void 0===t&&!n[e].parameter_has_default)throw new Error(`No value provided for required parameter: ${n[e].parameter_name}`)})),r})(e,U),C=g.protocol??"ws",D="",I=()=>D;const N="number"==typeof t?"/predict":t;let j,L=null,z=!1,q={},Y="undefined"!=typeof window&&"undefined"!=typeof document?new URLSearchParams(window.location.search).toString():"";const M=(null==(o=null==T?void 0:T.events)?void 0:o.reduce(((t,e)=>(t[e]=!0,t)),{}))||{};async function F(){const t={stage:"complete",queue:!1,time:new Date};z=t,s({...t,type:"status",endpoint:N,fn_index:$});let e={},n={};"ws"===C?(x&&0===x.readyState?x.addEventListener("open",(()=>{x.close()})):x.close(),e={fn_index:$,session_hash:w}):(Ae(y,R.abort_controller),a(),e={event_id:L},n={event_id:L,session_hash:w,fn_index:$});try{if(!g)throw new Error("Could not resolve app config");"event_id"in n&&await p(`${g.root}${P}/cancel`,{headers:{"Content-Type":"application/json"},method:"POST",body:JSON.stringify(n)}),await p(`${g.root}${P}/reset`,{headers:{"Content-Type":"application/json"},method:"POST",body:JSON.stringify(e)})}catch(t){console.warn("The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable.")}}const W=async t=>{await this._resolve_hearbeat(t)};async function J(t){if(!g)return;let e=t.render_id;g.components=[...g.components.filter((t=>t.props.rendered_in!==e)),...t.components],g.dependencies=[...g.dependencies.filter((t=>t.rendered_in!==e)),...t.dependencies];const n=g.components.some((t=>"state"===t.type)),r=g.dependencies.some((t=>t.targets.some((t=>"unload"===t[1]))));g.connect_heartbeat=n||r,await W(g),s({type:"render",data:t,endpoint:N,fn_index:$})}this.handle_blob(g.root,B,U).then((async t=>{var e;let i=ae(t,O,g.components,"input",!0);if(j={data:i||[],event_data:n,fn_index:$,trigger_id:r},function(t,e){var n,r;let i=null==(r=null==(n=null==e?void 0:e.dependencies)?void 0:n.find((e=>e.id==t)))?void 0:r.queue;return null!=i?!i:!e.enable_queue}($,g))s({type:"status",endpoint:N,stage:"pending",queue:!1,fn_index:$,time:new Date}),A(`${g.root}${P}/run${N.startsWith("/")?N:`/${N}`}${Y?"?"+Y:""}`,{...j,session_hash:w}).then((([t,e])=>{const i=t.data;200==e?(s({type:"data",endpoint:N,fn_index:$,data:ae(i,O,g.components,"output",T.with_null_state),time:new Date,event_data:n,trigger_id:r}),t.render_config&&J(t.render_config),s({type:"status",endpoint:N,fn_index:$,stage:"complete",eta:t.average_duration,queue:!1,time:new Date})):s({type:"status",stage:"error",endpoint:N,fn_index:$,message:t.error,queue:!1,time:new Date})})).catch((t=>{s({type:"status",stage:"error",message:t.message,endpoint:N,fn_index:$,queue:!1,time:new Date})}));else if("ws"==C){const{ws_protocol:t,host:e}=await Jt(d,f);s({type:"status",stage:"pending",queue:!0,endpoint:N,fn_index:$,time:new Date});let i=new URL(`${t}://${Nt(e,g.path,!0)}/queue/join${Y?"?"+Y:""}`);this.jwt&&i.searchParams.set("__sign",this.jwt),x=new WebSocket(i),x.onclose=t=>{t.wasClean||s({type:"status",stage:"error",broken:!0,message:Ot,queue:!0,endpoint:N,fn_index:$,time:new Date})},x.onmessage=function(t){const e=JSON.parse(t.data),{type:i,status:o,data:a}=Zt(e,q[$]);if("update"===i&&o&&!z)s({type:"status",endpoint:N,fn_index:$,time:new Date,...o}),"error"===o.stage&&x.close();else{if("hash"===i)return void x.send(JSON.stringify({fn_index:$,session_hash:w}));"data"===i?x.send(JSON.stringify({...j,session_hash:w})):"complete"===i?z=o:"log"===i?s({type:"log",title:a.title,log:a.log,level:a.level,endpoint:N,duration:a.duration,visible:a.visible,fn_index:$}):"generating"===i&&s({type:"status",time:new Date,...o,stage:null==o?void 0:o.stage,queue:!0,endpoint:N,fn_index:$})}a&&(s({type:"data",time:new Date,data:ae(a.data,O,g.components,"output",T.with_null_state),endpoint:N,fn_index:$,event_data:n,trigger_id:r}),z&&(s({type:"status",time:new Date,...z,stage:null==o?void 0:o.stage,queue:!0,endpoint:N,fn_index:$}),x.close()))},xt(g.version||"2.0.0","3.6")<0&&addEventListener("open",(()=>x.send(JSON.stringify({hash:w}))))}else if("sse"==C){s({type:"status",stage:"pending",queue:!0,endpoint:N,fn_index:$,time:new Date});var o=new URLSearchParams({fn_index:$.toString(),session_hash:w}).toString();let t=new URL(`${g.root}${P}/${kt}?${Y?Y+"&":""}${o}`);if(this.jwt&&t.searchParams.set("__sign",this.jwt),k=this.stream(t),!k)return Promise.reject(new Error("Cannot connect to SSE endpoint: "+t.toString()));k.onmessage=async function(t){const e=JSON.parse(t.data),{type:i,status:o,data:u}=Zt(e,q[$]);if("update"===i&&o&&!z)s({type:"status",endpoint:N,fn_index:$,time:new Date,...o}),"error"===o.stage&&(null==k||k.close(),a());else if("data"===i){let[t,e]=await A(`${g.root}${P}/queue/data`,{...j,session_hash:w,event_id:L});200!==e&&(s({type:"status",stage:"error",message:Ot,queue:!0,endpoint:N,fn_index:$,time:new Date}),null==k||k.close(),a())}else"complete"===i?z=o:"log"===i?s({type:"log",title:u.title,log:u.log,level:u.level,endpoint:N,duration:u.duration,visible:u.visible,fn_index:$}):"generating"!==i&&"streaming"!==i||s({type:"status",time:new Date,...o,stage:null==o?void 0:o.stage,queue:!0,endpoint:N,fn_index:$});u&&(s({type:"data",time:new Date,data:ae(u.data,O,g.components,"output",T.with_null_state),endpoint:N,fn_index:$,event_data:n,trigger_id:r}),z&&(s({type:"status",time:new Date,...z,stage:null==o?void 0:o.stage,queue:!0,endpoint:N,fn_index:$}),null==k||k.close(),a()))}}else if("sse_v1"==C||"sse_v2"==C||"sse_v2.1"==C||"sse_v3"==C){s({type:"status",stage:"pending",queue:!0,endpoint:N,fn_index:$,time:new Date});let t="";"undefined"!=typeof window&&"undefined"!=typeof document&&(t=null==(e=null==window?void 0:window.location)?void 0:e.hostname);let n="dev.spaces.huggingface.tech";const r=t.includes(".dev.")?`https://moon-${t.split(".")[1]}.${n}`:"https://huggingface.co",i="undefined"!=typeof window&&"undefined"!=typeof document&&window.parent!=window&&window.supports_zerogpu_headers?function(t,e){return new Promise(((n,r)=>{const i=new MessageChannel;i.port1.onmessage=({data:t})=>{i.port1.close(),n(t)},window.parent.postMessage(t,e,[i.port2])}))}("zerogpu-headers",r):Promise.resolve(null);i.then((t=>A(`${g.root}${P}/queue/join?${Y}`,{...j,session_hash:w},t))).then((async([t,e])=>{if(503===e)s({type:"status",stage:"error",message:Ut,queue:!0,endpoint:N,fn_index:$,time:new Date});else if(200!==e)s({type:"status",stage:"error",message:Ot,queue:!0,endpoint:N,fn_index:$,time:new Date});else{L=t.event_id,D=L;let e=async function(t){try{const{type:e,status:n,data:r,original_msg:i}=Zt(t,q[$]);if("heartbeat"==e)return;if("update"===e&&n&&!z)s({type:"status",endpoint:N,fn_index:$,time:new Date,original_msg:i,...n});else if("complete"===e)z=n;else if("unexpected_error"==e)console.error("Unexpected error",null==n?void 0:n.message),s({type:"status",stage:"error",message:(null==n?void 0:n.message)||"An Unexpected Error Occurred!",queue:!0,endpoint:N,fn_index:$,time:new Date});else{if("log"===e)return void s({type:"log",title:r.title,log:r.log,level:r.level,endpoint:N,duration:r.duration,visible:r.visible,fn_index:$});"generating"!==e&&"streaming"!==e||(s({type:"status",time:new Date,...n,stage:null==n?void 0:n.stage,queue:!0,endpoint:N,fn_index:$}),r&&"stream"!==O.connection&&["sse_v2","sse_v2.1","sse_v3"].includes(C)&&Te(b,L,r))}r&&(s({type:"data",time:new Date,data:ae(r.data,O,g.components,"output",T.with_null_state),endpoint:N,fn_index:$}),r.render_config&&await J(r.render_config),z&&(s({type:"status",time:new Date,...z,stage:null==n?void 0:n.stage,queue:!0,endpoint:N,fn_index:$}),a())),"complete"!==(null==n?void 0:n.stage)&&"error"!==(null==n?void 0:n.stage)||(E[L]&&delete E[L],L in b&&delete b[L])}catch(t){console.error("Unexpected client exception",t),s({type:"status",stage:"error",message:"An Unexpected Error Occurred!",queue:!0,endpoint:N,fn_index:$,time:new Date}),["sse_v2","sse_v2.1","sse_v3"].includes(C)&&(Ae(y,R.abort_controller),y.open=!1,a())}};L in v&&(v[L].forEach((t=>e(t))),delete v[L]),E[L]=e,S.add(L),y.open||await this.open_stream()}}))}}));let G=!1;const H=[],V=[],Z={[Symbol.asyncIterator]:()=>Z,next:l,throw:async t=>(c(t),l()),return:async()=>(a(),l()),cancel:F,event_id:I};return Z}catch(K){throw console.error("Submit function encountered an error:",K),K}}Et=new WeakMap;class xe{constructor(t,e={events:["data"]}){At(this,"app_reference"),At(this,"options"),At(this,"config"),At(this,"api_prefix",""),At(this,"api_info"),At(this,"api_map",{}),At(this,"session_hash",Math.random().toString(36).substring(2)),At(this,"jwt",!1),At(this,"last_status",{}),At(this,"cookies",null),At(this,"stream_status",{open:!1}),At(this,"pending_stream_messages",{}),At(this,"pending_diff_streams",{}),At(this,"event_callbacks",{}),At(this,"unclosed_events",new Set),At(this,"heartbeat_event",null),At(this,"abort_controller",null),At(this,"stream_instance",null),At(this,"current_payload"),At(this,"ws_map",{}),At(this,"view_api"),At(this,"upload_files"),At(this,"upload"),At(this,"handle_blob"),At(this,"post_data"),At(this,"submit"),At(this,"predict"),At(this,"open_stream"),At(this,"resolve_config"),At(this,"resolve_cookies"),this.app_reference=t,e.events||(e.events=["data"]),this.options=e,this.current_payload={},this.view_api=Kt.bind(this),this.upload_files=Qt.bind(this),this.handle_blob=ue.bind(this),this.post_data=le.bind(this),this.submit=Re.bind(this),this.predict=fe.bind(this),this.open_stream=Se.bind(this),this.resolve_config=Lt.bind(this),this.resolve_cookies=zt.bind(this),this.upload=Xt.bind(this),this.fetch=this.fetch.bind(this),this.handle_space_success=this.handle_space_success.bind(this),this.stream=this.stream.bind(this)}fetch(t,e){const n=new Headers((null==e?void 0:e.headers)||{});if(this&&this.cookies&&n.append("Cookie",this.cookies),this&&this.options.headers)for(const t in this.options.headers)n.append(t,this.options.headers[t]);return fetch(t,{...e,headers:n})}stream(t){const e=new Headers;if(this&&this.cookies&&e.append("Cookie",this.cookies),this&&this.options.headers)for(const t in this.options.headers)e.append(t,this.options.headers[t]);return this.abort_controller=new AbortController,this.stream_instance=Pe(t.toString(),{credentials:"include",headers:e,signal:this.abort_controller.signal}),this.stream_instance}async init(){var e;if(!("undefined"!=typeof window&&"WebSocket"in window||t.WebSocket)){const e=await import("/npm/@gradio/[email protected]/dist/wrapper-CviSselG.js/+esm");t.WebSocket=e.WebSocket}this.options.auth&&await this.resolve_cookies(),await this._resolve_config().then((({config:t})=>this._resolve_hearbeat(t))),this.api_info=await this.view_api(),this.api_map=function(t){let e={};return t.forEach((({api_name:t,id:n})=>{t&&(e[t]=n)})),e}((null==(e=this.config)?void 0:e.dependencies)||[])}async _resolve_hearbeat(t){if(t&&(this.config=t,this.api_prefix=t.api_prefix||"",this.config&&this.config.connect_heartbeat&&this.config.space_id&&this.options.hf_token&&(this.jwt=await jt(this.config.space_id,this.options.hf_token,this.cookies))),t.space_id&&this.options.hf_token&&(this.jwt=await jt(t.space_id,this.options.hf_token)),this.config&&this.config.connect_heartbeat){const t=new URL(`${this.config.root}${this.api_prefix}/heartbeat/${this.session_hash}`);this.jwt&&t.searchParams.set("__sign",this.jwt),this.heartbeat_event||(this.heartbeat_event=this.stream(t))}}static async connect(t,e={events:["data"]}){const n=new this(t,e);return await n.init(),n}close(){Ae(this.stream_status,this.abort_controller)}set_current_payload(t){this.current_payload=t}static async duplicate(t,e={events:["data"]}){return _e(t,e)}async _resolve_config(){const{http_protocol:t,host:e,space_id:n}=await Jt(this.app_reference,this.options.hf_token),{status_callback:r}=this.options;let i;n&&r&&await de(n,r);try{if(i=await this.resolve_config(`${t}//${e}`),!i)throw new Error(Bt);return this.config_success(i)}catch(t){if(!n||!r)throw r&&r({status:"error",message:"Could not load this space.",load_status:"error",detail:"NOT_FOUND"}),Error(t);pe(n,Ft.test(n)?"space_name":"subdomain",this.handle_space_success)}}async config_success(t){if(this.config=t,this.api_prefix=t.api_prefix||"","undefined"!=typeof window&&"undefined"!=typeof document&&"https:"===window.location.protocol&&(this.config.root=this.config.root.replace("http://","https://")),this.config.auth_required)return this.prepare_return_obj();try{this.api_info=await this.view_api()}catch(t){console.error("Could not get API info. "+t.message)}return this.prepare_return_obj()}async handle_space_success(t){var e;if(!this)throw new Error(Bt);const{status_callback:n}=this.options;if(n&&n(t),"running"===t.status)try{if(this.config=await this._resolve_config(),this.api_prefix=(null==(e=null==this?void 0:this.config)?void 0:e.api_prefix)||"",!this.config)throw new Error(Bt);return await this.config_success(this.config)}catch(t){throw n&&n({status:"error",message:"Could not load this space.",load_status:"error",detail:"NOT_FOUND"}),t}}async component_server(t,e,n){var r;if(!this.config)throw new Error(Bt);const i={},{hf_token:o}=this.options,{session_hash:s}=this;let a;o&&(i.Authorization=`Bearer ${this.options.hf_token}`);let u,c=this.config.components.find((e=>e.id===t));if(a=(null==(r=null==c?void 0:c.props)?void 0:r.root_url)?c.props.root_url:this.config.root,"binary"in n){u=new FormData;for(const t in n.data)"binary"!==t&&u.append(t,n.data[t]);u.set("component_id",t.toString()),u.set("fn_name",e),u.set("session_hash",s)}else u=JSON.stringify({data:n,component_id:t,fn_name:e,session_hash:s}),i["Content-Type"]="application/json";o&&(i.Authorization=`Bearer ${o}`);try{const t=await this.fetch(`${a}${this.api_prefix}/component_server/`,{method:"POST",body:u,headers:i,credentials:"include"});if(!t.ok)throw new Error("Could not connect to component server: "+t.statusText);return await t.json()}catch(t){console.warn(t)}}set_cookies(t){this.cookies=Mt(t).join("; ")}prepare_return_obj(){return{config:this.config,predict:this.predict,submit:this.submit,view_api:this.view_api,component_server:this.component_server}}async connect_ws(t){return new Promise(((e,n)=>{let r;try{r=new WebSocket(t)}catch(e){return void(this.ws_map[t]="failed")}r.onopen=()=>{e()},r.onerror=n=>{console.error("WebSocket error:",n),this.close_ws(t),this.ws_map[t]="failed",e()},r.onclose=()=>{delete this.ws_map[t],this.ws_map[t]="failed"},r.onmessage=t=>{},this.ws_map[t]=r}))}async send_ws_message(t,e){t in this.ws_map||await this.connect_ws(t);const n=this.ws_map[t];n instanceof WebSocket?n.send(JSON.stringify(e)):this.post_data(t,e)}async close_ws(t){if(t in this.ws_map){const e=this.ws_map[t];e instanceof WebSocket&&(e.close(),delete this.ws_map[t])}}}async function ke(t,e={events:["data"]}){return await xe.connect(t,e)}async function $e(t,e){return await xe.duplicate(t,e)}export{xe as Client,ee as FileData,ke as client,$e as duplicate,se as handle_file,fe as predict,te as prepare_files,Re as submit,Xt as upload,Qt as upload_files};export default null;
+//# sourceMappingURL=/sm/4d92fd0f682c91bdc5f31b37e659b6bd0cf5b64ff6c4edc2d0c0cb3f4bfa1850.map

libs/three.js/0.172.0/jsm/Addons.js ADDED Viewed

	@@ -0,0 +1,287 @@

+export * from './animation/AnimationClipCreator.js';
+export * from './animation/CCDIKSolver.js';
+export { default as WebGL } from './capabilities/WebGL.js';
+export * from './controls/ArcballControls.js';
+export * from './controls/DragControls.js';
+export * from './controls/FirstPersonControls.js';
+export * from './controls/FlyControls.js';
+export * from './controls/MapControls.js';
+export * from './controls/OrbitControls.js';
+export * from './controls/PointerLockControls.js';
+export * from './controls/TrackballControls.js';
+export * from './controls/TransformControls.js';
+export * from './csm/CSM.js';
+export * from './csm/CSMFrustum.js';
+export * from './csm/CSMHelper.js';
+export * from './csm/CSMShader.js';
+export * as Curves from './curves/CurveExtras.js';
+export * from './curves/NURBSCurve.js';
+export * from './curves/NURBSSurface.js';
+export * from './curves/NURBSVolume.js';
+export * as NURBSUtils from './curves/NURBSUtils.js';
+export * from './effects/AnaglyphEffect.js';
+export * from './effects/AsciiEffect.js';
+export * from './effects/OutlineEffect.js';
+export * from './effects/ParallaxBarrierEffect.js';
+export * from './effects/PeppersGhostEffect.js';
+export * from './effects/StereoEffect.js';
+export * from './environments/DebugEnvironment.js';
+export * from './environments/RoomEnvironment.js';
+export * from './exporters/DRACOExporter.js';
+export * from './exporters/EXRExporter.js';
+export * from './exporters/GLTFExporter.js';
+export * from './exporters/KTX2Exporter.js';
+export * from './exporters/OBJExporter.js';
+export * from './exporters/PLYExporter.js';
+export * from './exporters/STLExporter.js';
+export * from './exporters/USDZExporter.js';
+export * from './geometries/BoxLineGeometry.js';
+export * from './geometries/ConvexGeometry.js';
+export * from './geometries/DecalGeometry.js';
+export * from './geometries/ParametricGeometries.js';
+export * from './geometries/ParametricGeometry.js';
+export * from './geometries/RoundedBoxGeometry.js';
+export * from './geometries/TeapotGeometry.js';
+export * from './geometries/TextGeometry.js';
+export * from './helpers/LightProbeHelper.js';
+export * from './helpers/OctreeHelper.js';
+export * from './helpers/PositionalAudioHelper.js';
+export * from './helpers/RectAreaLightHelper.js';
+export * from './helpers/TextureHelper.js';
+export * from './helpers/VertexNormalsHelper.js';
+export * from './helpers/VertexTangentsHelper.js';
+export * from './helpers/ViewHelper.js';
+export * from './interactive/HTMLMesh.js';
+export * from './interactive/InteractiveGroup.js';
+export * from './interactive/SelectionBox.js';
+export * from './interactive/SelectionHelper.js';
+export * from './lights/LightProbeGenerator.js';
+export * from './lights/RectAreaLightTexturesLib.js';
+export * from './lights/RectAreaLightUniformsLib.js';
+export * from './lines/Line2.js';
+export * from './lines/LineGeometry.js';
+export * from './lines/LineMaterial.js';
+export * from './lines/LineSegments2.js';
+export * from './lines/LineSegmentsGeometry.js';
+export * from './lines/Wireframe.js';
+export * from './lines/WireframeGeometry2.js';
+export * from './loaders/3DMLoader.js';
+export * from './loaders/3MFLoader.js';
+export * from './loaders/AMFLoader.js';
+export * from './loaders/BVHLoader.js';
+export * from './loaders/ColladaLoader.js';
+export * from './loaders/DDSLoader.js';
+export * from './loaders/DRACOLoader.js';
+export * from './loaders/EXRLoader.js';
+export * from './loaders/FBXLoader.js';
+export * from './loaders/FontLoader.js';
+export * from './loaders/GCodeLoader.js';
+export * from './loaders/GLTFLoader.js';
+export * from './loaders/HDRCubeTextureLoader.js';
+export * from './loaders/IESLoader.js';
+export * from './loaders/KMZLoader.js';
+export * from './loaders/KTX2Loader.js';
+export * from './loaders/KTXLoader.js';
+export * from './loaders/LDrawLoader.js';
+export * from './loaders/LUT3dlLoader.js';
+export * from './loaders/LUTCubeLoader.js';
+export * from './loaders/LWOLoader.js';
+export * from './loaders/LottieLoader.js';
+export * from './loaders/MD2Loader.js';
+export * from './loaders/MDDLoader.js';
+export * from './loaders/MTLLoader.js';
+export * from './loaders/NRRDLoader.js';
+export * from './loaders/OBJLoader.js';
+export * from './loaders/PCDLoader.js';
+export * from './loaders/PDBLoader.js';
+export * from './loaders/PLYLoader.js';
+export * from './loaders/PVRLoader.js';
+export * from './loaders/RGBELoader.js';
+export * from './loaders/UltraHDRLoader.js';
+export * from './loaders/RGBMLoader.js';
+export * from './loaders/STLLoader.js';
+export * from './loaders/SVGLoader.js';
+export * from './loaders/TDSLoader.js';
+export * from './loaders/TGALoader.js';
+export * from './loaders/TIFFLoader.js';
+export * from './loaders/TTFLoader.js';
+export * from './loaders/USDZLoader.js';
+export * from './loaders/VOXLoader.js';
+export * from './loaders/VRMLLoader.js';
+export * from './loaders/VTKLoader.js';
+export * from './loaders/XYZLoader.js';
+export * from './materials/MeshGouraudMaterial.js';
+export * from './materials/LDrawConditionalLineMaterial.js';
+export * from './materials/MeshPostProcessingMaterial.js';
+export * from './math/Capsule.js';
+export * from './math/ColorConverter.js';
+export * from './math/ConvexHull.js';
+export * from './math/ImprovedNoise.js';
+export * from './math/Lut.js';
+export * from './math/MeshSurfaceSampler.js';
+export * from './math/OBB.js';
+export * from './math/Octree.js';
+export * from './math/SimplexNoise.js';
+export * from './misc/ConvexObjectBreaker.js';
+export * from './misc/GPUComputationRenderer.js';
+export * from './misc/Gyroscope.js';
+export * from './misc/MD2Character.js';
+export * from './misc/MD2CharacterComplex.js';
+export * from './misc/MorphAnimMesh.js';
+export * from './misc/MorphBlendMesh.js';
+export * from './misc/ProgressiveLightMap.js';
+export * from './misc/RollerCoaster.js';
+export * from './misc/Timer.js';
+export * from './misc/TubePainter.js';
+export * from './misc/Volume.js';
+export * from './misc/VolumeSlice.js';
+export * from './modifiers/CurveModifier.js';
+export * from './modifiers/EdgeSplitModifier.js';
+export * from './modifiers/SimplifyModifier.js';
+export * from './modifiers/TessellateModifier.js';
+export * from './objects/GroundedSkybox.js';
+export * from './objects/Lensflare.js';
+export * from './objects/MarchingCubes.js';
+export * from './objects/Reflector.js';
+export * from './objects/ReflectorForSSRPass.js';
+export * from './objects/Refractor.js';
+export * from './objects/ShadowMesh.js';
+export * from './objects/Sky.js';
+export * from './objects/Water.js';
+export { Water as Water2 } from './objects/Water2.js';
+export * from './physics/AmmoPhysics.js';
+export * from './physics/RapierPhysics.js';
+export * from './postprocessing/AfterimagePass.js';
+export * from './postprocessing/BloomPass.js';
+export * from './postprocessing/BokehPass.js';
+export * from './postprocessing/ClearPass.js';
+export * from './postprocessing/CubeTexturePass.js';
+export * from './postprocessing/DotScreenPass.js';
+export * from './postprocessing/EffectComposer.js';
+export * from './postprocessing/FilmPass.js';
+export * from './postprocessing/GlitchPass.js';
+export * from './postprocessing/GTAOPass.js';
+export * from './postprocessing/HalftonePass.js';
+export * from './postprocessing/LUTPass.js';
+export * from './postprocessing/MaskPass.js';
+export * from './postprocessing/OutlinePass.js';
+export * from './postprocessing/OutputPass.js';
+export * from './postprocessing/Pass.js';
+export * from './postprocessing/RenderPass.js';
+export * from './postprocessing/RenderPixelatedPass.js';
+export * from './postprocessing/SAOPass.js';
+export * from './postprocessing/SMAAPass.js';
+export * from './postprocessing/SSAARenderPass.js';
+export * from './postprocessing/SSAOPass.js';
+export * from './postprocessing/SSRPass.js';
+export * from './postprocessing/SavePass.js';
+export * from './postprocessing/ShaderPass.js';
+export * from './postprocessing/TAARenderPass.js';
+export * from './postprocessing/TexturePass.js';
+export * from './postprocessing/UnrealBloomPass.js';
+export * from './renderers/CSS2DRenderer.js';
+export * from './renderers/CSS3DRenderer.js';
+export * from './renderers/Projector.js';
+export * from './renderers/SVGRenderer.js';
+export * from './shaders/ACESFilmicToneMappingShader.js';
+export * from './shaders/AfterimageShader.js';
+export * from './shaders/BasicShader.js';
+export * from './shaders/BleachBypassShader.js';
+export * from './shaders/BlendShader.js';
+export * from './shaders/BokehShader.js';
+export { BokehShader as BokehShader2 } from './shaders/BokehShader2.js';
+export * from './shaders/BrightnessContrastShader.js';
+export * from './shaders/ColorCorrectionShader.js';
+export * from './shaders/ColorifyShader.js';
+export * from './shaders/ConvolutionShader.js';
+export * from './shaders/CopyShader.js';
+export * from './shaders/DOFMipMapShader.js';
+export * from './shaders/DepthLimitedBlurShader.js';
+export * from './shaders/DigitalGlitch.js';
+export * from './shaders/DotScreenShader.js';
+export * from './shaders/ExposureShader.js';
+export * from './shaders/FXAAShader.js';
+export * from './shaders/FilmShader.js';
+export * from './shaders/FocusShader.js';
+export * from './shaders/FreiChenShader.js';
+export * from './shaders/GammaCorrectionShader.js';
+export * from './shaders/GodRaysShader.js';
+export * from './shaders/GTAOShader.js';
+export * from './shaders/HalftoneShader.js';
+export * from './shaders/HorizontalBlurShader.js';
+export * from './shaders/HorizontalTiltShiftShader.js';
+export * from './shaders/HueSaturationShader.js';
+export * from './shaders/KaleidoShader.js';
+export * from './shaders/LuminosityHighPassShader.js';
+export * from './shaders/LuminosityShader.js';
+export * from './shaders/MirrorShader.js';
+export * from './shaders/NormalMapShader.js';
+export * from './shaders/OutputShader.js';
+export * from './shaders/RGBShiftShader.js';
+export * from './shaders/SAOShader.js';
+export * from './shaders/SMAAShader.js';
+export * from './shaders/SSAOShader.js';
+export * from './shaders/SSRShader.js';
+export * from './shaders/SepiaShader.js';
+export * from './shaders/SobelOperatorShader.js';
+export * from './shaders/SubsurfaceScatteringShader.js';
+export * from './shaders/TechnicolorShader.js';
+export * from './shaders/ToonShader.js';
+export * from './shaders/TriangleBlurShader.js';
+export * from './shaders/UnpackDepthRGBAShader.js';
+export * from './shaders/VelocityShader.js';
+export * from './shaders/VerticalBlurShader.js';
+export * from './shaders/VerticalTiltShiftShader.js';
+export * from './shaders/VignetteShader.js';
+export * from './shaders/VolumeShader.js';
+export * from './shaders/WaterRefractionShader.js';
+export * from './textures/FlakesTexture.js';
+export * as BufferGeometryUtils from './utils/BufferGeometryUtils.js';
+export * as CameraUtils from './utils/CameraUtils.js';
+export * as GeometryCompressionUtils from './utils/GeometryCompressionUtils.js';
+export * as GeometryUtils from './utils/GeometryUtils.js';
+export * from './utils/LDrawUtils.js';
+export * as SceneUtils from './utils/SceneUtils.js';
+export * from './utils/ShadowMapViewer.js';
+export * as SkeletonUtils from './utils/SkeletonUtils.js';
+export * as SortUtils from './utils/SortUtils.js';
+export * from './utils/WebGLTextureUtils.js';
+export * from './utils/UVsDebug.js';
+export * from './utils/WorkerPool.js';
+export * from './webxr/ARButton.js';
+export * from './webxr/OculusHandModel.js';
+export * from './webxr/OculusHandPointerModel.js';
+export * from './webxr/Text2D.js';
+export * from './webxr/VRButton.js';
+export * from './webxr/XRButton.js';
+export * from './webxr/XRControllerModelFactory.js';
+export * from './webxr/XREstimatedLight.js';
+export * from './webxr/XRHandMeshModel.js';
+export * from './webxr/XRHandModelFactory.js';
+export * from './webxr/XRHandPrimitiveModel.js';
+export * from './webxr/XRPlanes.js';

libs/three.js/0.172.0/jsm/animation/AnimationClipCreator.js ADDED Viewed

	@@ -0,0 +1,116 @@

+import {
+	AnimationClip,
+	BooleanKeyframeTrack,
+	ColorKeyframeTrack,
+	NumberKeyframeTrack,
+	Vector3,
+	VectorKeyframeTrack
+} from 'three';
+class AnimationClipCreator {
+	static CreateRotationAnimation( period, axis = 'x' ) {
+		const times = [ 0, period ], values = [ 0, 360 ];
+		const trackName = '.rotation[' + axis + ']';
+		const track = new NumberKeyframeTrack( trackName, times, values );
+		return new AnimationClip( null, period, [ track ] );
+	}
+	static CreateScaleAxisAnimation( period, axis = 'x' ) {
+		const times = [ 0, period ], values = [ 0, 1 ];
+		const trackName = '.scale[' + axis + ']';
+		const track = new NumberKeyframeTrack( trackName, times, values );
+		return new AnimationClip( null, period, [ track ] );
+	}
+	static CreateShakeAnimation( duration, shakeScale ) {
+		const times = [], values = [], tmp = new Vector3();
+		for ( let i = 0; i < duration * 10; i ++ ) {
+			times.push( i / 10 );
+			tmp.set( Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0 ).
+				multiply( shakeScale ).
+				toArray( values, values.length );
+		}
+		const trackName = '.position';
+		const track = new VectorKeyframeTrack( trackName, times, values );
+		return new AnimationClip( null, duration, [ track ] );
+	}
+	static CreatePulsationAnimation( duration, pulseScale ) {
+		const times = [], values = [], tmp = new Vector3();
+		for ( let i = 0; i < duration * 10; i ++ ) {
+			times.push( i / 10 );
+			const scaleFactor = Math.random() * pulseScale;
+			tmp.set( scaleFactor, scaleFactor, scaleFactor ).
+				toArray( values, values.length );
+		}
+		const trackName = '.scale';
+		const track = new VectorKeyframeTrack( trackName, times, values );
+		return new AnimationClip( null, duration, [ track ] );
+	}
+	static CreateVisibilityAnimation( duration ) {
+		const times = [ 0, duration / 2, duration ], values = [ true, false, true ];
+		const trackName = '.visible';
+		const track = new BooleanKeyframeTrack( trackName, times, values );
+		return new AnimationClip( null, duration, [ track ] );
+	}
+	static CreateMaterialColorAnimation( duration, colors ) {
+		const times = [], values = [],
+			timeStep = ( colors.length > 1 ) ? duration / ( colors.length - 1 ) : 0;
+		for ( let i = 0; i < colors.length; i ++ ) {
+			times.push( i * timeStep );
+			const color = colors[ i ];
+			values.push( color.r, color.g, color.b );
+		}
+		const trackName = '.material.color';
+		const track = new ColorKeyframeTrack( trackName, times, values );
+		return new AnimationClip( null, duration, [ track ] );
+	}
+}
+export { AnimationClipCreator };

libs/three.js/0.172.0/jsm/animation/CCDIKSolver.js ADDED Viewed

	@@ -0,0 +1,485 @@

+import {
+	BufferAttribute,
+	BufferGeometry,
+	Color,
+	Line,
+	LineBasicMaterial,
+	Matrix4,
+	Mesh,
+	MeshBasicMaterial,
+	Object3D,
+	Quaternion,
+	SphereGeometry,
+	Vector3
+} from 'three';
+const _q = new Quaternion();
+const _targetPos = new Vector3();
+const _targetVec = new Vector3();
+const _effectorPos = new Vector3();
+const _effectorVec = new Vector3();
+const _linkPos = new Vector3();
+const _invLinkQ = new Quaternion();
+const _linkScale = new Vector3();
+const _axis = new Vector3();
+const _vector = new Vector3();
+const _matrix = new Matrix4();
+/**
+ * CCD Algorithm
+ *  - https://web.archive.org/web/20221206080850/https://sites.google.com/site/auraliusproject/ccd-algorithm
+ *
+ * // ik parameter example
+ * //
+ * // target, effector, index in links are bone index in skeleton.bones.
+ * // the bones relation should be
+ * // <-- parent                                  child -->
+ * // links[ n ], links[ n - 1 ], ..., links[ 0 ], effector
+ * iks = [ {
+ *	target: 1,
+ *	effector: 2,
+ *	links: [ { index: 5, limitation: new Vector3( 1, 0, 0 ) }, { index: 4, enabled: false }, { index : 3 } ],
+ *	iteration: 10,
+ *	minAngle: 0.0,
+ *	maxAngle: 1.0,
+ * } ];
+ */
+class CCDIKSolver {
+	/**
+	 * @param {THREE.SkinnedMesh} mesh
+	 * @param {Array<Object>} iks
+	 */
+	constructor( mesh, iks = [] ) {
+		this.mesh = mesh;
+		this.iks = iks;
+		this._valid();
+	}
+	/**
+	 * Update all IK bones.
+	 *
+	 * @return {CCDIKSolver}
+	 */
+	update() {
+		const iks = this.iks;
+		for ( let i = 0, il = iks.length; i < il; i ++ ) {
+			this.updateOne( iks[ i ] );
+		}
+		return this;
+	}
+	/**
+	 * Update one IK bone
+	 *
+	 * @param {Object} ik parameter
+	 * @return {CCDIKSolver}
+	 */
+	updateOne( ik ) {
+		const bones = this.mesh.skeleton.bones;
+		// for reference overhead reduction in loop
+		const math = Math;
+		const effector = bones[ ik.effector ];
+		const target = bones[ ik.target ];
+		// don't use getWorldPosition() here for the performance
+		// because it calls updateMatrixWorld( true ) inside.
+		_targetPos.setFromMatrixPosition( target.matrixWorld );
+		const links = ik.links;
+		const iteration = ik.iteration !== undefined ? ik.iteration : 1;
+		for ( let i = 0; i < iteration; i ++ ) {
+			let rotated = false;
+			for ( let j = 0, jl = links.length; j < jl; j ++ ) {
+				const link = bones[ links[ j ].index ];
+				// skip this link and following links
+				if ( links[ j ].enabled === false ) break;
+				const limitation = links[ j ].limitation;
+				const rotationMin = links[ j ].rotationMin;
+				const rotationMax = links[ j ].rotationMax;
+				// don't use getWorldPosition/Quaternion() here for the performance
+				// because they call updateMatrixWorld( true ) inside.
+				link.matrixWorld.decompose( _linkPos, _invLinkQ, _linkScale );
+				_invLinkQ.invert();
+				_effectorPos.setFromMatrixPosition( effector.matrixWorld );
+				// work in link world
+				_effectorVec.subVectors( _effectorPos, _linkPos );
+				_effectorVec.applyQuaternion( _invLinkQ );
+				_effectorVec.normalize();
+				_targetVec.subVectors( _targetPos, _linkPos );
+				_targetVec.applyQuaternion( _invLinkQ );
+				_targetVec.normalize();
+				let angle = _targetVec.dot( _effectorVec );
+				if ( angle > 1.0 ) {
+					angle = 1.0;
+				} else if ( angle < - 1.0 ) {
+					angle = - 1.0;
+				}
+				angle = math.acos( angle );
+				// skip if changing angle is too small to prevent vibration of bone
+				if ( angle < 1e-5 ) continue;
+				if ( ik.minAngle !== undefined && angle < ik.minAngle ) {
+					angle = ik.minAngle;
+				}
+				if ( ik.maxAngle !== undefined && angle > ik.maxAngle ) {
+					angle = ik.maxAngle;
+				}
+				_axis.crossVectors( _effectorVec, _targetVec );
+				_axis.normalize();
+				_q.setFromAxisAngle( _axis, angle );
+				link.quaternion.multiply( _q );
+				// TODO: re-consider the limitation specification
+				if ( limitation !== undefined ) {
+					let c = link.quaternion.w;
+					if ( c > 1.0 ) c = 1.0;
+					const c2 = math.sqrt( 1 - c * c );
+					link.quaternion.set( limitation.x * c2,
+					                     limitation.y * c2,
+					                     limitation.z * c2,
+					                     c );
+				}
+				if ( rotationMin !== undefined ) {
+					link.rotation.setFromVector3( _vector.setFromEuler( link.rotation ).max( rotationMin ) );
+				}
+				if ( rotationMax !== undefined ) {
+					link.rotation.setFromVector3( _vector.setFromEuler( link.rotation ).min( rotationMax ) );
+				}
+				link.updateMatrixWorld( true );
+				rotated = true;
+			}
+			if ( ! rotated ) break;
+		}
+		return this;
+	}
+	/**
+	 * Creates Helper
+	 *
+	 * @param {number} sphereSize
+	 * @return {CCDIKHelper}
+	 */
+	createHelper( sphereSize ) {
+		return new CCDIKHelper( this.mesh, this.iks, sphereSize );
+	}
+	// private methods
+	_valid() {
+		const iks = this.iks;
+		const bones = this.mesh.skeleton.bones;
+		for ( let i = 0, il = iks.length; i < il; i ++ ) {
+			const ik = iks[ i ];
+			const effector = bones[ ik.effector ];
+			const links = ik.links;
+			let link0, link1;
+			link0 = effector;
+			for ( let j = 0, jl = links.length; j < jl; j ++ ) {
+				link1 = bones[ links[ j ].index ];
+				if ( link0.parent !== link1 ) {
+					console.warn( 'THREE.CCDIKSolver: bone ' + link0.name + ' is not the child of bone ' + link1.name );
+				}
+				link0 = link1;
+			}
+		}
+	}
+}
+function getPosition( bone, matrixWorldInv ) {
+	return _vector
+		.setFromMatrixPosition( bone.matrixWorld )
+		.applyMatrix4( matrixWorldInv );
+}
+function setPositionOfBoneToAttributeArray( array, index, bone, matrixWorldInv ) {
+	const v = getPosition( bone, matrixWorldInv );
+	array[ index * 3 + 0 ] = v.x;
+	array[ index * 3 + 1 ] = v.y;
+	array[ index * 3 + 2 ] = v.z;
+}
+/**
+ * Visualize IK bones
+ *
+ * @param {SkinnedMesh} mesh
+ * @param {Array<Object>} iks
+ * @param {number} sphereSize
+ */
+class CCDIKHelper extends Object3D {
+	constructor( mesh, iks = [], sphereSize = 0.25 ) {
+		super();
+		this.root = mesh;
+		this.iks = iks;
+		this.matrix.copy( mesh.matrixWorld );
+		this.matrixAutoUpdate = false;
+		this.sphereGeometry = new SphereGeometry( sphereSize, 16, 8 );
+		this.targetSphereMaterial = new MeshBasicMaterial( {
+			color: new Color( 0xff8888 ),
+			depthTest: false,
+			depthWrite: false,
+			transparent: true
+		} );
+		this.effectorSphereMaterial = new MeshBasicMaterial( {
+			color: new Color( 0x88ff88 ),
+			depthTest: false,
+			depthWrite: false,
+			transparent: true
+		} );
+		this.linkSphereMaterial = new MeshBasicMaterial( {
+			color: new Color( 0x8888ff ),
+			depthTest: false,
+			depthWrite: false,
+			transparent: true
+		} );
+		this.lineMaterial = new LineBasicMaterial( {
+			color: new Color( 0xff0000 ),
+			depthTest: false,
+			depthWrite: false,
+			transparent: true
+		} );
+		this._init();
+	}
+	/**
+	 * Updates IK bones visualization.
+	 *
+	 * @param {Boolean} force
+	 */
+	updateMatrixWorld( force ) {
+		const mesh = this.root;
+		if ( this.visible ) {
+			let offset = 0;
+			const iks = this.iks;
+			const bones = mesh.skeleton.bones;
+			_matrix.copy( mesh.matrixWorld ).invert();
+			for ( let i = 0, il = iks.length; i < il; i ++ ) {
+				const ik = iks[ i ];
+				const targetBone = bones[ ik.target ];
+				const effectorBone = bones[ ik.effector ];
+				const targetMesh = this.children[ offset ++ ];
+				const effectorMesh = this.children[ offset ++ ];
+				targetMesh.position.copy( getPosition( targetBone, _matrix ) );
+				effectorMesh.position.copy( getPosition( effectorBone, _matrix ) );
+				for ( let j = 0, jl = ik.links.length; j < jl; j ++ ) {
+					const link = ik.links[ j ];
+					const linkBone = bones[ link.index ];
+					const linkMesh = this.children[ offset ++ ];
+					linkMesh.position.copy( getPosition( linkBone, _matrix ) );
+				}
+				const line = this.children[ offset ++ ];
+				const array = line.geometry.attributes.position.array;
+				setPositionOfBoneToAttributeArray( array, 0, targetBone, _matrix );
+				setPositionOfBoneToAttributeArray( array, 1, effectorBone, _matrix );
+				for ( let j = 0, jl = ik.links.length; j < jl; j ++ ) {
+					const link = ik.links[ j ];
+					const linkBone = bones[ link.index ];
+					setPositionOfBoneToAttributeArray( array, j + 2, linkBone, _matrix );
+				}
+				line.geometry.attributes.position.needsUpdate = true;
+			}
+		}
+		this.matrix.copy( mesh.matrixWorld );
+		super.updateMatrixWorld( force );
+	}
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+		this.sphereGeometry.dispose();
+		this.targetSphereMaterial.dispose();
+		this.effectorSphereMaterial.dispose();
+		this.linkSphereMaterial.dispose();
+		this.lineMaterial.dispose();
+		const children = this.children;
+		for ( let i = 0; i < children.length; i ++ ) {
+			const child = children[ i ];
+			if ( child.isLine ) child.geometry.dispose();
+		}
+	}
+	// private method
+	_init() {
+		const scope = this;
+		const iks = this.iks;
+		function createLineGeometry( ik ) {
+			const geometry = new BufferGeometry();
+			const vertices = new Float32Array( ( 2 + ik.links.length ) * 3 );
+			geometry.setAttribute( 'position', new BufferAttribute( vertices, 3 ) );
+			return geometry;
+		}
+		function createTargetMesh() {
+			return new Mesh( scope.sphereGeometry, scope.targetSphereMaterial );
+		}
+		function createEffectorMesh() {
+			return new Mesh( scope.sphereGeometry, scope.effectorSphereMaterial );
+		}
+		function createLinkMesh() {
+			return new Mesh( scope.sphereGeometry, scope.linkSphereMaterial );
+		}
+		function createLine( ik ) {
+			return new Line( createLineGeometry( ik ), scope.lineMaterial );
+		}
+		for ( let i = 0, il = iks.length; i < il; i ++ ) {
+			const ik = iks[ i ];
+			this.add( createTargetMesh() );
+			this.add( createEffectorMesh() );
+			for ( let j = 0, jl = ik.links.length; j < jl; j ++ ) {
+				this.add( createLinkMesh() );
+			}
+			this.add( createLine( ik ) );
+		}
+	}
+}
+export { CCDIKSolver, CCDIKHelper };

libs/three.js/0.172.0/jsm/capabilities/WebGL.js ADDED Viewed

	@@ -0,0 +1,114 @@

+class WebGL {
+	static isWebGL2Available() {
+		try {
+			const canvas = document.createElement( 'canvas' );
+			return !! ( window.WebGL2RenderingContext && canvas.getContext( 'webgl2' ) );
+		} catch ( e ) {
+			return false;
+		}
+	}
+	static isColorSpaceAvailable( colorSpace ) {
+		try {
+			const canvas = document.createElement( 'canvas' );
+			const ctx = window.WebGL2RenderingContext && canvas.getContext( 'webgl2' );
+			ctx.drawingBufferColorSpace = colorSpace;
+			return ctx.drawingBufferColorSpace === colorSpace; // deepscan-disable-line SAME_OPERAND_VALUE
+		} catch ( e ) {
+			return false;
+		}
+	}
+	static getWebGL2ErrorMessage() {
+		return this.getErrorMessage( 2 );
+	}
+	static getErrorMessage( version ) {
+		const names = {
+			1: 'WebGL',
+			2: 'WebGL 2'
+		};
+		const contexts = {
+			1: window.WebGLRenderingContext,
+			2: window.WebGL2RenderingContext
+		};
+		let message = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
+		const element = document.createElement( 'div' );
+		element.id = 'webglmessage';
+		element.style.fontFamily = 'monospace';
+		element.style.fontSize = '13px';
+		element.style.fontWeight = 'normal';
+		element.style.textAlign = 'center';
+		element.style.background = '#fff';
+		element.style.color = '#000';
+		element.style.padding = '1.5em';
+		element.style.width = '400px';
+		element.style.margin = '5em auto 0';
+		if ( contexts[ version ] ) {
+			message = message.replace( '$0', 'graphics card' );
+		} else {
+			message = message.replace( '$0', 'browser' );
+		}
+		message = message.replace( '$1', names[ version ] );
+		element.innerHTML = message;
+		return element;
+	}
+	// @deprecated, r168
+	static isWebGLAvailable() {
+		console.warn( 'isWebGLAvailable() has been deprecated and will be removed in r178. Use isWebGL2Available() instead.' );
+		try {
+			const canvas = document.createElement( 'canvas' );
+			return !! ( window.WebGLRenderingContext && ( canvas.getContext( 'webgl' ) || canvas.getContext( 'experimental-webgl' ) ) );
+		} catch ( e ) {
+			return false;
+		}
+	}
+	static getWebGLErrorMessage() {
+		console.warn( 'getWebGLErrorMessage() has been deprecated and will be removed in r178. Use getWebGL2ErrorMessage() instead.' );
+		return this.getErrorMessage( 1 );
+	}
+}
+export default WebGL;

libs/three.js/0.172.0/jsm/capabilities/WebGPU.js ADDED Viewed

	@@ -0,0 +1,48 @@

+let isAvailable = ( typeof navigator !== 'undefined'  && navigator.gpu !== undefined );
+if ( typeof window !== 'undefined' && isAvailable ) {
+	isAvailable = await navigator.gpu.requestAdapter();
+}
+class WebGPU {
+	static isAvailable() {
+		return Boolean( isAvailable );
+	}
+	static getStaticAdapter() {
+		return isAvailable;
+	}
+	static getErrorMessage() {
+		const message = 'Your browser does not support <a href="https://gpuweb.github.io/gpuweb/" style="color:blue">WebGPU</a> yet';
+		const element = document.createElement( 'div' );
+		element.id = 'webgpumessage';
+		element.style.fontFamily = 'monospace';
+		element.style.fontSize = '13px';
+		element.style.fontWeight = 'normal';
+		element.style.textAlign = 'center';
+		element.style.background = '#fff';
+		element.style.color = '#000';
+		element.style.padding = '1.5em';
+		element.style.maxWidth = '400px';
+		element.style.margin = '5em auto 0';
+		element.innerHTML = message;
+		return element;
+	}
+}
+export default WebGPU;

libs/three.js/0.172.0/jsm/controls/ArcballControls.js ADDED Viewed

	@@ -0,0 +1,3253 @@

+import {
+	Controls,
+	GridHelper,
+	EllipseCurve,
+	BufferGeometry,
+	Line,
+	LineBasicMaterial,
+	Raycaster,
+	Group,
+	Box3,
+	Sphere,
+	Quaternion,
+	Vector2,
+	Vector3,
+	Matrix4,
+	MathUtils
+} from 'three';
+//trackball state
+const STATE = {
+	IDLE: Symbol(),
+	ROTATE: Symbol(),
+	PAN: Symbol(),
+	SCALE: Symbol(),
+	FOV: Symbol(),
+	FOCUS: Symbol(),
+	ZROTATE: Symbol(),
+	TOUCH_MULTI: Symbol(),
+	ANIMATION_FOCUS: Symbol(),
+	ANIMATION_ROTATE: Symbol()
+};
+const INPUT = {
+	NONE: Symbol(),
+	ONE_FINGER: Symbol(),
+	ONE_FINGER_SWITCHED: Symbol(),
+	TWO_FINGER: Symbol(),
+	MULT_FINGER: Symbol(),
+	CURSOR: Symbol()
+};
+//cursor center coordinates
+const _center = {
+	x: 0,
+	y: 0
+};
+//transformation matrices for gizmos and camera
+const _transformation = {
+	camera: new Matrix4(),
+	gizmos: new Matrix4()
+};
+//events
+const _changeEvent = { type: 'change' };
+const _startEvent = { type: 'start' };
+const _endEvent = { type: 'end' };
+const _raycaster = new Raycaster();
+const _offset = new Vector3();
+const _gizmoMatrixStateTemp = new Matrix4();
+const _cameraMatrixStateTemp = new Matrix4();
+const _scalePointTemp = new Vector3();
+/**
+ *
+ * @param {Camera} camera Virtual camera used in the scene
+ * @param {HTMLElement} domElement Renderer's dom element
+ * @param {Scene} scene The scene to be rendered
+ */
+class ArcballControls extends Controls {
+	constructor( camera, domElement = null, scene = null ) {
+		super( camera, domElement );
+		this.scene = scene;
+		this.target = new Vector3();
+		this._currentTarget = new Vector3();
+		this.radiusFactor = 0.67;
+		this.mouseActions = [];
+		this._mouseOp = null;
+		//global vectors and matrices that are used in some operations to avoid creating new objects every time (e.g. every time cursor moves)
+		this._v2_1 = new Vector2();
+		this._v3_1 = new Vector3();
+		this._v3_2 = new Vector3();
+		this._m4_1 = new Matrix4();
+		this._m4_2 = new Matrix4();
+		this._quat = new Quaternion();
+		//transformation matrices
+		this._translationMatrix = new Matrix4(); //matrix for translation operation
+		this._rotationMatrix = new Matrix4(); //matrix for rotation operation
+		this._scaleMatrix = new Matrix4(); //matrix for scaling operation
+		this._rotationAxis = new Vector3(); //axis for rotate operation
+		//camera state
+		this._cameraMatrixState = new Matrix4();
+		this._cameraProjectionState = new Matrix4();
+		this._fovState = 1;
+		this._upState = new Vector3();
+		this._zoomState = 1;
+		this._nearPos = 0;
+		this._farPos = 0;
+		this._gizmoMatrixState = new Matrix4();
+		//initial values
+		this._up0 = new Vector3();
+		this._zoom0 = 1;
+		this._fov0 = 0;
+		this._initialNear = 0;
+		this._nearPos0 = 0;
+		this._initialFar = 0;
+		this._farPos0 = 0;
+		this._cameraMatrixState0 = new Matrix4();
+		this._gizmoMatrixState0 = new Matrix4();
+		//pointers array
+		this._button = - 1;
+		this._touchStart = [];
+		this._touchCurrent = [];
+		this._input = INPUT.NONE;
+		//two fingers touch interaction
+		this._switchSensibility = 32;	//minimum movement to be performed to fire single pan start after the second finger has been released
+		this._startFingerDistance = 0; //distance between two fingers
+		this._currentFingerDistance = 0;
+		this._startFingerRotation = 0; //amount of rotation performed with two fingers
+		this._currentFingerRotation = 0;
+		//double tap
+		this._devPxRatio = 0;
+		this._downValid = true;
+		this._nclicks = 0;
+		this._downEvents = [];
+		this._downStart = 0;	//pointerDown time
+		this._clickStart = 0;	//first click time
+		this._maxDownTime = 250;
+		this._maxInterval = 300;
+		this._posThreshold = 24;
+		this._movementThreshold = 24;
+		//cursor positions
+		this._currentCursorPosition = new Vector3();
+		this._startCursorPosition = new Vector3();
+		//grid
+		this._grid = null; //grid to be visualized during pan operation
+		this._gridPosition = new Vector3();
+		//gizmos
+		this._gizmos = new Group();
+		this._curvePts = 128;
+		//animations
+		this._timeStart = - 1; //initial time
+		this._animationId = - 1;
+		//focus animation
+		this.focusAnimationTime = 500; //duration of focus animation in ms
+		//rotate animation
+		this._timePrev = 0; //time at which previous rotate operation has been detected
+		this._timeCurrent = 0; //time at which current rotate operation has been detected
+		this._anglePrev = 0; //angle of previous rotation
+		this._angleCurrent = 0; //angle of current rotation
+		this._cursorPosPrev = new Vector3();	//cursor position when previous rotate operation has been detected
+		this._cursorPosCurr = new Vector3();//cursor position when current rotate operation has been detected
+		this._wPrev = 0; //angular velocity of the previous rotate operation
+		this._wCurr = 0; //angular velocity of the current rotate operation
+		//parameters
+		this.adjustNearFar = false;
+		this.scaleFactor = 1.1;	//zoom/distance multiplier
+		this.dampingFactor = 25;
+		this.wMax = 20;	//maximum angular velocity allowed
+		this.enableAnimations = true; //if animations should be performed
+		this.enableGrid = false; //if grid should be showed during pan operation
+		this.cursorZoom = false;	//if wheel zoom should be cursor centered
+		this.minFov = 5;
+		this.maxFov = 90;
+		this.rotateSpeed = 1;
+		this.enablePan = true;
+		this.enableRotate = true;
+		this.enableZoom = true;
+		this.enableGizmos = true;
+		this.enableFocus = true;
+		this.minDistance = 0;
+		this.maxDistance = Infinity;
+		this.minZoom = 0;
+		this.maxZoom = Infinity;
+		//trackball parameters
+		this._tbRadius = 1;
+		//FSA
+		this._state = STATE.IDLE;
+		this.setCamera( camera );
+		if ( this.scene != null ) {
+			this.scene.add( this._gizmos );
+		}
+		this.initializeMouseActions();
+		// event listeners
+		this._onContextMenu = onContextMenu.bind( this );
+		this._onWheel = onWheel.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerCancel = onPointerCancel.bind( this );
+		this._onWindowResize = onWindowResize.bind( this );
+		if ( domElement !== null ) {
+			this.connect();
+		}
+	}
+	connect() {
+		this.domElement.style.touchAction = 'none';
+		this._devPxRatio = window.devicePixelRatio;
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+		this.domElement.addEventListener( 'wheel', this._onWheel );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointercancel', this._onPointerCancel );
+		window.addEventListener( 'resize', this._onWindowResize );
+	}
+	disconnect() {
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.removeEventListener( 'wheel', this._onWheel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+		window.removeEventListener( 'pointermove', this._onPointerMove );
+		window.removeEventListener( 'pointerup', this._onPointerUp );
+		window.removeEventListener( 'resize', this._onWindowResize );
+	}
+	onSinglePanStart( event, operation ) {
+		if ( this.enabled ) {
+			this.dispatchEvent( _startEvent );
+			this.setCenter( event.clientX, event.clientY );
+			switch ( operation ) {
+				case 'PAN':
+					if ( ! this.enablePan ) {
+						return;
+					}
+					if ( this._animationId != - 1 ) {
+						cancelAnimationFrame( this._animationId );
+						this._animationId = - 1;
+						this._timeStart = - 1;
+						this.activateGizmos( false );
+						this.dispatchEvent( _changeEvent );
+					}
+					this.updateTbState( STATE.PAN, true );
+					this._startCursorPosition.copy( this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement ) );
+					if ( this.enableGrid ) {
+						this.drawGrid();
+						this.dispatchEvent( _changeEvent );
+					}
+					break;
+				case 'ROTATE':
+					if ( ! this.enableRotate ) {
+						return;
+					}
+					if ( this._animationId != - 1 ) {
+						cancelAnimationFrame( this._animationId );
+						this._animationId = - 1;
+						this._timeStart = - 1;
+					}
+					this.updateTbState( STATE.ROTATE, true );
+					this._startCursorPosition.copy( this.unprojectOnTbSurface( this.object, _center.x, _center.y, this.domElement, this._tbRadius ) );
+					this.activateGizmos( true );
+					if ( this.enableAnimations ) {
+						this._timePrev = this._timeCurrent = performance.now();
+						this._angleCurrent = this._anglePrev = 0;
+						this._cursorPosPrev.copy( this._startCursorPosition );
+						this._cursorPosCurr.copy( this._cursorPosPrev );
+						this._wCurr = 0;
+						this._wPrev = this._wCurr;
+					}
+					this.dispatchEvent( _changeEvent );
+					break;
+				case 'FOV':
+					if ( ! this.object.isPerspectiveCamera || ! this.enableZoom ) {
+						return;
+					}
+					if ( this._animationId != - 1 ) {
+						cancelAnimationFrame( this._animationId );
+						this._animationId = - 1;
+						this._timeStart = - 1;
+						this.activateGizmos( false );
+						this.dispatchEvent( _changeEvent );
+					}
+					this.updateTbState( STATE.FOV, true );
+					this._startCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+					this._currentCursorPosition.copy( this._startCursorPosition );
+					break;
+				case 'ZOOM':
+					if ( ! this.enableZoom ) {
+						return;
+					}
+					if ( this._animationId != - 1 ) {
+						cancelAnimationFrame( this._animationId );
+						this._animationId = - 1;
+						this._timeStart = - 1;
+						this.activateGizmos( false );
+						this.dispatchEvent( _changeEvent );
+					}
+					this.updateTbState( STATE.SCALE, true );
+					this._startCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+					this._currentCursorPosition.copy( this._startCursorPosition );
+					break;
+			}
+		}
+	}
+	onSinglePanMove( event, opState ) {
+		if ( this.enabled ) {
+			const restart = opState != this._state;
+			this.setCenter( event.clientX, event.clientY );
+			switch ( opState ) {
+				case STATE.PAN:
+					if ( this.enablePan ) {
+						if ( restart ) {
+							//switch to pan operation
+							this.dispatchEvent( _endEvent );
+							this.dispatchEvent( _startEvent );
+							this.updateTbState( opState, true );
+							this._startCursorPosition.copy( this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement ) );
+							if ( this.enableGrid ) {
+								this.drawGrid();
+							}
+							this.activateGizmos( false );
+						} else {
+							//continue with pan operation
+							this._currentCursorPosition.copy( this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement ) );
+							this.applyTransformMatrix( this.pan( this._startCursorPosition, this._currentCursorPosition ) );
+						}
+					}
+					break;
+				case STATE.ROTATE:
+					if ( this.enableRotate ) {
+						if ( restart ) {
+							//switch to rotate operation
+							this.dispatchEvent( _endEvent );
+							this.dispatchEvent( _startEvent );
+							this.updateTbState( opState, true );
+							this._startCursorPosition.copy( this.unprojectOnTbSurface( this.object, _center.x, _center.y, this.domElement, this._tbRadius ) );
+							if ( this.enableGrid ) {
+								this.disposeGrid();
+							}
+							this.activateGizmos( true );
+						} else {
+							//continue with rotate operation
+							this._currentCursorPosition.copy( this.unprojectOnTbSurface( this.object, _center.x, _center.y, this.domElement, this._tbRadius ) );
+							const distance = this._startCursorPosition.distanceTo( this._currentCursorPosition );
+							const angle = this._startCursorPosition.angleTo( this._currentCursorPosition );
+							const amount = Math.max( distance / this._tbRadius, angle ) * this.rotateSpeed; //effective rotation angle
+							this.applyTransformMatrix( this.rotate( this.calculateRotationAxis( this._startCursorPosition, this._currentCursorPosition ), amount ) );
+							if ( this.enableAnimations ) {
+								this._timePrev = this._timeCurrent;
+								this._timeCurrent = performance.now();
+								this._anglePrev = this._angleCurrent;
+								this._angleCurrent = amount;
+								this._cursorPosPrev.copy( this._cursorPosCurr );
+								this._cursorPosCurr.copy( this._currentCursorPosition );
+								this._wPrev = this._wCurr;
+								this._wCurr = this.calculateAngularSpeed( this._anglePrev, this._angleCurrent, this._timePrev, this._timeCurrent );
+							}
+						}
+					}
+					break;
+				case STATE.SCALE:
+					if ( this.enableZoom ) {
+						if ( restart ) {
+							//switch to zoom operation
+							this.dispatchEvent( _endEvent );
+							this.dispatchEvent( _startEvent );
+							this.updateTbState( opState, true );
+							this._startCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+							this._currentCursorPosition.copy( this._startCursorPosition );
+							if ( this.enableGrid ) {
+								this.disposeGrid();
+							}
+							this.activateGizmos( false );
+						} else {
+							//continue with zoom operation
+							const screenNotches = 8;	//how many wheel notches corresponds to a full screen pan
+							this._currentCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+							const movement = this._currentCursorPosition.y - this._startCursorPosition.y;
+							let size = 1;
+							if ( movement < 0 ) {
+								size = 1 / ( Math.pow( this.scaleFactor, - movement * screenNotches ) );
+							} else if ( movement > 0 ) {
+								size = Math.pow( this.scaleFactor, movement * screenNotches );
+							}
+							this._v3_1.setFromMatrixPosition( this._gizmoMatrixState );
+							this.applyTransformMatrix( this.scale( size, this._v3_1 ) );
+						}
+					}
+					break;
+				case STATE.FOV:
+					if ( this.enableZoom && this.object.isPerspectiveCamera ) {
+						if ( restart ) {
+							//switch to fov operation
+							this.dispatchEvent( _endEvent );
+							this.dispatchEvent( _startEvent );
+							this.updateTbState( opState, true );
+							this._startCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+							this._currentCursorPosition.copy( this._startCursorPosition );
+							if ( this.enableGrid ) {
+								this.disposeGrid();
+							}
+							this.activateGizmos( false );
+						} else {
+							//continue with fov operation
+							const screenNotches = 8;	//how many wheel notches corresponds to a full screen pan
+							this._currentCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+							const movement = this._currentCursorPosition.y - this._startCursorPosition.y;
+							let size = 1;
+							if ( movement < 0 ) {
+								size = 1 / ( Math.pow( this.scaleFactor, - movement * screenNotches ) );
+							} else if ( movement > 0 ) {
+								size = Math.pow( this.scaleFactor, movement * screenNotches );
+							}
+							this._v3_1.setFromMatrixPosition( this._cameraMatrixState );
+							const x = this._v3_1.distanceTo( this._gizmos.position );
+							let xNew = x / size; //distance between camera and gizmos if scale(size, scalepoint) would be performed
+							//check min and max distance
+							xNew = MathUtils.clamp( xNew, this.minDistance, this.maxDistance );
+							const y = x * Math.tan( MathUtils.DEG2RAD * this._fovState * 0.5 );
+							//calculate new fov
+							let newFov = MathUtils.RAD2DEG * ( Math.atan( y / xNew ) * 2 );
+							//check min and max fov
+							newFov = MathUtils.clamp( newFov, this.minFov, this.maxFov );
+							const newDistance = y / Math.tan( MathUtils.DEG2RAD * ( newFov / 2 ) );
+							size = x / newDistance;
+							this._v3_2.setFromMatrixPosition( this._gizmoMatrixState );
+							this.setFov( newFov );
+							this.applyTransformMatrix( this.scale( size, this._v3_2, false ) );
+							//adjusting distance
+							_offset.copy( this._gizmos.position ).sub( this.object.position ).normalize().multiplyScalar( newDistance / x );
+							this._m4_1.makeTranslation( _offset.x, _offset.y, _offset.z );
+						}
+					}
+					break;
+			}
+			this.dispatchEvent( _changeEvent );
+		}
+	}
+	onSinglePanEnd() {
+		if ( this._state == STATE.ROTATE ) {
+			if ( ! this.enableRotate ) {
+				return;
+			}
+			if ( this.enableAnimations ) {
+				//perform rotation animation
+				const deltaTime = ( performance.now() - this._timeCurrent );
+				if ( deltaTime < 120 ) {
+					const w = Math.abs( ( this._wPrev + this._wCurr ) / 2 );
+					const self = this;
+					this._animationId = window.requestAnimationFrame( function ( t ) {
+						self.updateTbState( STATE.ANIMATION_ROTATE, true );
+						const rotationAxis = self.calculateRotationAxis( self._cursorPosPrev, self._cursorPosCurr );
+						self.onRotationAnim( t, rotationAxis, Math.min( w, self.wMax ) );
+					} );
+				} else {
+					//cursor has been standing still for over 120 ms since last movement
+					this.updateTbState( STATE.IDLE, false );
+					this.activateGizmos( false );
+					this.dispatchEvent( _changeEvent );
+				}
+			} else {
+				this.updateTbState( STATE.IDLE, false );
+				this.activateGizmos( false );
+				this.dispatchEvent( _changeEvent );
+			}
+		} else if ( this._state == STATE.PAN || this._state == STATE.IDLE ) {
+			this.updateTbState( STATE.IDLE, false );
+			if ( this.enableGrid ) {
+				this.disposeGrid();
+			}
+			this.activateGizmos( false );
+			this.dispatchEvent( _changeEvent );
+		}
+		this.dispatchEvent( _endEvent );
+	}
+	onDoubleTap( event ) {
+		if ( this.enabled && this.enablePan && this.enableFocus && this.scene != null ) {
+			this.dispatchEvent( _startEvent );
+			this.setCenter( event.clientX, event.clientY );
+			const hitP = this.unprojectOnObj( this.getCursorNDC( _center.x, _center.y, this.domElement ), this.object );
+			if ( hitP != null && this.enableAnimations ) {
+				const self = this;
+				if ( this._animationId != - 1 ) {
+					window.cancelAnimationFrame( this._animationId );
+				}
+				this._timeStart = - 1;
+				this._animationId = window.requestAnimationFrame( function ( t ) {
+					self.updateTbState( STATE.ANIMATION_FOCUS, true );
+					self.onFocusAnim( t, hitP, self._cameraMatrixState, self._gizmoMatrixState );
+				} );
+			} else if ( hitP != null && ! this.enableAnimations ) {
+				this.updateTbState( STATE.FOCUS, true );
+				this.focus( hitP, this.scaleFactor );
+				this.updateTbState( STATE.IDLE, false );
+				this.dispatchEvent( _changeEvent );
+			}
+		}
+		this.dispatchEvent( _endEvent );
+	}
+	onDoublePanStart() {
+		if ( this.enabled && this.enablePan ) {
+			this.dispatchEvent( _startEvent );
+			this.updateTbState( STATE.PAN, true );
+			this.setCenter( ( this._touchCurrent[ 0 ].clientX + this._touchCurrent[ 1 ].clientX ) / 2, ( this._touchCurrent[ 0 ].clientY + this._touchCurrent[ 1 ].clientY ) / 2 );
+			this._startCursorPosition.copy( this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement, true ) );
+			this._currentCursorPosition.copy( this._startCursorPosition );
+			this.activateGizmos( false );
+		}
+	}
+	onDoublePanMove() {
+		if ( this.enabled && this.enablePan ) {
+			this.setCenter( ( this._touchCurrent[ 0 ].clientX + this._touchCurrent[ 1 ].clientX ) / 2, ( this._touchCurrent[ 0 ].clientY + this._touchCurrent[ 1 ].clientY ) / 2 );
+			if ( this._state != STATE.PAN ) {
+				this.updateTbState( STATE.PAN, true );
+				this._startCursorPosition.copy( this._currentCursorPosition );
+			}
+			this._currentCursorPosition.copy( this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement, true ) );
+			this.applyTransformMatrix( this.pan( this._startCursorPosition, this._currentCursorPosition, true ) );
+			this.dispatchEvent( _changeEvent );
+		}
+	}
+	onDoublePanEnd() {
+		this.updateTbState( STATE.IDLE, false );
+		this.dispatchEvent( _endEvent );
+	}
+	onRotateStart() {
+		if ( this.enabled && this.enableRotate ) {
+			this.dispatchEvent( _startEvent );
+			this.updateTbState( STATE.ZROTATE, true );
+			//this._startFingerRotation = event.rotation;
+			this._startFingerRotation = this.getAngle( this._touchCurrent[ 1 ], this._touchCurrent[ 0 ] ) + this.getAngle( this._touchStart[ 1 ], this._touchStart[ 0 ] );
+			this._currentFingerRotation = this._startFingerRotation;
+			this.object.getWorldDirection( this._rotationAxis ); //rotation axis
+			if ( ! this.enablePan && ! this.enableZoom ) {
+				this.activateGizmos( true );
+			}
+		}
+	}
+	onRotateMove() {
+		if ( this.enabled && this.enableRotate ) {
+			this.setCenter( ( this._touchCurrent[ 0 ].clientX + this._touchCurrent[ 1 ].clientX ) / 2, ( this._touchCurrent[ 0 ].clientY + this._touchCurrent[ 1 ].clientY ) / 2 );
+			let rotationPoint;
+			if ( this._state != STATE.ZROTATE ) {
+				this.updateTbState( STATE.ZROTATE, true );
+				this._startFingerRotation = this._currentFingerRotation;
+			}
+			//this._currentFingerRotation = event.rotation;
+			this._currentFingerRotation = this.getAngle( this._touchCurrent[ 1 ], this._touchCurrent[ 0 ] ) + this.getAngle( this._touchStart[ 1 ], this._touchStart[ 0 ] );
+			if ( ! this.enablePan ) {
+				rotationPoint = new Vector3().setFromMatrixPosition( this._gizmoMatrixState );
+			} else {
+				this._v3_2.setFromMatrixPosition( this._gizmoMatrixState );
+				rotationPoint = this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement ).applyQuaternion( this.object.quaternion ).multiplyScalar( 1 / this.object.zoom ).add( this._v3_2 );
+			}
+			const amount = MathUtils.DEG2RAD * ( this._startFingerRotation - this._currentFingerRotation );
+			this.applyTransformMatrix( this.zRotate( rotationPoint, amount ) );
+			this.dispatchEvent( _changeEvent );
+		}
+	}
+	onRotateEnd() {
+		this.updateTbState( STATE.IDLE, false );
+		this.activateGizmos( false );
+		this.dispatchEvent( _endEvent );
+	}
+	onPinchStart() {
+		if ( this.enabled && this.enableZoom ) {
+			this.dispatchEvent( _startEvent );
+			this.updateTbState( STATE.SCALE, true );
+			this._startFingerDistance = this.calculatePointersDistance( this._touchCurrent[ 0 ], this._touchCurrent[ 1 ] );
+			this._currentFingerDistance = this._startFingerDistance;
+			this.activateGizmos( false );
+		}
+	}
+	onPinchMove() {
+		if ( this.enabled && this.enableZoom ) {
+			this.setCenter( ( this._touchCurrent[ 0 ].clientX + this._touchCurrent[ 1 ].clientX ) / 2, ( this._touchCurrent[ 0 ].clientY + this._touchCurrent[ 1 ].clientY ) / 2 );
+			const minDistance = 12; //minimum distance between fingers (in css pixels)
+			if ( this._state != STATE.SCALE ) {
+				this._startFingerDistance = this._currentFingerDistance;
+				this.updateTbState( STATE.SCALE, true );
+			}
+			this._currentFingerDistance = Math.max( this.calculatePointersDistance( this._touchCurrent[ 0 ], this._touchCurrent[ 1 ] ), minDistance * this._devPxRatio );
+			const amount = this._currentFingerDistance / this._startFingerDistance;
+			let scalePoint;
+			if ( ! this.enablePan ) {
+				scalePoint = this._gizmos.position;
+			} else {
+				if ( this.object.isOrthographicCamera ) {
+					scalePoint = this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement )
+						.applyQuaternion( this.object.quaternion )
+						.multiplyScalar( 1 / this.object.zoom )
+						.add( this._gizmos.position );
+				} else if ( this.object.isPerspectiveCamera ) {
+					scalePoint = this.unprojectOnTbPlane( this.object, _center.x, _center.y, this.domElement )
+						.applyQuaternion( this.object.quaternion )
+						.add( this._gizmos.position );
+				}
+			}
+			this.applyTransformMatrix( this.scale( amount, scalePoint ) );
+			this.dispatchEvent( _changeEvent );
+		}
+	}
+	onPinchEnd() {
+		this.updateTbState( STATE.IDLE, false );
+		this.dispatchEvent( _endEvent );
+	}
+	onTriplePanStart() {
+		if ( this.enabled && this.enableZoom ) {
+			this.dispatchEvent( _startEvent );
+			this.updateTbState( STATE.SCALE, true );
+			//const center = event.center;
+			let clientX = 0;
+			let clientY = 0;
+			const nFingers = this._touchCurrent.length;
+			for ( let i = 0; i < nFingers; i ++ ) {
+				clientX += this._touchCurrent[ i ].clientX;
+				clientY += this._touchCurrent[ i ].clientY;
+			}
+			this.setCenter( clientX / nFingers, clientY / nFingers );
+			this._startCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+			this._currentCursorPosition.copy( this._startCursorPosition );
+		}
+	}
+	onTriplePanMove() {
+		if ( this.enabled && this.enableZoom ) {
+			//	  fov / 2
+			//		|\
+			//		| \
+			//		|  \
+			//	x	|	\
+			//		| 	 \
+			//		| 	  \
+			//		| _ _ _\
+			//			y
+			//const center = event.center;
+			let clientX = 0;
+			let clientY = 0;
+			const nFingers = this._touchCurrent.length;
+			for ( let i = 0; i < nFingers; i ++ ) {
+				clientX += this._touchCurrent[ i ].clientX;
+				clientY += this._touchCurrent[ i ].clientY;
+			}
+			this.setCenter( clientX / nFingers, clientY / nFingers );
+			const screenNotches = 8;	//how many wheel notches corresponds to a full screen pan
+			this._currentCursorPosition.setY( this.getCursorNDC( _center.x, _center.y, this.domElement ).y * 0.5 );
+			const movement = this._currentCursorPosition.y - this._startCursorPosition.y;
+			let size = 1;
+			if ( movement < 0 ) {
+				size = 1 / ( Math.pow( this.scaleFactor, - movement * screenNotches ) );
+			} else if ( movement > 0 ) {
+				size = Math.pow( this.scaleFactor, movement * screenNotches );
+			}
+			this._v3_1.setFromMatrixPosition( this._cameraMatrixState );
+			const x = this._v3_1.distanceTo( this._gizmos.position );
+			let xNew = x / size; //distance between camera and gizmos if scale(size, scalepoint) would be performed
+			//check min and max distance
+			xNew = MathUtils.clamp( xNew, this.minDistance, this.maxDistance );
+			const y = x * Math.tan( MathUtils.DEG2RAD * this._fovState * 0.5 );
+			//calculate new fov
+			let newFov = MathUtils.RAD2DEG * ( Math.atan( y / xNew ) * 2 );
+			//check min and max fov
+			newFov = MathUtils.clamp( newFov, this.minFov, this.maxFov );
+			const newDistance = y / Math.tan( MathUtils.DEG2RAD * ( newFov / 2 ) );
+			size = x / newDistance;
+			this._v3_2.setFromMatrixPosition( this._gizmoMatrixState );
+			this.setFov( newFov );
+			this.applyTransformMatrix( this.scale( size, this._v3_2, false ) );
+			//adjusting distance
+			_offset.copy( this._gizmos.position ).sub( this.object.position ).normalize().multiplyScalar( newDistance / x );
+			this._m4_1.makeTranslation( _offset.x, _offset.y, _offset.z );
+			this.dispatchEvent( _changeEvent );
+		}
+	}
+	onTriplePanEnd() {
+		this.updateTbState( STATE.IDLE, false );
+		this.dispatchEvent( _endEvent );
+		//this.dispatchEvent( _changeEvent );
+	}
+	/**
+	 * Set _center's x/y coordinates
+	 * @param {Number} clientX
+	 * @param {Number} clientY
+	 */
+	setCenter( clientX, clientY ) {
+		_center.x = clientX;
+		_center.y = clientY;
+	}
+	/**
+	 * Set default mouse actions
+	 */
+	initializeMouseActions() {
+		this.setMouseAction( 'PAN', 0, 'CTRL' );
+		this.setMouseAction( 'PAN', 2 );
+		this.setMouseAction( 'ROTATE', 0 );
+		this.setMouseAction( 'ZOOM', 'WHEEL' );
+		this.setMouseAction( 'ZOOM', 1 );
+		this.setMouseAction( 'FOV', 'WHEEL', 'SHIFT' );
+		this.setMouseAction( 'FOV', 1, 'SHIFT' );
+	}
+	/**
+	 * Compare two mouse actions
+	 * @param {Object} action1
+	 * @param {Object} action2
+	 * @returns {Boolean} True if action1 and action 2 are the same mouse action, false otherwise
+	 */
+	compareMouseAction( action1, action2 ) {
+		if ( action1.operation == action2.operation ) {
+			if ( action1.mouse == action2.mouse && action1.key == action2.key ) {
+				return true;
+			} else {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+	/**
+	 * Set a new mouse action by specifying the operation to be performed and a mouse/key combination. In case of conflict, replaces the existing one
+	 * @param {String} operation The operation to be performed ('PAN', 'ROTATE', 'ZOOM', 'FOV)
+	 * @param {*} mouse A mouse button (0, 1, 2) or 'WHEEL' for wheel notches
+	 * @param {*} key The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed
+	 * @returns {Boolean} True if the mouse action has been successfully added, false otherwise
+	 */
+	setMouseAction( operation, mouse, key = null ) {
+		const operationInput = [ 'PAN', 'ROTATE', 'ZOOM', 'FOV' ];
+		const mouseInput = [ 0, 1, 2, 'WHEEL' ];
+		const keyInput = [ 'CTRL', 'SHIFT', null ];
+		let state;
+		if ( ! operationInput.includes( operation ) || ! mouseInput.includes( mouse ) || ! keyInput.includes( key ) ) {
+			//invalid parameters
+			return false;
+		}
+		if ( mouse == 'WHEEL' ) {
+			if ( operation != 'ZOOM' && operation != 'FOV' ) {
+				//cannot associate 2D operation to 1D input
+				return false;
+			}
+		}
+		switch ( operation ) {
+			case 'PAN':
+				state = STATE.PAN;
+				break;
+			case 'ROTATE':
+				state = STATE.ROTATE;
+				break;
+			case 'ZOOM':
+				state = STATE.SCALE;
+				break;
+			case 'FOV':
+				state = STATE.FOV;
+				break;
+		}
+		const action = {
+			operation: operation,
+			mouse: mouse,
+			key: key,
+			state: state
+		};
+		for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+			if ( this.mouseActions[ i ].mouse == action.mouse && this.mouseActions[ i ].key == action.key ) {
+				this.mouseActions.splice( i, 1, action );
+				return true;
+			}
+		}
+		this.mouseActions.push( action );
+		return true;
+	}
+	/**
+	 * Remove a mouse action by specifying its mouse/key combination
+	 * @param {*} mouse A mouse button (0, 1, 2) or 'WHEEL' for wheel notches
+	 * @param {*} key The keyboard modifier ('CTRL', 'SHIFT') or null if key is not needed
+	 * @returns {Boolean} True if the operation has been successfully removed, false otherwise
+	 */
+	unsetMouseAction( mouse, key = null ) {
+		for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+			if ( this.mouseActions[ i ].mouse == mouse && this.mouseActions[ i ].key == key ) {
+				this.mouseActions.splice( i, 1 );
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	 * Return the operation associated to a mouse/keyboard combination
+	 * @param {0|1|2|'WHEEL'} mouse Mouse button index (0, 1, 2) or 'WHEEL' for wheel notches
+	 * @param {'CTRL'|'SHIFT'|null} key Keyboard modifier
+	 * @returns {string|null} The operation if it has been found, null otherwise
+	 */
+	getOpFromAction( mouse, key ) {
+		let action;
+		for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+			action = this.mouseActions[ i ];
+			if ( action.mouse == mouse && action.key == key ) {
+				return action.operation;
+			}
+		}
+		if ( key != null ) {
+			for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+				action = this.mouseActions[ i ];
+				if ( action.mouse == mouse && action.key == null ) {
+					return action.operation;
+				}
+			}
+		}
+		return null;
+	}
+	/**
+	 * Get the operation associated to mouse and key combination and returns the corresponding FSA state
+	 * @param {0|1|2} mouse Mouse button index (0, 1, 2)
+	 * @param {'CTRL'|'SHIFT'|null} key Keyboard modifier
+	 * @returns {STATE|null} The FSA state obtained from the operation associated to mouse/keyboard combination
+	 */
+	getOpStateFromAction( mouse, key ) {
+		let action;
+		for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+			action = this.mouseActions[ i ];
+			if ( action.mouse == mouse && action.key == key ) {
+				return action.state;
+			}
+		}
+		if ( key != null ) {
+			for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+				action = this.mouseActions[ i ];
+				if ( action.mouse == mouse && action.key == null ) {
+					return action.state;
+				}
+			}
+		}
+		return null;
+	}
+	/**
+	 * Calculate the angle between two pointers
+	 * @param {PointerEvent} p1
+	 * @param {PointerEvent} p2
+	 * @returns {Number} The angle between two pointers in degrees
+	 */
+	getAngle( p1, p2 ) {
+		return Math.atan2( p2.clientY - p1.clientY, p2.clientX - p1.clientX ) * 180 / Math.PI;
+	}
+	/**
+	 * Update a PointerEvent inside current pointerevents array
+	 * @param {PointerEvent} event
+	 */
+	updateTouchEvent( event ) {
+		for ( let i = 0; i < this._touchCurrent.length; i ++ ) {
+			if ( this._touchCurrent[ i ].pointerId == event.pointerId ) {
+				this._touchCurrent.splice( i, 1, event );
+				break;
+			}
+		}
+	}
+	/**
+	 * Apply a transformation matrix, to the camera and gizmos
+	 * @param {Object} transformation Object containing matrices to apply to camera and gizmos
+	 */
+	applyTransformMatrix( transformation ) {
+		if ( transformation.camera != null ) {
+			this._m4_1.copy( this._cameraMatrixState ).premultiply( transformation.camera );
+			this._m4_1.decompose( this.object.position, this.object.quaternion, this.object.scale );
+			this.object.updateMatrix();
+			//update camera up vector
+			if ( this._state == STATE.ROTATE || this._state == STATE.ZROTATE || this._state == STATE.ANIMATION_ROTATE ) {
+				this.object.up.copy( this._upState ).applyQuaternion( this.object.quaternion );
+			}
+		}
+		if ( transformation.gizmos != null ) {
+			this._m4_1.copy( this._gizmoMatrixState ).premultiply( transformation.gizmos );
+			this._m4_1.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+			this._gizmos.updateMatrix();
+		}
+		if ( this._state == STATE.SCALE || this._state == STATE.FOCUS || this._state == STATE.ANIMATION_FOCUS ) {
+			this._tbRadius = this.calculateTbRadius( this.object );
+			if ( this.adjustNearFar ) {
+				const cameraDistance = this.object.position.distanceTo( this._gizmos.position );
+				const bb = new Box3();
+				bb.setFromObject( this._gizmos );
+				const sphere = new Sphere();
+				bb.getBoundingSphere( sphere );
+				const adjustedNearPosition = Math.max( this._nearPos0, sphere.radius + sphere.center.length() );
+				const regularNearPosition = cameraDistance - this._initialNear;
+				const minNearPos = Math.min( adjustedNearPosition, regularNearPosition );
+				this.object.near = cameraDistance - minNearPos;
+				const adjustedFarPosition = Math.min( this._farPos0, - sphere.radius + sphere.center.length() );
+				const regularFarPosition = cameraDistance - this._initialFar;
+				const minFarPos = Math.min( adjustedFarPosition, regularFarPosition );
+				this.object.far = cameraDistance - minFarPos;
+				this.object.updateProjectionMatrix();
+			} else {
+				let update = false;
+				if ( this.object.near != this._initialNear ) {
+					this.object.near = this._initialNear;
+					update = true;
+				}
+				if ( this.object.far != this._initialFar ) {
+					this.object.far = this._initialFar;
+					update = true;
+				}
+				if ( update ) {
+					this.object.updateProjectionMatrix();
+				}
+			}
+		}
+	}
+	/**
+	 * Calculate the angular speed
+	 *
+	 * @param {Number} p0 Position at t0
+	 * @param {Number} p1 Position at t1
+	 * @param {Number} t0 Initial time in milliseconds
+	 * @param {Number} t1 Ending time in milliseconds
+	 * @returns {Number}
+	 */
+	calculateAngularSpeed( p0, p1, t0, t1 ) {
+		const s = p1 - p0;
+		const t = ( t1 - t0 ) / 1000;
+		if ( t == 0 ) {
+			return 0;
+		}
+		return s / t;
+	}
+	/**
+	 * Calculate the distance between two pointers
+	 * @param {PointerEvent} p0 The first pointer
+	 * @param {PointerEvent} p1 The second pointer
+	 * @returns {number} The distance between the two pointers
+	 */
+	calculatePointersDistance( p0, p1 ) {
+		return Math.sqrt( Math.pow( p1.clientX - p0.clientX, 2 ) + Math.pow( p1.clientY - p0.clientY, 2 ) );
+	}
+	/**
+	 * Calculate the rotation axis as the vector perpendicular between two vectors
+	 * @param {Vector3} vec1 The first vector
+	 * @param {Vector3} vec2 The second vector
+	 * @returns {Vector3} The normalized rotation axis
+	 */
+	calculateRotationAxis( vec1, vec2 ) {
+		this._rotationMatrix.extractRotation( this._cameraMatrixState );
+		this._quat.setFromRotationMatrix( this._rotationMatrix );
+		this._rotationAxis.crossVectors( vec1, vec2 ).applyQuaternion( this._quat );
+		return this._rotationAxis.normalize().clone();
+	}
+	/**
+	 * Calculate the trackball radius so that gizmo's diameter will be 2/3 of the minimum side of the camera frustum
+	 * @param {Camera} camera
+	 * @returns {Number} The trackball radius
+	 */
+	calculateTbRadius( camera ) {
+		const distance = camera.position.distanceTo( this._gizmos.position );
+		if ( camera.type == 'PerspectiveCamera' ) {
+			const halfFovV = MathUtils.DEG2RAD * camera.fov * 0.5; //vertical fov/2 in radians
+			const halfFovH = Math.atan( ( camera.aspect ) * Math.tan( halfFovV ) ); //horizontal fov/2 in radians
+			return Math.tan( Math.min( halfFovV, halfFovH ) ) * distance * this.radiusFactor;
+		} else if ( camera.type == 'OrthographicCamera' ) {
+			return Math.min( camera.top, camera.right ) * this.radiusFactor;
+		}
+	}
+	/**
+	 * Focus operation consist of positioning the point of interest in front of the camera and a slightly zoom in
+	 * @param {Vector3} point The point of interest
+	 * @param {Number} size Scale factor
+	 * @param {Number} amount Amount of operation to be completed (used for focus animations, default is complete full operation)
+	 */
+	focus( point, size, amount = 1 ) {
+		//move center of camera (along with gizmos) towards point of interest
+		_offset.copy( point ).sub( this._gizmos.position ).multiplyScalar( amount );
+		this._translationMatrix.makeTranslation( _offset.x, _offset.y, _offset.z );
+		_gizmoMatrixStateTemp.copy( this._gizmoMatrixState );
+		this._gizmoMatrixState.premultiply( this._translationMatrix );
+		this._gizmoMatrixState.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+		_cameraMatrixStateTemp.copy( this._cameraMatrixState );
+		this._cameraMatrixState.premultiply( this._translationMatrix );
+		this._cameraMatrixState.decompose( this.object.position, this.object.quaternion, this.object.scale );
+		//apply zoom
+		if ( this.enableZoom ) {
+			this.applyTransformMatrix( this.scale( size, this._gizmos.position ) );
+		}
+		this._gizmoMatrixState.copy( _gizmoMatrixStateTemp );
+		this._cameraMatrixState.copy( _cameraMatrixStateTemp );
+	}
+	/**
+	 * Draw a grid and add it to the scene
+	 */
+	drawGrid() {
+		if ( this.scene != null ) {
+			const color = 0x888888;
+			const multiplier = 3;
+			let size, divisions, maxLength, tick;
+			if ( this.object.isOrthographicCamera ) {
+				const width = this.object.right - this.object.left;
+				const height = this.object.bottom - this.object.top;
+				maxLength = Math.max( width, height );
+				tick = maxLength / 20;
+				size = maxLength / this.object.zoom * multiplier;
+				divisions = size / tick * this.object.zoom;
+			} else if ( this.object.isPerspectiveCamera ) {
+				const distance = this.object.position.distanceTo( this._gizmos.position );
+				const halfFovV = MathUtils.DEG2RAD * this.object.fov * 0.5;
+				const halfFovH = Math.atan( ( this.object.aspect ) * Math.tan( halfFovV ) );
+				maxLength = Math.tan( Math.max( halfFovV, halfFovH ) ) * distance * 2;
+				tick = maxLength / 20;
+				size = maxLength * multiplier;
+				divisions = size / tick;
+			}
+			if ( this._grid == null ) {
+				this._grid = new GridHelper( size, divisions, color, color );
+				this._grid.position.copy( this._gizmos.position );
+				this._gridPosition.copy( this._grid.position );
+				this._grid.quaternion.copy( this.object.quaternion );
+				this._grid.rotateX( Math.PI * 0.5 );
+				this.scene.add( this._grid );
+			}
+		}
+	}
+	/**
+	 * Remove all listeners, stop animations and clean scene
+	 */
+	dispose() {
+		if ( this._animationId != - 1 ) {
+			window.cancelAnimationFrame( this._animationId );
+		}
+		this.disconnect();
+		if ( this.scene !== null ) this.scene.remove( this._gizmos );
+		this.disposeGrid();
+	}
+	/**
+	 * remove the grid from the scene
+	 */
+	disposeGrid() {
+		if ( this._grid != null && this.scene != null ) {
+			this.scene.remove( this._grid );
+			this._grid = null;
+		}
+	}
+	/**
+	 * Compute the easing out cubic function for ease out effect in animation
+	 * @param {Number} t The absolute progress of the animation in the bound of 0 (beginning of the) and 1 (ending of animation)
+	 * @returns {Number} Result of easing out cubic at time t
+	 */
+	easeOutCubic( t ) {
+		return 1 - Math.pow( 1 - t, 3 );
+	}
+	/**
+	 * Make rotation gizmos more or less visible
+	 * @param {Boolean} isActive If true, make gizmos more visible
+	 */
+	activateGizmos( isActive ) {
+		const gizmoX = this._gizmos.children[ 0 ];
+		const gizmoY = this._gizmos.children[ 1 ];
+		const gizmoZ = this._gizmos.children[ 2 ];
+		if ( isActive ) {
+			gizmoX.material.setValues( { opacity: 1 } );
+			gizmoY.material.setValues( { opacity: 1 } );
+			gizmoZ.material.setValues( { opacity: 1 } );
+		} else {
+			gizmoX.material.setValues( { opacity: 0.6 } );
+			gizmoY.material.setValues( { opacity: 0.6 } );
+			gizmoZ.material.setValues( { opacity: 0.6 } );
+		}
+	}
+	/**
+	 * Calculate the cursor position in NDC
+	 *
+	 * @param {number} cursorX Cursor horizontal coordinate within the canvas
+	 * @param {number} cursorY Cursor vertical coordinate within the canvas
+	 * @param {HTMLElement} canvas The canvas where the renderer draws its output
+	 * @returns {Vector2} Cursor normalized position inside the canvas
+	 */
+	getCursorNDC( cursorX, cursorY, canvas ) {
+		const canvasRect = canvas.getBoundingClientRect();
+		this._v2_1.setX( ( ( cursorX - canvasRect.left ) / canvasRect.width ) * 2 - 1 );
+		this._v2_1.setY( ( ( canvasRect.bottom - cursorY ) / canvasRect.height ) * 2 - 1 );
+		return this._v2_1.clone();
+	}
+	/**
+	 * Calculate the cursor position inside the canvas x/y coordinates with the origin being in the center of the canvas
+	 *
+	 * @param {Number} cursorX Cursor horizontal coordinate within the canvas
+	 * @param {Number} cursorY Cursor vertical coordinate within the canvas
+	 * @param {HTMLElement} canvas The canvas where the renderer draws its output
+	 * @returns {Vector2} Cursor position inside the canvas
+	 */
+	getCursorPosition( cursorX, cursorY, canvas ) {
+		this._v2_1.copy( this.getCursorNDC( cursorX, cursorY, canvas ) );
+		this._v2_1.x *= ( this.object.right - this.object.left ) * 0.5;
+		this._v2_1.y *= ( this.object.top - this.object.bottom ) * 0.5;
+		return this._v2_1.clone();
+	}
+	/**
+	 * Set the camera to be controlled
+	 * @param {Camera} camera The virtual camera to be controlled
+	 */
+	setCamera( camera ) {
+		camera.lookAt( this.target );
+		camera.updateMatrix();
+		//setting state
+		if ( camera.type == 'PerspectiveCamera' ) {
+			this._fov0 = camera.fov;
+			this._fovState = camera.fov;
+		}
+		this._cameraMatrixState0.copy( camera.matrix );
+		this._cameraMatrixState.copy( this._cameraMatrixState0 );
+		this._cameraProjectionState.copy( camera.projectionMatrix );
+		this._zoom0 = camera.zoom;
+		this._zoomState = this._zoom0;
+		this._initialNear = camera.near;
+		this._nearPos0 = camera.position.distanceTo( this.target ) - camera.near;
+		this._nearPos = this._initialNear;
+		this._initialFar = camera.far;
+		this._farPos0 = camera.position.distanceTo( this.target ) - camera.far;
+		this._farPos = this._initialFar;
+		this._up0.copy( camera.up );
+		this._upState.copy( camera.up );
+		this.object = camera;
+		this.object.updateProjectionMatrix();
+		//making gizmos
+		this._tbRadius = this.calculateTbRadius( camera );
+		this.makeGizmos( this.target, this._tbRadius );
+	}
+	/**
+	 * Set gizmos visibility
+	 * @param {Boolean} value Value of gizmos visibility
+	 */
+	setGizmosVisible( value ) {
+		this._gizmos.visible = value;
+		this.dispatchEvent( _changeEvent );
+	}
+	/**
+	 * Set gizmos radius factor and redraws gizmos
+	 * @param {Float} value Value of radius factor
+	 */
+	setTbRadius( value ) {
+		this.radiusFactor = value;
+		this._tbRadius = this.calculateTbRadius( this.object );
+		const curve = new EllipseCurve( 0, 0, this._tbRadius, this._tbRadius );
+		const points = curve.getPoints( this._curvePts );
+		const curveGeometry = new BufferGeometry().setFromPoints( points );
+		for ( const gizmo in this._gizmos.children ) {
+			this._gizmos.children[ gizmo ].geometry = curveGeometry;
+		}
+		this.dispatchEvent( _changeEvent );
+	}
+	/**
+	 * Creates the rotation gizmos matching trackball center and radius
+	 * @param {Vector3} tbCenter The trackball center
+	 * @param {number} tbRadius The trackball radius
+	 */
+	makeGizmos( tbCenter, tbRadius ) {
+		const curve = new EllipseCurve( 0, 0, tbRadius, tbRadius );
+		const points = curve.getPoints( this._curvePts );
+		//geometry
+		const curveGeometry = new BufferGeometry().setFromPoints( points );
+		//material
+		const curveMaterialX = new LineBasicMaterial( { color: 0xff8080, fog: false, transparent: true, opacity: 0.6 } );
+		const curveMaterialY = new LineBasicMaterial( { color: 0x80ff80, fog: false, transparent: true, opacity: 0.6 } );
+		const curveMaterialZ = new LineBasicMaterial( { color: 0x8080ff, fog: false, transparent: true, opacity: 0.6 } );
+		//line
+		const gizmoX = new Line( curveGeometry, curveMaterialX );
+		const gizmoY = new Line( curveGeometry, curveMaterialY );
+		const gizmoZ = new Line( curveGeometry, curveMaterialZ );
+		const rotation = Math.PI * 0.5;
+		gizmoX.rotation.x = rotation;
+		gizmoY.rotation.y = rotation;
+		//setting state
+		this._gizmoMatrixState0.identity().setPosition( tbCenter );
+		this._gizmoMatrixState.copy( this._gizmoMatrixState0 );
+		if ( this.object.zoom !== 1 ) {
+			//adapt gizmos size to camera zoom
+			const size = 1 / this.object.zoom;
+			this._scaleMatrix.makeScale( size, size, size );
+			this._translationMatrix.makeTranslation( - tbCenter.x, - tbCenter.y, - tbCenter.z );
+			this._gizmoMatrixState.premultiply( this._translationMatrix ).premultiply( this._scaleMatrix );
+			this._translationMatrix.makeTranslation( tbCenter.x, tbCenter.y, tbCenter.z );
+			this._gizmoMatrixState.premultiply( this._translationMatrix );
+		}
+		this._gizmoMatrixState.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+		//
+		this._gizmos.traverse( function ( object ) {
+			if ( object.isLine ) {
+				object.geometry.dispose();
+				object.material.dispose();
+			}
+		} );
+		this._gizmos.clear();
+		//
+		this._gizmos.add( gizmoX );
+		this._gizmos.add( gizmoY );
+		this._gizmos.add( gizmoZ );
+	}
+	/**
+	 * Perform animation for focus operation
+	 * @param {Number} time Instant in which this function is called as performance.now()
+	 * @param {Vector3} point Point of interest for focus operation
+	 * @param {Matrix4} cameraMatrix Camera matrix
+	 * @param {Matrix4} gizmoMatrix Gizmos matrix
+	 */
+	onFocusAnim( time, point, cameraMatrix, gizmoMatrix ) {
+		if ( this._timeStart == - 1 ) {
+			//animation start
+			this._timeStart = time;
+		}
+		if ( this._state == STATE.ANIMATION_FOCUS ) {
+			const deltaTime = time - this._timeStart;
+			const animTime = deltaTime / this.focusAnimationTime;
+			this._gizmoMatrixState.copy( gizmoMatrix );
+			if ( animTime >= 1 ) {
+				//animation end
+				this._gizmoMatrixState.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+				this.focus( point, this.scaleFactor );
+				this._timeStart = - 1;
+				this.updateTbState( STATE.IDLE, false );
+				this.activateGizmos( false );
+				this.dispatchEvent( _changeEvent );
+			} else {
+				const amount = this.easeOutCubic( animTime );
+				const size = ( ( 1 - amount ) + ( this.scaleFactor * amount ) );
+				this._gizmoMatrixState.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+				this.focus( point, size, amount );
+				this.dispatchEvent( _changeEvent );
+				const self = this;
+				this._animationId = window.requestAnimationFrame( function ( t ) {
+					self.onFocusAnim( t, point, cameraMatrix, gizmoMatrix.clone() );
+				} );
+			}
+		} else {
+			//interrupt animation
+			this._animationId = - 1;
+			this._timeStart = - 1;
+		}
+	}
+	/**
+	 * Perform animation for rotation operation
+	 * @param {Number} time Instant in which this function is called as performance.now()
+	 * @param {Vector3} rotationAxis Rotation axis
+	 * @param {number} w0 Initial angular velocity
+	 */
+	onRotationAnim( time, rotationAxis, w0 ) {
+		if ( this._timeStart == - 1 ) {
+			//animation start
+			this._anglePrev = 0;
+			this._angleCurrent = 0;
+			this._timeStart = time;
+		}
+		if ( this._state == STATE.ANIMATION_ROTATE ) {
+			//w = w0 + alpha * t
+			const deltaTime = ( time - this._timeStart ) / 1000;
+			const w = w0 + ( ( - this.dampingFactor ) * deltaTime );
+			if ( w > 0 ) {
+				//tetha = 0.5 * alpha * t^2 + w0 * t + tetha0
+				this._angleCurrent = 0.5 * ( - this.dampingFactor ) * Math.pow( deltaTime, 2 ) + w0 * deltaTime + 0;
+				this.applyTransformMatrix( this.rotate( rotationAxis, this._angleCurrent ) );
+				this.dispatchEvent( _changeEvent );
+				const self = this;
+				this._animationId = window.requestAnimationFrame( function ( t ) {
+					self.onRotationAnim( t, rotationAxis, w0 );
+				} );
+			} else {
+				this._animationId = - 1;
+				this._timeStart = - 1;
+				this.updateTbState( STATE.IDLE, false );
+				this.activateGizmos( false );
+				this.dispatchEvent( _changeEvent );
+			}
+		} else {
+			//interrupt animation
+			this._animationId = - 1;
+			this._timeStart = - 1;
+			if ( this._state != STATE.ROTATE ) {
+				this.activateGizmos( false );
+				this.dispatchEvent( _changeEvent );
+			}
+		}
+	}
+	/**
+	 * Perform pan operation moving camera between two points
+	 *
+	 * @param {Vector3} p0 Initial point
+	 * @param {Vector3} p1 Ending point
+	 * @param {Boolean} [adjust=false] If movement should be adjusted considering camera distance (Perspective only)
+	 * @returns {Object}
+	 */
+	pan( p0, p1, adjust = false ) {
+		const movement = p0.clone().sub( p1 );
+		if ( this.object.isOrthographicCamera ) {
+			//adjust movement amount
+			movement.multiplyScalar( 1 / this.object.zoom );
+		} else if ( this.object.isPerspectiveCamera && adjust ) {
+			//adjust movement amount
+			this._v3_1.setFromMatrixPosition( this._cameraMatrixState0 );	//camera's initial position
+			this._v3_2.setFromMatrixPosition( this._gizmoMatrixState0 );	//gizmo's initial position
+			const distanceFactor = this._v3_1.distanceTo( this._v3_2 ) / this.object.position.distanceTo( this._gizmos.position );
+			movement.multiplyScalar( 1 / distanceFactor );
+		}
+		this._v3_1.set( movement.x, movement.y, 0 ).applyQuaternion( this.object.quaternion );
+		this._m4_1.makeTranslation( this._v3_1.x, this._v3_1.y, this._v3_1.z );
+		this.setTransformationMatrices( this._m4_1, this._m4_1 );
+		return _transformation;
+	}
+	/**
+	 * Reset trackball
+	 */
+	reset() {
+		this.object.zoom = this._zoom0;
+		if ( this.object.isPerspectiveCamera ) {
+			this.object.fov = this._fov0;
+		}
+		this.object.near = this._nearPos;
+		this.object.far = this._farPos;
+		this._cameraMatrixState.copy( this._cameraMatrixState0 );
+		this._cameraMatrixState.decompose( this.object.position, this.object.quaternion, this.object.scale );
+		this.object.up.copy( this._up0 );
+		this.object.updateMatrix();
+		this.object.updateProjectionMatrix();
+		this._gizmoMatrixState.copy( this._gizmoMatrixState0 );
+		this._gizmoMatrixState0.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+		this._gizmos.updateMatrix();
+		this._tbRadius = this.calculateTbRadius( this.object );
+		this.makeGizmos( this._gizmos.position, this._tbRadius );
+		this.object.lookAt( this._gizmos.position );
+		this.updateTbState( STATE.IDLE, false );
+		this.dispatchEvent( _changeEvent );
+	}
+	/**
+	 * Rotate the camera around an axis passing by trackball's center
+	 * @param {Vector3} axis Rotation axis
+	 * @param {number} angle Angle in radians
+	 * @returns {Object} Object with 'camera' field containing transformation matrix resulting from the operation to be applied to the camera
+	 */
+	rotate( axis, angle ) {
+		const point = this._gizmos.position; //rotation center
+		this._translationMatrix.makeTranslation( - point.x, - point.y, - point.z );
+		this._rotationMatrix.makeRotationAxis( axis, - angle );
+		//rotate camera
+		this._m4_1.makeTranslation( point.x, point.y, point.z );
+		this._m4_1.multiply( this._rotationMatrix );
+		this._m4_1.multiply( this._translationMatrix );
+		this.setTransformationMatrices( this._m4_1 );
+		return _transformation;
+	}
+	copyState() {
+		let state;
+		if ( this.object.isOrthographicCamera ) {
+			state = JSON.stringify( {
+				arcballState: {
+					cameraFar: this.object.far,
+					cameraMatrix: this.object.matrix,
+					cameraNear: this.object.near,
+					cameraUp: this.object.up,
+					cameraZoom: this.object.zoom,
+					gizmoMatrix: this._gizmos.matrix
+				}
+			} );
+		} else if ( this.object.isPerspectiveCamera ) {
+			state = JSON.stringify( {
+				arcballState: {
+					cameraFar: this.object.far,
+					cameraFov: this.object.fov,
+					cameraMatrix: this.object.matrix,
+					cameraNear: this.object.near,
+					cameraUp: this.object.up,
+					cameraZoom: this.object.zoom,
+					gizmoMatrix: this._gizmos.matrix
+				}
+			} );
+		}
+		navigator.clipboard.writeText( state );
+	}
+	pasteState() {
+		const self = this;
+		navigator.clipboard.readText().then( function resolved( value ) {
+			self.setStateFromJSON( value );
+		} );
+	}
+	/**
+	 * Save the current state of the control. This can later be recover with .reset
+	 */
+	saveState() {
+		this._cameraMatrixState0.copy( this.object.matrix );
+		this._gizmoMatrixState0.copy( this._gizmos.matrix );
+		this._nearPos = this.object.near;
+		this._farPos = this.object.far;
+		this._zoom0 = this.object.zoom;
+		this._up0.copy( this.object.up );
+		if ( this.object.isPerspectiveCamera ) {
+			this._fov0 = this.object.fov;
+		}
+	}
+	/**
+	 * Perform uniform scale operation around a given point
+	 * @param {Number} size Scale factor
+	 * @param {Vector3} point Point around which scale
+	 * @param {Boolean} scaleGizmos If gizmos should be scaled (Perspective only)
+	 * @returns {Object} Object with 'camera' and 'gizmo' fields containing transformation matrices resulting from the operation to be applied to the camera and gizmos
+	 */
+	scale( size, point, scaleGizmos = true ) {
+		_scalePointTemp.copy( point );
+		let sizeInverse = 1 / size;
+		if ( this.object.isOrthographicCamera ) {
+			//camera zoom
+			this.object.zoom = this._zoomState;
+			this.object.zoom *= size;
+			//check min and max zoom
+			if ( this.object.zoom > this.maxZoom ) {
+				this.object.zoom = this.maxZoom;
+				sizeInverse = this._zoomState / this.maxZoom;
+			} else if ( this.object.zoom < this.minZoom ) {
+				this.object.zoom = this.minZoom;
+				sizeInverse = this._zoomState / this.minZoom;
+			}
+			this.object.updateProjectionMatrix();
+			this._v3_1.setFromMatrixPosition( this._gizmoMatrixState );	//gizmos position
+			//scale gizmos so they appear in the same spot having the same dimension
+			this._scaleMatrix.makeScale( sizeInverse, sizeInverse, sizeInverse );
+			this._translationMatrix.makeTranslation( - this._v3_1.x, - this._v3_1.y, - this._v3_1.z );
+			this._m4_2.makeTranslation( this._v3_1.x, this._v3_1.y, this._v3_1.z ).multiply( this._scaleMatrix );
+			this._m4_2.multiply( this._translationMatrix );
+			//move camera and gizmos to obtain pinch effect
+			_scalePointTemp.sub( this._v3_1 );
+			const amount = _scalePointTemp.clone().multiplyScalar( sizeInverse );
+			_scalePointTemp.sub( amount );
+			this._m4_1.makeTranslation( _scalePointTemp.x, _scalePointTemp.y, _scalePointTemp.z );
+			this._m4_2.premultiply( this._m4_1 );
+			this.setTransformationMatrices( this._m4_1, this._m4_2 );
+			return _transformation;
+		} else if ( this.object.isPerspectiveCamera ) {
+			this._v3_1.setFromMatrixPosition( this._cameraMatrixState );
+			this._v3_2.setFromMatrixPosition( this._gizmoMatrixState );
+			//move camera
+			let distance = this._v3_1.distanceTo( _scalePointTemp );
+			let amount = distance - ( distance * sizeInverse );
+			//check min and max distance
+			const newDistance = distance - amount;
+			if ( newDistance < this.minDistance ) {
+				sizeInverse = this.minDistance / distance;
+				amount = distance - ( distance * sizeInverse );
+			} else if ( newDistance > this.maxDistance ) {
+				sizeInverse = this.maxDistance / distance;
+				amount = distance - ( distance * sizeInverse );
+			}
+			_offset.copy( _scalePointTemp ).sub( this._v3_1 ).normalize().multiplyScalar( amount );
+			this._m4_1.makeTranslation( _offset.x, _offset.y, _offset.z );
+			if ( scaleGizmos ) {
+				//scale gizmos so they appear in the same spot having the same dimension
+				const pos = this._v3_2;
+				distance = pos.distanceTo( _scalePointTemp );
+				amount = distance - ( distance * sizeInverse );
+				_offset.copy( _scalePointTemp ).sub( this._v3_2 ).normalize().multiplyScalar( amount );
+				this._translationMatrix.makeTranslation( pos.x, pos.y, pos.z );
+				this._scaleMatrix.makeScale( sizeInverse, sizeInverse, sizeInverse );
+				this._m4_2.makeTranslation( _offset.x, _offset.y, _offset.z ).multiply( this._translationMatrix );
+				this._m4_2.multiply( this._scaleMatrix );
+				this._translationMatrix.makeTranslation( - pos.x, - pos.y, - pos.z );
+				this._m4_2.multiply( this._translationMatrix );
+				this.setTransformationMatrices( this._m4_1, this._m4_2 );
+			} else {
+				this.setTransformationMatrices( this._m4_1 );
+			}
+			return _transformation;
+		}
+	}
+	/**
+	 * Set camera fov
+	 * @param {Number} value fov to be set
+	 */
+	setFov( value ) {
+		if ( this.object.isPerspectiveCamera ) {
+			this.object.fov = MathUtils.clamp( value, this.minFov, this.maxFov );
+			this.object.updateProjectionMatrix();
+		}
+	}
+	/**
+	 * Set values in transformation object
+	 *
+	 * @param {Matrix4} [camera=null] Transformation to be applied to the camera
+	 * @param {Matrix4} [gizmos=null] Transformation to be applied to gizmos
+	 */
+	setTransformationMatrices( camera = null, gizmos = null ) {
+		if ( camera != null ) {
+			if ( _transformation.camera != null ) {
+				_transformation.camera.copy( camera );
+			} else {
+				_transformation.camera = camera.clone();
+			}
+		} else {
+			_transformation.camera = null;
+		}
+		if ( gizmos != null ) {
+			if ( _transformation.gizmos != null ) {
+				_transformation.gizmos.copy( gizmos );
+			} else {
+				_transformation.gizmos = gizmos.clone();
+			}
+		} else {
+			_transformation.gizmos = null;
+		}
+	}
+	/**
+	 * Rotate camera around its direction axis passing by a given point by a given angle
+	 *
+	 * @param {Vector3} point The point where the rotation axis is passing trough
+	 * @param {Number} angle Angle in radians
+	 * @returns {Object} The computed transformation matrix
+	 */
+	zRotate( point, angle ) {
+		this._rotationMatrix.makeRotationAxis( this._rotationAxis, angle );
+		this._translationMatrix.makeTranslation( - point.x, - point.y, - point.z );
+		this._m4_1.makeTranslation( point.x, point.y, point.z );
+		this._m4_1.multiply( this._rotationMatrix );
+		this._m4_1.multiply( this._translationMatrix );
+		this._v3_1.setFromMatrixPosition( this._gizmoMatrixState ).sub( point );	//vector from rotation center to gizmos position
+		this._v3_2.copy( this._v3_1 ).applyAxisAngle( this._rotationAxis, angle );	//apply rotation
+		this._v3_2.sub( this._v3_1 );
+		this._m4_2.makeTranslation( this._v3_2.x, this._v3_2.y, this._v3_2.z );
+		this.setTransformationMatrices( this._m4_1, this._m4_2 );
+		return _transformation;
+	}
+	getRaycaster() {
+		return _raycaster;
+	}
+	/**
+	 * Unproject the cursor on the 3D object surface
+	 *
+	 * @param {Vector2} cursor Cursor coordinates in NDC
+	 * @param {Camera} camera Virtual camera
+	 * @returns {Vector3|null} The point of intersection with the model, if exist, null otherwise
+	 */
+	unprojectOnObj( cursor, camera ) {
+		const raycaster = this.getRaycaster();
+		raycaster.near = camera.near;
+		raycaster.far = camera.far;
+		raycaster.setFromCamera( cursor, camera );
+		const intersect = raycaster.intersectObjects( this.scene.children, true );
+		for ( let i = 0; i < intersect.length; i ++ ) {
+			if ( intersect[ i ].object.uuid != this._gizmos.uuid && intersect[ i ].face != null ) {
+				return intersect[ i ].point.clone();
+			}
+		}
+		return null;
+	}
+	/**
+	 * Unproject the cursor on the trackball surface
+	 * @param {Camera} camera The virtual camera
+	 * @param {Number} cursorX Cursor horizontal coordinate on screen
+	 * @param {Number} cursorY Cursor vertical coordinate on screen
+	 * @param {HTMLElement} canvas The canvas where the renderer draws its output
+	 * @param {number} tbRadius The trackball radius
+	 * @returns {Vector3} The unprojected point on the trackball surface
+	 */
+	unprojectOnTbSurface( camera, cursorX, cursorY, canvas, tbRadius ) {
+		if ( camera.type == 'OrthographicCamera' ) {
+			this._v2_1.copy( this.getCursorPosition( cursorX, cursorY, canvas ) );
+			this._v3_1.set( this._v2_1.x, this._v2_1.y, 0 );
+			const x2 = Math.pow( this._v2_1.x, 2 );
+			const y2 = Math.pow( this._v2_1.y, 2 );
+			const r2 = Math.pow( this._tbRadius, 2 );
+			if ( x2 + y2 <= r2 * 0.5 ) {
+				//intersection with sphere
+				this._v3_1.setZ( Math.sqrt( r2 - ( x2 + y2 ) ) );
+			} else {
+				//intersection with hyperboloid
+				this._v3_1.setZ( ( r2 * 0.5 ) / ( Math.sqrt( x2 + y2 ) ) );
+			}
+			return this._v3_1;
+		} else if ( camera.type == 'PerspectiveCamera' ) {
+			//unproject cursor on the near plane
+			this._v2_1.copy( this.getCursorNDC( cursorX, cursorY, canvas ) );
+			this._v3_1.set( this._v2_1.x, this._v2_1.y, - 1 );
+			this._v3_1.applyMatrix4( camera.projectionMatrixInverse );
+			const rayDir = this._v3_1.clone().normalize(); //unprojected ray direction
+			const cameraGizmoDistance = camera.position.distanceTo( this._gizmos.position );
+			const radius2 = Math.pow( tbRadius, 2 );
+			//	  camera
+			//		|\
+			//		| \
+			//		|  \
+			//	h	|	\
+			//		| 	 \
+			//		| 	  \
+			//	_ _ | _ _ _\ _ _  near plane
+			//			l
+			const h = this._v3_1.z;
+			const l = Math.sqrt( Math.pow( this._v3_1.x, 2 ) + Math.pow( this._v3_1.y, 2 ) );
+			if ( l == 0 ) {
+				//ray aligned with camera
+				rayDir.set( this._v3_1.x, this._v3_1.y, tbRadius );
+				return rayDir;
+			}
+			const m = h / l;
+			const q = cameraGizmoDistance;
+			/*
+			 * calculate intersection point between unprojected ray and trackball surface
+			 *|y = m * x + q
+			 *|x^2 + y^2 = r^2
+			 *
+			 * (m^2 + 1) * x^2 + (2 * m * q) * x + q^2 - r^2 = 0
+			 */
+			let a = Math.pow( m, 2 ) + 1;
+			let b = 2 * m * q;
+			let c = Math.pow( q, 2 ) - radius2;
+			let delta = Math.pow( b, 2 ) - ( 4 * a * c );
+			if ( delta >= 0 ) {
+				//intersection with sphere
+				this._v2_1.setX( ( - b - Math.sqrt( delta ) ) / ( 2 * a ) );
+				this._v2_1.setY( m * this._v2_1.x + q );
+				const angle = MathUtils.RAD2DEG * this._v2_1.angle();
+				if ( angle >= 45 ) {
+					//if angle between intersection point and X' axis is >= 45°, return that point
+					//otherwise, calculate intersection point with hyperboloid
+					const rayLength = Math.sqrt( Math.pow( this._v2_1.x, 2 ) + Math.pow( ( cameraGizmoDistance - this._v2_1.y ), 2 ) );
+					rayDir.multiplyScalar( rayLength );
+					rayDir.z += cameraGizmoDistance;
+					return rayDir;
+				}
+			}
+			//intersection with hyperboloid
+			/*
+			 *|y = m * x + q
+			 *|y = (1 / x) * (r^2 / 2)
+			 *
+			 * m * x^2 + q * x - r^2 / 2 = 0
+			 */
+			a = m;
+			b = q;
+			c = - radius2 * 0.5;
+			delta = Math.pow( b, 2 ) - ( 4 * a * c );
+			this._v2_1.setX( ( - b - Math.sqrt( delta ) ) / ( 2 * a ) );
+			this._v2_1.setY( m * this._v2_1.x + q );
+			const rayLength = Math.sqrt( Math.pow( this._v2_1.x, 2 ) + Math.pow( ( cameraGizmoDistance - this._v2_1.y ), 2 ) );
+			rayDir.multiplyScalar( rayLength );
+			rayDir.z += cameraGizmoDistance;
+			return rayDir;
+		}
+	}
+	/**
+	 * Unproject the cursor on the plane passing through the center of the trackball orthogonal to the camera
+	 * @param {Camera} camera The virtual camera
+	 * @param {Number} cursorX Cursor horizontal coordinate on screen
+	 * @param {Number} cursorY Cursor vertical coordinate on screen
+	 * @param {HTMLElement} canvas The canvas where the renderer draws its output
+	 * @param {Boolean} initialDistance If initial distance between camera and gizmos should be used for calculations instead of current (Perspective only)
+	 * @returns {Vector3} The unprojected point on the trackball plane
+	 */
+	unprojectOnTbPlane( camera, cursorX, cursorY, canvas, initialDistance = false ) {
+		if ( camera.type == 'OrthographicCamera' ) {
+			this._v2_1.copy( this.getCursorPosition( cursorX, cursorY, canvas ) );
+			this._v3_1.set( this._v2_1.x, this._v2_1.y, 0 );
+			return this._v3_1.clone();
+		} else if ( camera.type == 'PerspectiveCamera' ) {
+			this._v2_1.copy( this.getCursorNDC( cursorX, cursorY, canvas ) );
+			//unproject cursor on the near plane
+			this._v3_1.set( this._v2_1.x, this._v2_1.y, - 1 );
+			this._v3_1.applyMatrix4( camera.projectionMatrixInverse );
+			const rayDir = this._v3_1.clone().normalize(); //unprojected ray direction
+			//	  camera
+			//		|\
+			//		| \
+			//		|  \
+			//	h	|	\
+			//		| 	 \
+			//		| 	  \
+			//	_ _ | _ _ _\ _ _  near plane
+			//			l
+			const h = this._v3_1.z;
+			const l = Math.sqrt( Math.pow( this._v3_1.x, 2 ) + Math.pow( this._v3_1.y, 2 ) );
+			let cameraGizmoDistance;
+			if ( initialDistance ) {
+				cameraGizmoDistance = this._v3_1.setFromMatrixPosition( this._cameraMatrixState0 ).distanceTo( this._v3_2.setFromMatrixPosition( this._gizmoMatrixState0 ) );
+			} else {
+				cameraGizmoDistance = camera.position.distanceTo( this._gizmos.position );
+			}
+			/*
+			 * calculate intersection point between unprojected ray and the plane
+			 *|y = mx + q
+			 *|y = 0
+			 *
+			 * x = -q/m
+			*/
+			if ( l == 0 ) {
+				//ray aligned with camera
+				rayDir.set( 0, 0, 0 );
+				return rayDir;
+			}
+			const m = h / l;
+			const q = cameraGizmoDistance;
+			const x = - q / m;
+			const rayLength = Math.sqrt( Math.pow( q, 2 ) + Math.pow( x, 2 ) );
+			rayDir.multiplyScalar( rayLength );
+			rayDir.z = 0;
+			return rayDir;
+		}
+	}
+	/**
+	 * Update camera and gizmos state
+	 */
+	updateMatrixState() {
+		//update camera and gizmos state
+		this._cameraMatrixState.copy( this.object.matrix );
+		this._gizmoMatrixState.copy( this._gizmos.matrix );
+		if ( this.object.isOrthographicCamera ) {
+			this._cameraProjectionState.copy( this.object.projectionMatrix );
+			this.object.updateProjectionMatrix();
+			this._zoomState = this.object.zoom;
+		} else if ( this.object.isPerspectiveCamera ) {
+			this._fovState = this.object.fov;
+		}
+	}
+	/**
+	 * Update the trackball FSA
+	 * @param {STATE} newState New state of the FSA
+	 * @param {Boolean} updateMatrices If matrices state should be updated
+	 */
+	updateTbState( newState, updateMatrices ) {
+		this._state = newState;
+		if ( updateMatrices ) {
+			this.updateMatrixState();
+		}
+	}
+	update() {
+		const EPS = 0.000001;
+		if ( this.target.equals( this._currentTarget ) === false ) {
+			this._gizmos.position.copy( this.target );	//for correct radius calculation
+			this._tbRadius = this.calculateTbRadius( this.object );
+			this.makeGizmos( this.target, this._tbRadius );
+			this._currentTarget.copy( this.target );
+		}
+		//check min/max parameters
+		if ( this.object.isOrthographicCamera ) {
+			//check zoom
+			if ( this.object.zoom > this.maxZoom || this.object.zoom < this.minZoom ) {
+				const newZoom = MathUtils.clamp( this.object.zoom, this.minZoom, this.maxZoom );
+				this.applyTransformMatrix( this.scale( newZoom / this.object.zoom, this._gizmos.position, true ) );
+			}
+		} else if ( this.object.isPerspectiveCamera ) {
+			//check distance
+			const distance = this.object.position.distanceTo( this._gizmos.position );
+			if ( distance > this.maxDistance + EPS || distance < this.minDistance - EPS ) {
+				const newDistance = MathUtils.clamp( distance, this.minDistance, this.maxDistance );
+				this.applyTransformMatrix( this.scale( newDistance / distance, this._gizmos.position ) );
+				this.updateMatrixState();
+			}
+			//check fov
+			if ( this.object.fov < this.minFov || this.object.fov > this.maxFov ) {
+				this.object.fov = MathUtils.clamp( this.object.fov, this.minFov, this.maxFov );
+				this.object.updateProjectionMatrix();
+			}
+			const oldRadius = this._tbRadius;
+			this._tbRadius = this.calculateTbRadius( this.object );
+			if ( oldRadius < this._tbRadius - EPS || oldRadius > this._tbRadius + EPS ) {
+				const scale = ( this._gizmos.scale.x + this._gizmos.scale.y + this._gizmos.scale.z ) / 3;
+				const newRadius = this._tbRadius / scale;
+				const curve = new EllipseCurve( 0, 0, newRadius, newRadius );
+				const points = curve.getPoints( this._curvePts );
+				const curveGeometry = new BufferGeometry().setFromPoints( points );
+				for ( const gizmo in this._gizmos.children ) {
+					this._gizmos.children[ gizmo ].geometry = curveGeometry;
+				}
+			}
+		}
+		this.object.lookAt( this._gizmos.position );
+	}
+	setStateFromJSON( json ) {
+		const state = JSON.parse( json );
+		if ( state.arcballState != undefined ) {
+			this._cameraMatrixState.fromArray( state.arcballState.cameraMatrix.elements );
+			this._cameraMatrixState.decompose( this.object.position, this.object.quaternion, this.object.scale );
+			this.object.up.copy( state.arcballState.cameraUp );
+			this.object.near = state.arcballState.cameraNear;
+			this.object.far = state.arcballState.cameraFar;
+			this.object.zoom = state.arcballState.cameraZoom;
+			if ( this.object.isPerspectiveCamera ) {
+				this.object.fov = state.arcballState.cameraFov;
+			}
+			this._gizmoMatrixState.fromArray( state.arcballState.gizmoMatrix.elements );
+			this._gizmoMatrixState.decompose( this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale );
+			this.object.updateMatrix();
+			this.object.updateProjectionMatrix();
+			this._gizmos.updateMatrix();
+			this._tbRadius = this.calculateTbRadius( this.object );
+			const gizmoTmp = new Matrix4().copy( this._gizmoMatrixState0 );
+			this.makeGizmos( this._gizmos.position, this._tbRadius );
+			this._gizmoMatrixState0.copy( gizmoTmp );
+			this.object.lookAt( this._gizmos.position );
+			this.updateTbState( STATE.IDLE, false );
+			this.dispatchEvent( _changeEvent );
+		}
+	}
+}
+//listeners
+function onWindowResize() {
+	const scale = ( this._gizmos.scale.x + this._gizmos.scale.y + this._gizmos.scale.z ) / 3;
+	this._tbRadius = this.calculateTbRadius( this.object );
+	const newRadius = this._tbRadius / scale;
+	const curve = new EllipseCurve( 0, 0, newRadius, newRadius );
+	const points = curve.getPoints( this._curvePts );
+	const curveGeometry = new BufferGeometry().setFromPoints( points );
+	for ( const gizmo in this._gizmos.children ) {
+		this._gizmos.children[ gizmo ].geometry = curveGeometry;
+	}
+	this.dispatchEvent( _changeEvent );
+}
+function onContextMenu( event ) {
+	if ( ! this.enabled ) {
+		return;
+	}
+	for ( let i = 0; i < this.mouseActions.length; i ++ ) {
+		if ( this.mouseActions[ i ].mouse == 2 ) {
+			//prevent only if button 2 is actually used
+			event.preventDefault();
+			break;
+		}
+	}
+}
+function onPointerCancel() {
+	this._touchStart.splice( 0, this._touchStart.length );
+	this._touchCurrent.splice( 0, this._touchCurrent.length );
+	this._input = INPUT.NONE;
+}
+function onPointerDown( event ) {
+	if ( event.button == 0 && event.isPrimary ) {
+		this._downValid = true;
+		this._downEvents.push( event );
+		this._downStart = performance.now();
+	} else {
+		this._downValid = false;
+	}
+	if ( event.pointerType == 'touch' && this._input != INPUT.CURSOR ) {
+		this._touchStart.push( event );
+		this._touchCurrent.push( event );
+		switch ( this._input ) {
+			case INPUT.NONE:
+				//singleStart
+				this._input = INPUT.ONE_FINGER;
+				this.onSinglePanStart( event, 'ROTATE' );
+				window.addEventListener( 'pointermove', this._onPointerMove );
+				window.addEventListener( 'pointerup', this._onPointerUp );
+				break;
+			case INPUT.ONE_FINGER:
+			case INPUT.ONE_FINGER_SWITCHED:
+				//doubleStart
+				this._input = INPUT.TWO_FINGER;
+				this.onRotateStart();
+				this.onPinchStart();
+				this.onDoublePanStart();
+				break;
+			case INPUT.TWO_FINGER:
+				//multipleStart
+				this._input = INPUT.MULT_FINGER;
+				this.onTriplePanStart( event );
+				break;
+		}
+	} else if ( event.pointerType != 'touch' && this._input == INPUT.NONE ) {
+		let modifier = null;
+		if ( event.ctrlKey || event.metaKey ) {
+			modifier = 'CTRL';
+		} else if ( event.shiftKey ) {
+			modifier = 'SHIFT';
+		}
+		this._mouseOp = this.getOpFromAction( event.button, modifier );
+		if ( this._mouseOp != null ) {
+			window.addEventListener( 'pointermove', this._onPointerMove );
+			window.addEventListener( 'pointerup', this._onPointerUp );
+			//singleStart
+			this._input = INPUT.CURSOR;
+			this._button = event.button;
+			this.onSinglePanStart( event, this._mouseOp );
+		}
+	}
+}
+function onPointerMove( event ) {
+	if ( event.pointerType == 'touch' && this._input != INPUT.CURSOR ) {
+		switch ( this._input ) {
+			case INPUT.ONE_FINGER:
+				//singleMove
+				this.updateTouchEvent( event );
+				this.onSinglePanMove( event, STATE.ROTATE );
+				break;
+			case INPUT.ONE_FINGER_SWITCHED:
+				const movement = this.calculatePointersDistance( this._touchCurrent[ 0 ], event ) * this._devPxRatio;
+				if ( movement >= this._switchSensibility ) {
+					//singleMove
+					this._input = INPUT.ONE_FINGER;
+					this.updateTouchEvent( event );
+					this.onSinglePanStart( event, 'ROTATE' );
+					break;
+				}
+				break;
+			case INPUT.TWO_FINGER:
+				//rotate/pan/pinchMove
+				this.updateTouchEvent( event );
+				this.onRotateMove();
+				this.onPinchMove();
+				this.onDoublePanMove();
+				break;
+			case INPUT.MULT_FINGER:
+				//multMove
+				this.updateTouchEvent( event );
+				this.onTriplePanMove( event );
+				break;
+		}
+	} else if ( event.pointerType != 'touch' && this._input == INPUT.CURSOR ) {
+		let modifier = null;
+		if ( event.ctrlKey || event.metaKey ) {
+			modifier = 'CTRL';
+		} else if ( event.shiftKey ) {
+			modifier = 'SHIFT';
+		}
+		const mouseOpState = this.getOpStateFromAction( this._button, modifier );
+		if ( mouseOpState != null ) {
+			this.onSinglePanMove( event, mouseOpState );
+		}
+	}
+	//checkDistance
+	if ( this._downValid ) {
+		const movement = this.calculatePointersDistance( this._downEvents[ this._downEvents.length - 1 ], event ) * this._devPxRatio;
+		if ( movement > this._movementThreshold ) {
+			this._downValid = false;
+		}
+	}
+}
+function onPointerUp( event ) {
+	if ( event.pointerType == 'touch' && this._input != INPUT.CURSOR ) {
+		const nTouch = this._touchCurrent.length;
+		for ( let i = 0; i < nTouch; i ++ ) {
+			if ( this._touchCurrent[ i ].pointerId == event.pointerId ) {
+				this._touchCurrent.splice( i, 1 );
+				this._touchStart.splice( i, 1 );
+				break;
+			}
+		}
+		switch ( this._input ) {
+			case INPUT.ONE_FINGER:
+			case INPUT.ONE_FINGER_SWITCHED:
+				//singleEnd
+				window.removeEventListener( 'pointermove', this._onPointerMove );
+				window.removeEventListener( 'pointerup', this._onPointerUp );
+				this._input = INPUT.NONE;
+				this.onSinglePanEnd();
+				break;
+			case INPUT.TWO_FINGER:
+				//doubleEnd
+				this.onDoublePanEnd( event );
+				this.onPinchEnd( event );
+				this.onRotateEnd( event );
+				//switching to singleStart
+				this._input = INPUT.ONE_FINGER_SWITCHED;
+				break;
+			case INPUT.MULT_FINGER:
+				if ( this._touchCurrent.length == 0 ) {
+					window.removeEventListener( 'pointermove', this._onPointerMove );
+					window.removeEventListener( 'pointerup', this._onPointerUp );
+					//multCancel
+					this._input = INPUT.NONE;
+					this.onTriplePanEnd();
+				}
+				break;
+		}
+	} else if ( event.pointerType != 'touch' && this._input == INPUT.CURSOR ) {
+		window.removeEventListener( 'pointermove', this._onPointerMove );
+		window.removeEventListener( 'pointerup', this._onPointerUp );
+		this._input = INPUT.NONE;
+		this.onSinglePanEnd();
+		this._button = - 1;
+	}
+	if ( event.isPrimary ) {
+		if ( this._downValid ) {
+			const downTime = event.timeStamp - this._downEvents[ this._downEvents.length - 1 ].timeStamp;
+			if ( downTime <= this._maxDownTime ) {
+				if ( this._nclicks == 0 ) {
+					//first valid click detected
+					this._nclicks = 1;
+					this._clickStart = performance.now();
+				} else {
+					const clickInterval = event.timeStamp - this._clickStart;
+					const movement = this.calculatePointersDistance( this._downEvents[ 1 ], this._downEvents[ 0 ] ) * this._devPxRatio;
+					if ( clickInterval <= this._maxInterval && movement <= this._posThreshold ) {
+						//second valid click detected
+						//fire double tap and reset values
+						this._nclicks = 0;
+						this._downEvents.splice( 0, this._downEvents.length );
+						this.onDoubleTap( event );
+					} else {
+						//new 'first click'
+						this._nclicks = 1;
+						this._downEvents.shift();
+						this._clickStart = performance.now();
+					}
+				}
+			} else {
+				this._downValid = false;
+				this._nclicks = 0;
+				this._downEvents.splice( 0, this._downEvents.length );
+			}
+		} else {
+			this._nclicks = 0;
+			this._downEvents.splice( 0, this._downEvents.length );
+		}
+	}
+}
+function onWheel( event ) {
+	if ( this.enabled && this.enableZoom ) {
+		let modifier = null;
+		if ( event.ctrlKey || event.metaKey ) {
+			modifier = 'CTRL';
+		} else if ( event.shiftKey ) {
+			modifier = 'SHIFT';
+		}
+		const mouseOp = this.getOpFromAction( 'WHEEL', modifier );
+		if ( mouseOp != null ) {
+			event.preventDefault();
+			this.dispatchEvent( _startEvent );
+			const notchDeltaY = 125; //distance of one notch of mouse wheel
+			let sgn = event.deltaY / notchDeltaY;
+			let size = 1;
+			if ( sgn > 0 ) {
+				size = 1 / this.scaleFactor;
+			} else if ( sgn < 0 ) {
+				size = this.scaleFactor;
+			}
+			switch ( mouseOp ) {
+				case 'ZOOM':
+					this.updateTbState( STATE.SCALE, true );
+					if ( sgn > 0 ) {
+						size = 1 / ( Math.pow( this.scaleFactor, sgn ) );
+					} else if ( sgn < 0 ) {
+						size = Math.pow( this.scaleFactor, - sgn );
+					}
+					if ( this.cursorZoom && this.enablePan ) {
+						let scalePoint;
+						if ( this.object.isOrthographicCamera ) {
+							scalePoint = this.unprojectOnTbPlane( this.object, event.clientX, event.clientY, this.domElement ).applyQuaternion( this.object.quaternion ).multiplyScalar( 1 / this.object.zoom ).add( this._gizmos.position );
+						} else if ( this.object.isPerspectiveCamera ) {
+							scalePoint = this.unprojectOnTbPlane( this.object, event.clientX, event.clientY, this.domElement ).applyQuaternion( this.object.quaternion ).add( this._gizmos.position );
+						}
+						this.applyTransformMatrix( this.scale( size, scalePoint ) );
+					} else {
+						this.applyTransformMatrix( this.scale( size, this._gizmos.position ) );
+					}
+					if ( this._grid != null ) {
+						this.disposeGrid();
+						this.drawGrid();
+					}
+					this.updateTbState( STATE.IDLE, false );
+					this.dispatchEvent( _changeEvent );
+					this.dispatchEvent( _endEvent );
+					break;
+				case 'FOV':
+					if ( this.object.isPerspectiveCamera ) {
+						this.updateTbState( STATE.FOV, true );
+						//Vertigo effect
+						//	  fov / 2
+						//		|\
+						//		| \
+						//		|  \
+						//	x	|	\
+						//		| 	 \
+						//		| 	  \
+						//		| _ _ _\
+						//			y
+						//check for iOs shift shortcut
+						if ( event.deltaX != 0 ) {
+							sgn = event.deltaX / notchDeltaY;
+							size = 1;
+							if ( sgn > 0 ) {
+								size = 1 / ( Math.pow( this.scaleFactor, sgn ) );
+							} else if ( sgn < 0 ) {
+								size = Math.pow( this.scaleFactor, - sgn );
+							}
+						}
+						this._v3_1.setFromMatrixPosition( this._cameraMatrixState );
+						const x = this._v3_1.distanceTo( this._gizmos.position );
+						let xNew = x / size;	//distance between camera and gizmos if scale(size, scalepoint) would be performed
+						//check min and max distance
+						xNew = MathUtils.clamp( xNew, this.minDistance, this.maxDistance );
+						const y = x * Math.tan( MathUtils.DEG2RAD * this.object.fov * 0.5 );
+						//calculate new fov
+						let newFov = MathUtils.RAD2DEG * ( Math.atan( y / xNew ) * 2 );
+						//check min and max fov
+						if ( newFov > this.maxFov ) {
+							newFov = this.maxFov;
+						} else if ( newFov < this.minFov ) {
+							newFov = this.minFov;
+						}
+						const newDistance = y / Math.tan( MathUtils.DEG2RAD * ( newFov / 2 ) );
+						size = x / newDistance;
+						this.setFov( newFov );
+						this.applyTransformMatrix( this.scale( size, this._gizmos.position, false ) );
+					}
+					if ( this._grid != null ) {
+						this.disposeGrid();
+						this.drawGrid();
+					}
+					this.updateTbState( STATE.IDLE, false );
+					this.dispatchEvent( _changeEvent );
+					this.dispatchEvent( _endEvent );
+					break;
+			}
+		}
+	}
+}
+export { ArcballControls };

libs/three.js/0.172.0/jsm/controls/DragControls.js ADDED Viewed

	@@ -0,0 +1,410 @@

+import {
+	Controls,
+	Matrix4,
+	Plane,
+	Raycaster,
+	Vector2,
+	Vector3,
+	MOUSE,
+	TOUCH
+} from 'three';
+const _plane = new Plane();
+const _pointer = new Vector2();
+const _offset = new Vector3();
+const _diff = new Vector2();
+const _previousPointer = new Vector2();
+const _intersection = new Vector3();
+const _worldPosition = new Vector3();
+const _inverseMatrix = new Matrix4();
+const _up = new Vector3();
+const _right = new Vector3();
+let _selected = null, _hovered = null;
+const _intersections = [];
+const STATE = {
+	NONE: - 1,
+	PAN: 0,
+	ROTATE: 1
+};
+class DragControls extends Controls {
+	constructor( objects, camera, domElement = null ) {
+		super( camera, domElement );
+		this.objects = objects;
+		this.recursive = true;
+		this.transformGroup = false;
+		this.rotateSpeed = 1;
+		this.raycaster = new Raycaster();
+		// interaction
+		this.mouseButtons = { LEFT: MOUSE.PAN, MIDDLE: MOUSE.PAN, RIGHT: MOUSE.ROTATE };
+		this.touches = { ONE: TOUCH.PAN };
+		// event listeners
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerCancel = onPointerCancel.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
+		//
+		if ( domElement !== null ) {
+			this.connect();
+		}
+	}
+	connect() {
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointerup', this._onPointerCancel );
+		this.domElement.addEventListener( 'pointerleave', this._onPointerCancel );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+		this.domElement.style.touchAction = 'none'; // disable touch scroll
+	}
+	disconnect() {
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerCancel );
+		this.domElement.removeEventListener( 'pointerleave', this._onPointerCancel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+		this.domElement.style.touchAction = 'auto';
+		this.domElement.style.cursor = '';
+	}
+	dispose() {
+		this.disconnect();
+	}
+	_updatePointer( event ) {
+		const rect = this.domElement.getBoundingClientRect();
+		_pointer.x = ( event.clientX - rect.left ) / rect.width * 2 - 1;
+		_pointer.y = - ( event.clientY - rect.top ) / rect.height * 2 + 1;
+	}
+	_updateState( event ) {
+		// determine action
+		let action;
+		if ( event.pointerType === 'touch' ) {
+			action = this.touches.ONE;
+		} else {
+			switch ( event.button ) {
+				case 0:
+					action = this.mouseButtons.LEFT;
+					break;
+				case 1:
+					action = this.mouseButtons.MIDDLE;
+					break;
+				case 2:
+					action = this.mouseButtons.RIGHT;
+					break;
+				default:
+					action = null;
+			}
+		}
+		// determine state
+		switch ( action ) {
+			case MOUSE.PAN:
+			case TOUCH.PAN:
+				this.state = STATE.PAN;
+				break;
+			case MOUSE.ROTATE:
+			case TOUCH.ROTATE:
+				this.state = STATE.ROTATE;
+				break;
+			default:
+				this.state = STATE.NONE;
+		}
+	}
+	getRaycaster() {
+		console.warn( 'THREE.DragControls: getRaycaster() has been deprecated. Use controls.raycaster instead.' ); // @deprecated r169
+		return this.raycaster;
+	}
+	setObjects( objects ) {
+		console.warn( 'THREE.DragControls: setObjects() has been deprecated. Use controls.objects instead.' ); // @deprecated r169
+		this.objects = objects;
+	}
+	getObjects() {
+		console.warn( 'THREE.DragControls: getObjects() has been deprecated. Use controls.objects instead.' ); // @deprecated r169
+		return this.objects;
+	}
+	activate() {
+		console.warn( 'THREE.DragControls: activate() has been renamed to connect().' ); // @deprecated r169
+		this.connect();
+	}
+	deactivate() {
+		console.warn( 'THREE.DragControls: deactivate() has been renamed to disconnect().' ); // @deprecated r169
+		this.disconnect();
+	}
+	set mode( value ) {
+		console.warn( 'THREE.DragControls: The .mode property has been removed. Define the type of transformation via the .mouseButtons or .touches properties.' ); // @deprecated r169
+	}
+	get mode() {
+		console.warn( 'THREE.DragControls: The .mode property has been removed. Define the type of transformation via the .mouseButtons or .touches properties.' ); // @deprecated r169
+	}
+}
+function onPointerMove( event ) {
+	const camera = this.object;
+	const domElement = this.domElement;
+	const raycaster = this.raycaster;
+	if ( this.enabled === false ) return;
+	this._updatePointer( event );
+	raycaster.setFromCamera( _pointer, camera );
+	if ( _selected ) {
+		if ( this.state === STATE.PAN ) {
+			if ( raycaster.ray.intersectPlane( _plane, _intersection ) ) {
+				_selected.position.copy( _intersection.sub( _offset ).applyMatrix4( _inverseMatrix ) );
+			}
+		} else if ( this.state === STATE.ROTATE ) {
+			_diff.subVectors( _pointer, _previousPointer ).multiplyScalar( this.rotateSpeed );
+			_selected.rotateOnWorldAxis( _up, _diff.x );
+			_selected.rotateOnWorldAxis( _right.normalize(), - _diff.y );
+		}
+		this.dispatchEvent( { type: 'drag', object: _selected } );
+		_previousPointer.copy( _pointer );
+	} else {
+		// hover support
+		if ( event.pointerType === 'mouse' || event.pointerType === 'pen' ) {
+			_intersections.length = 0;
+			raycaster.setFromCamera( _pointer, camera );
+			raycaster.intersectObjects( this.objects, this.recursive, _intersections );
+			if ( _intersections.length > 0 ) {
+				const object = _intersections[ 0 ].object;
+				_plane.setFromNormalAndCoplanarPoint( camera.getWorldDirection( _plane.normal ), _worldPosition.setFromMatrixPosition( object.matrixWorld ) );
+				if ( _hovered !== object && _hovered !== null ) {
+					this.dispatchEvent( { type: 'hoveroff', object: _hovered } );
+					domElement.style.cursor = 'auto';
+					_hovered = null;
+				}
+				if ( _hovered !== object ) {
+					this.dispatchEvent( { type: 'hoveron', object: object } );
+					domElement.style.cursor = 'pointer';
+					_hovered = object;
+				}
+			} else {
+				if ( _hovered !== null ) {
+					this.dispatchEvent( { type: 'hoveroff', object: _hovered } );
+					domElement.style.cursor = 'auto';
+					_hovered = null;
+				}
+			}
+		}
+	}
+	_previousPointer.copy( _pointer );
+}
+function onPointerDown( event ) {
+	const camera = this.object;
+	const domElement = this.domElement;
+	const raycaster = this.raycaster;
+	if ( this.enabled === false ) return;
+	this._updatePointer( event );
+	this._updateState( event );
+	_intersections.length = 0;
+	raycaster.setFromCamera( _pointer, camera );
+	raycaster.intersectObjects( this.objects, this.recursive, _intersections );
+	if ( _intersections.length > 0 ) {
+		if ( this.transformGroup === true ) {
+			// look for the outermost group in the object's upper hierarchy
+			_selected = findGroup( _intersections[ 0 ].object );
+		} else {
+			_selected = _intersections[ 0 ].object;
+		}
+		_plane.setFromNormalAndCoplanarPoint( camera.getWorldDirection( _plane.normal ), _worldPosition.setFromMatrixPosition( _selected.matrixWorld ) );
+		if ( raycaster.ray.intersectPlane( _plane, _intersection ) ) {
+			if ( this.state === STATE.PAN ) {
+				_inverseMatrix.copy( _selected.parent.matrixWorld ).invert();
+				_offset.copy( _intersection ).sub( _worldPosition.setFromMatrixPosition( _selected.matrixWorld ) );
+			} else if ( this.state === STATE.ROTATE ) {
+				// the controls only support Y+ up
+				_up.set( 0, 1, 0 ).applyQuaternion( camera.quaternion ).normalize();
+				_right.set( 1, 0, 0 ).applyQuaternion( camera.quaternion ).normalize();
+			}
+		}
+		domElement.style.cursor = 'move';
+		this.dispatchEvent( { type: 'dragstart', object: _selected } );
+	}
+	_previousPointer.copy( _pointer );
+}
+function onPointerCancel() {
+	if ( this.enabled === false ) return;
+	if ( _selected ) {
+		this.dispatchEvent( { type: 'dragend', object: _selected } );
+		_selected = null;
+	}
+	this.domElement.style.cursor = _hovered ? 'pointer' : 'auto';
+	this.state = STATE.NONE;
+}
+function onContextMenu( event ) {
+	if ( this.enabled === false ) return;
+	event.preventDefault();
+}
+function findGroup( obj, group = null ) {
+	if ( obj.isGroup ) group = obj;
+	if ( obj.parent === null ) return group;
+	return findGroup( obj.parent, group );
+}
+export { DragControls };

libs/three.js/0.172.0/jsm/controls/FirstPersonControls.js ADDED Viewed

	@@ -0,0 +1,337 @@

+import {
+	Controls,
+	MathUtils,
+	Spherical,
+	Vector3
+} from 'three';
+const _lookDirection = new Vector3();
+const _spherical = new Spherical();
+const _target = new Vector3();
+const _targetPosition = new Vector3();
+class FirstPersonControls extends Controls {
+	constructor( object, domElement = null ) {
+		super( object, domElement );
+		// API
+		this.movementSpeed = 1.0;
+		this.lookSpeed = 0.005;
+		this.lookVertical = true;
+		this.autoForward = false;
+		this.activeLook = true;
+		this.heightSpeed = false;
+		this.heightCoef = 1.0;
+		this.heightMin = 0.0;
+		this.heightMax = 1.0;
+		this.constrainVertical = false;
+		this.verticalMin = 0;
+		this.verticalMax = Math.PI;
+		this.mouseDragOn = false;
+		// internals
+		this._autoSpeedFactor = 0.0;
+		this._pointerX = 0;
+		this._pointerY = 0;
+		this._moveForward = false;
+		this._moveBackward = false;
+		this._moveLeft = false;
+		this._moveRight = false;
+		this._viewHalfX = 0;
+		this._viewHalfY = 0;
+		this._lat = 0;
+		this._lon = 0;
+		// event listeners
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
+		this._onKeyDown = onKeyDown.bind( this );
+		this._onKeyUp = onKeyUp.bind( this );
+		//
+		if ( domElement !== null ) {
+			this.connect();
+			this.handleResize();
+		}
+		this._setOrientation();
+	}
+	connect() {
+		window.addEventListener( 'keydown', this._onKeyDown );
+		window.addEventListener( 'keyup', this._onKeyUp );
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+	}
+	disconnect() {
+		window.removeEventListener( 'keydown', this._onKeyDown );
+		window.removeEventListener( 'keyup', this._onKeyUp );
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+	}
+	dispose() {
+		this.disconnect();
+	}
+	handleResize() {
+		if ( this.domElement === document ) {
+			this._viewHalfX = window.innerWidth / 2;
+			this._viewHalfY = window.innerHeight / 2;
+		} else {
+			this._viewHalfX = this.domElement.offsetWidth / 2;
+			this._viewHalfY = this.domElement.offsetHeight / 2;
+		}
+	}
+	lookAt( x, y, z ) {
+		if ( x.isVector3 ) {
+			_target.copy( x );
+		} else {
+			_target.set( x, y, z );
+		}
+		this.object.lookAt( _target );
+		this._setOrientation();
+		return this;
+	}
+	update( delta ) {
+		if ( this.enabled === false ) return;
+		if ( this.heightSpeed ) {
+			const y = MathUtils.clamp( this.object.position.y, this.heightMin, this.heightMax );
+			const heightDelta = y - this.heightMin;
+			this._autoSpeedFactor = delta * ( heightDelta * this.heightCoef );
+		} else {
+			this._autoSpeedFactor = 0.0;
+		}
+		const actualMoveSpeed = delta * this.movementSpeed;
+		if ( this._moveForward || ( this.autoForward && ! this._moveBackward ) ) this.object.translateZ( - ( actualMoveSpeed + this._autoSpeedFactor ) );
+		if ( this._moveBackward ) this.object.translateZ( actualMoveSpeed );
+		if ( this._moveLeft ) this.object.translateX( - actualMoveSpeed );
+		if ( this._moveRight ) this.object.translateX( actualMoveSpeed );
+		if ( this._moveUp ) this.object.translateY( actualMoveSpeed );
+		if ( this._moveDown ) this.object.translateY( - actualMoveSpeed );
+		let actualLookSpeed = delta * this.lookSpeed;
+		if ( ! this.activeLook ) {
+			actualLookSpeed = 0;
+		}
+		let verticalLookRatio = 1;
+		if ( this.constrainVertical ) {
+			verticalLookRatio = Math.PI / ( this.verticalMax - this.verticalMin );
+		}
+		this._lon -= this._pointerX * actualLookSpeed;
+		if ( this.lookVertical ) this._lat -= this._pointerY * actualLookSpeed * verticalLookRatio;
+		this._lat = Math.max( - 85, Math.min( 85, this._lat ) );
+		let phi = MathUtils.degToRad( 90 - this._lat );
+		const theta = MathUtils.degToRad( this._lon );
+		if ( this.constrainVertical ) {
+			phi = MathUtils.mapLinear( phi, 0, Math.PI, this.verticalMin, this.verticalMax );
+		}
+		const position = this.object.position;
+		_targetPosition.setFromSphericalCoords( 1, phi, theta ).add( position );
+		this.object.lookAt( _targetPosition );
+	}
+	_setOrientation() {
+		const quaternion = this.object.quaternion;
+		_lookDirection.set( 0, 0, - 1 ).applyQuaternion( quaternion );
+		_spherical.setFromVector3( _lookDirection );
+		this._lat = 90 - MathUtils.radToDeg( _spherical.phi );
+		this._lon = MathUtils.radToDeg( _spherical.theta );
+	}
+}
+function onPointerDown( event ) {
+	if ( this.domElement !== document ) {
+		this.domElement.focus();
+	}
+	if ( this.activeLook ) {
+		switch ( event.button ) {
+			case 0: this._moveForward = true; break;
+			case 2: this._moveBackward = true; break;
+		}
+	}
+	this.mouseDragOn = true;
+}
+function onPointerUp( event ) {
+	if ( this.activeLook ) {
+		switch ( event.button ) {
+			case 0: this._moveForward = false; break;
+			case 2: this._moveBackward = false; break;
+		}
+	}
+	this.mouseDragOn = false;
+}
+function onPointerMove( event ) {
+	if ( this.domElement === document ) {
+		this._pointerX = event.pageX - this._viewHalfX;
+		this._pointerY = event.pageY - this._viewHalfY;
+	} else {
+		this._pointerX = event.pageX - this.domElement.offsetLeft - this._viewHalfX;
+		this._pointerY = event.pageY - this.domElement.offsetTop - this._viewHalfY;
+	}
+}
+function onKeyDown( event ) {
+	switch ( event.code ) {
+		case 'ArrowUp':
+		case 'KeyW': this._moveForward = true; break;
+		case 'ArrowLeft':
+		case 'KeyA': this._moveLeft = true; break;
+		case 'ArrowDown':
+		case 'KeyS': this._moveBackward = true; break;
+		case 'ArrowRight':
+		case 'KeyD': this._moveRight = true; break;
+		case 'KeyR': this._moveUp = true; break;
+		case 'KeyF': this._moveDown = true; break;
+	}
+}
+function onKeyUp( event ) {
+	switch ( event.code ) {
+		case 'ArrowUp':
+		case 'KeyW': this._moveForward = false; break;
+		case 'ArrowLeft':
+		case 'KeyA': this._moveLeft = false; break;
+		case 'ArrowDown':
+		case 'KeyS': this._moveBackward = false; break;
+		case 'ArrowRight':
+		case 'KeyD': this._moveRight = false; break;
+		case 'KeyR': this._moveUp = false; break;
+		case 'KeyF': this._moveDown = false; break;
+	}
+}
+function onContextMenu( event ) {
+	if ( this.enabled === false ) return;
+	event.preventDefault();
+}
+export { FirstPersonControls };

libs/three.js/0.172.0/jsm/controls/FlyControls.js ADDED Viewed

	@@ -0,0 +1,332 @@

+import {
+	Controls,
+	Quaternion,
+	Vector3
+} from 'three';
+const _changeEvent = { type: 'change' };
+const _EPS = 0.000001;
+const _tmpQuaternion = new Quaternion();
+class FlyControls extends Controls {
+	constructor( object, domElement = null ) {
+		super( object, domElement );
+		this.movementSpeed = 1.0;
+		this.rollSpeed = 0.005;
+		this.dragToLook = false;
+		this.autoForward = false;
+		// internals
+		this._moveState = { up: 0, down: 0, left: 0, right: 0, forward: 0, back: 0, pitchUp: 0, pitchDown: 0, yawLeft: 0, yawRight: 0, rollLeft: 0, rollRight: 0 };
+		this._moveVector = new Vector3( 0, 0, 0 );
+		this._rotationVector = new Vector3( 0, 0, 0 );
+		this._lastQuaternion = new Quaternion();
+		this._lastPosition = new Vector3();
+		this._status = 0;
+		// event listeners
+		this._onKeyDown = onKeyDown.bind( this );
+		this._onKeyUp = onKeyUp.bind( this );
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		this._onPointerCancel = onPointerCancel.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
+		//
+		if ( domElement !== null ) {
+			this.connect();
+		}
+	}
+	connect() {
+		window.addEventListener( 'keydown', this._onKeyDown );
+		window.addEventListener( 'keyup', this._onKeyUp );
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.addEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+	}
+	disconnect() {
+		window.removeEventListener( 'keydown', this._onKeyDown );
+		window.removeEventListener( 'keyup', this._onKeyUp );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.removeEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+	}
+	dispose() {
+		this.disconnect();
+	}
+	update( delta ) {
+		if ( this.enabled === false ) return;
+		const object = this.object;
+		const moveMult = delta * this.movementSpeed;
+		const rotMult = delta * this.rollSpeed;
+		object.translateX( this._moveVector.x * moveMult );
+		object.translateY( this._moveVector.y * moveMult );
+		object.translateZ( this._moveVector.z * moveMult );
+		_tmpQuaternion.set( this._rotationVector.x * rotMult, this._rotationVector.y * rotMult, this._rotationVector.z * rotMult, 1 ).normalize();
+		object.quaternion.multiply( _tmpQuaternion );
+		if (
+			this._lastPosition.distanceToSquared( object.position ) > _EPS ||
+			8 * ( 1 - this._lastQuaternion.dot( object.quaternion ) ) > _EPS
+		) {
+			this.dispatchEvent( _changeEvent );
+			this._lastQuaternion.copy( object.quaternion );
+			this._lastPosition.copy( object.position );
+		}
+	}
+	// private
+	_updateMovementVector() {
+		const forward = ( this._moveState.forward || ( this.autoForward && ! this._moveState.back ) ) ? 1 : 0;
+		this._moveVector.x = ( - this._moveState.left + this._moveState.right );
+		this._moveVector.y = ( - this._moveState.down + this._moveState.up );
+		this._moveVector.z = ( - forward + this._moveState.back );
+		//console.log( 'move:', [ this._moveVector.x, this._moveVector.y, this._moveVector.z ] );
+	}
+	_updateRotationVector() {
+		this._rotationVector.x = ( - this._moveState.pitchDown + this._moveState.pitchUp );
+		this._rotationVector.y = ( - this._moveState.yawRight + this._moveState.yawLeft );
+		this._rotationVector.z = ( - this._moveState.rollRight + this._moveState.rollLeft );
+		//console.log( 'rotate:', [ this._rotationVector.x, this._rotationVector.y, this._rotationVector.z ] );
+	}
+	_getContainerDimensions() {
+		if ( this.domElement != document ) {
+			return {
+				size: [ this.domElement.offsetWidth, this.domElement.offsetHeight ],
+				offset: [ this.domElement.offsetLeft, this.domElement.offsetTop ]
+			};
+		} else {
+			return {
+				size: [ window.innerWidth, window.innerHeight ],
+				offset: [ 0, 0 ]
+			};
+		}
+	}
+}
+function onKeyDown( event ) {
+	if ( event.altKey || this.enabled === false ) {
+		return;
+	}
+	switch ( event.code ) {
+		case 'ShiftLeft':
+		case 'ShiftRight': this.movementSpeedMultiplier = .1; break;
+		case 'KeyW': this._moveState.forward = 1; break;
+		case 'KeyS': this._moveState.back = 1; break;
+		case 'KeyA': this._moveState.left = 1; break;
+		case 'KeyD': this._moveState.right = 1; break;
+		case 'KeyR': this._moveState.up = 1; break;
+		case 'KeyF': this._moveState.down = 1; break;
+		case 'ArrowUp': this._moveState.pitchUp = 1; break;
+		case 'ArrowDown': this._moveState.pitchDown = 1; break;
+		case 'ArrowLeft': this._moveState.yawLeft = 1; break;
+		case 'ArrowRight': this._moveState.yawRight = 1; break;
+		case 'KeyQ': this._moveState.rollLeft = 1; break;
+		case 'KeyE': this._moveState.rollRight = 1; break;
+	}
+	this._updateMovementVector();
+	this._updateRotationVector();
+}
+function onKeyUp( event ) {
+	if ( this.enabled === false ) return;
+	switch ( event.code ) {
+		case 'ShiftLeft':
+		case 'ShiftRight': this.movementSpeedMultiplier = 1; break;
+		case 'KeyW': this._moveState.forward = 0; break;
+		case 'KeyS': this._moveState.back = 0; break;
+		case 'KeyA': this._moveState.left = 0; break;
+		case 'KeyD': this._moveState.right = 0; break;
+		case 'KeyR': this._moveState.up = 0; break;
+		case 'KeyF': this._moveState.down = 0; break;
+		case 'ArrowUp': this._moveState.pitchUp = 0; break;
+		case 'ArrowDown': this._moveState.pitchDown = 0; break;
+		case 'ArrowLeft': this._moveState.yawLeft = 0; break;
+		case 'ArrowRight': this._moveState.yawRight = 0; break;
+		case 'KeyQ': this._moveState.rollLeft = 0; break;
+		case 'KeyE': this._moveState.rollRight = 0; break;
+	}
+	this._updateMovementVector();
+	this._updateRotationVector();
+}
+function onPointerDown( event ) {
+	if ( this.enabled === false ) return;
+	if ( this.dragToLook ) {
+		this._status ++;
+	} else {
+		switch ( event.button ) {
+			case 0: this._moveState.forward = 1; break;
+			case 2: this._moveState.back = 1; break;
+		}
+		this._updateMovementVector();
+	}
+}
+function onPointerMove( event ) {
+	if ( this.enabled === false ) return;
+	if ( ! this.dragToLook || this._status > 0 ) {
+		const container = this._getContainerDimensions();
+		const halfWidth = container.size[ 0 ] / 2;
+		const halfHeight = container.size[ 1 ] / 2;
+		this._moveState.yawLeft = - ( ( event.pageX - container.offset[ 0 ] ) - halfWidth ) / halfWidth;
+		this._moveState.pitchDown = ( ( event.pageY - container.offset[ 1 ] ) - halfHeight ) / halfHeight;
+		this._updateRotationVector();
+	}
+}
+function onPointerUp( event ) {
+	if ( this.enabled === false ) return;
+	if ( this.dragToLook ) {
+		this._status --;
+		this._moveState.yawLeft = this._moveState.pitchDown = 0;
+	} else {
+		switch ( event.button ) {
+			case 0: this._moveState.forward = 0; break;
+			case 2: this._moveState.back = 0; break;
+		}
+		this._updateMovementVector();
+	}
+	this._updateRotationVector();
+}
+function onPointerCancel() {
+	if ( this.enabled === false ) return;
+	if ( this.dragToLook ) {
+		this._status = 0;
+		this._moveState.yawLeft = this._moveState.pitchDown = 0;
+	} else {
+		this._moveState.forward = 0;
+		this._moveState.back = 0;
+		this._updateMovementVector();
+	}
+	this._updateRotationVector();
+}
+function onContextMenu( event ) {
+	if ( this.enabled === false ) return;
+	event.preventDefault();
+}
+export { FlyControls };

libs/three.js/0.172.0/jsm/controls/MapControls.js ADDED Viewed

	@@ -0,0 +1,28 @@

+import { MOUSE, TOUCH } from 'three';
+import { OrbitControls } from './OrbitControls.js';
+// MapControls performs orbiting, dollying (zooming), and panning.
+// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+//
+//    Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate
+//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+//    Pan - left mouse, or arrow keys / touch: one-finger move
+class MapControls extends OrbitControls {
+	constructor( object, domElement ) {
+		super( object, domElement );
+		this.screenSpacePanning = false; // pan orthogonal to world-space direction camera.up
+		this.mouseButtons = { LEFT: MOUSE.PAN, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.ROTATE };
+		this.touches = { ONE: TOUCH.PAN, TWO: TOUCH.DOLLY_ROTATE };
+	}
+}
+export { MapControls };

libs/three.js/0.172.0/jsm/controls/OrbitControls.js ADDED Viewed

	@@ -0,0 +1,1556 @@

+import {
+	Controls,
+	MOUSE,
+	Quaternion,
+	Spherical,
+	TOUCH,
+	Vector2,
+	Vector3,
+	Plane,
+	Ray,
+	MathUtils
+} from 'three';
+// OrbitControls performs orbiting, dollying (zooming), and panning.
+// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+//
+//    Orbit - left mouse / touch: one-finger move
+//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+//    Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move
+const _changeEvent = { type: 'change' };
+const _startEvent = { type: 'start' };
+const _endEvent = { type: 'end' };
+const _ray = new Ray();
+const _plane = new Plane();
+const _TILT_LIMIT = Math.cos( 70 * MathUtils.DEG2RAD );
+const _v = new Vector3();
+const _twoPI = 2 * Math.PI;
+const _STATE = {
+	NONE: - 1,
+	ROTATE: 0,
+	DOLLY: 1,
+	PAN: 2,
+	TOUCH_ROTATE: 3,
+	TOUCH_PAN: 4,
+	TOUCH_DOLLY_PAN: 5,
+	TOUCH_DOLLY_ROTATE: 6
+};
+const _EPS = 0.000001;
+class OrbitControls extends Controls {
+	constructor( object, domElement = null ) {
+		super( object, domElement );
+		this.state = _STATE.NONE;
+		// Set to false to disable this control
+		this.enabled = true;
+		// "target" sets the location of focus, where the object orbits around
+		this.target = new Vector3();
+		// Sets the 3D cursor (similar to Blender), from which the maxTargetRadius takes effect
+		this.cursor = new Vector3();
+		// How far you can dolly in and out ( PerspectiveCamera only )
+		this.minDistance = 0;
+		this.maxDistance = Infinity;
+		// How far you can zoom in and out ( OrthographicCamera only )
+		this.minZoom = 0;
+		this.maxZoom = Infinity;
+		// Limit camera target within a spherical area around the cursor
+		this.minTargetRadius = 0;
+		this.maxTargetRadius = Infinity;
+		// How far you can orbit vertically, upper and lower limits.
+		// Range is 0 to Math.PI radians.
+		this.minPolarAngle = 0; // radians
+		this.maxPolarAngle = Math.PI; // radians
+		// How far you can orbit horizontally, upper and lower limits.
+		// If set, the interval [ min, max ] must be a sub-interval of [ - 2 PI, 2 PI ], with ( max - min < 2 PI )
+		this.minAzimuthAngle = - Infinity; // radians
+		this.maxAzimuthAngle = Infinity; // radians
+		// Set to true to enable damping (inertia)
+		// If damping is enabled, you must call controls.update() in your animation loop
+		this.enableDamping = false;
+		this.dampingFactor = 0.05;
+		// This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
+		// Set to false to disable zooming
+		this.enableZoom = true;
+		this.zoomSpeed = 1.0;
+		// Set to false to disable rotating
+		this.enableRotate = true;
+		this.rotateSpeed = 1.0;
+		this.keyRotateSpeed = 1.0;
+		// Set to false to disable panning
+		this.enablePan = true;
+		this.panSpeed = 1.0;
+		this.screenSpacePanning = true; // if false, pan orthogonal to world-space direction camera.up
+		this.keyPanSpeed = 7.0;	// pixels moved per arrow key push
+		this.zoomToCursor = false;
+		// Set to true to automatically rotate around the target
+		// If auto-rotate is enabled, you must call controls.update() in your animation loop
+		this.autoRotate = false;
+		this.autoRotateSpeed = 2.0; // 30 seconds per orbit when fps is 60
+		// The four arrow keys
+		this.keys = { LEFT: 'ArrowLeft', UP: 'ArrowUp', RIGHT: 'ArrowRight', BOTTOM: 'ArrowDown' };
+		// Mouse buttons
+		this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
+		// Touch fingers
+		this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
+		// for reset
+		this.target0 = this.target.clone();
+		this.position0 = this.object.position.clone();
+		this.zoom0 = this.object.zoom;
+		// the target DOM element for key events
+		this._domElementKeyEvents = null;
+		// internals
+		this._lastPosition = new Vector3();
+		this._lastQuaternion = new Quaternion();
+		this._lastTargetPosition = new Vector3();
+		// so camera.up is the orbit axis
+		this._quat = new Quaternion().setFromUnitVectors( object.up, new Vector3( 0, 1, 0 ) );
+		this._quatInverse = this._quat.clone().invert();
+		// current position in spherical coordinates
+		this._spherical = new Spherical();
+		this._sphericalDelta = new Spherical();
+		this._scale = 1;
+		this._panOffset = new Vector3();
+		this._rotateStart = new Vector2();
+		this._rotateEnd = new Vector2();
+		this._rotateDelta = new Vector2();
+		this._panStart = new Vector2();
+		this._panEnd = new Vector2();
+		this._panDelta = new Vector2();
+		this._dollyStart = new Vector2();
+		this._dollyEnd = new Vector2();
+		this._dollyDelta = new Vector2();
+		this._dollyDirection = new Vector3();
+		this._mouse = new Vector2();
+		this._performCursorZoom = false;
+		this._pointers = [];
+		this._pointerPositions = {};
+		this._controlActive = false;
+		// event listeners
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
+		this._onMouseWheel = onMouseWheel.bind( this );
+		this._onKeyDown = onKeyDown.bind( this );
+		this._onTouchStart = onTouchStart.bind( this );
+		this._onTouchMove = onTouchMove.bind( this );
+		this._onMouseDown = onMouseDown.bind( this );
+		this._onMouseMove = onMouseMove.bind( this );
+		this._interceptControlDown = interceptControlDown.bind( this );
+		this._interceptControlUp = interceptControlUp.bind( this );
+		//
+		if ( this.domElement !== null ) {
+			this.connect();
+		}
+		this.update();
+	}
+	connect() {
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointercancel', this._onPointerUp );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+		this.domElement.addEventListener( 'wheel', this._onMouseWheel, { passive: false } );
+		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
+		document.addEventListener( 'keydown', this._interceptControlDown, { passive: true, capture: true } );
+		this.domElement.style.touchAction = 'none'; // disable touch scroll
+	}
+	disconnect() {
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.removeEventListener( 'pointercancel', this._onPointerUp );
+		this.domElement.removeEventListener( 'wheel', this._onMouseWheel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+		this.stopListenToKeyEvents();
+		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
+		document.removeEventListener( 'keydown', this._interceptControlDown, { capture: true } );
+		this.domElement.style.touchAction = 'auto';
+	}
+	dispose() {
+		this.disconnect();
+	}
+	getPolarAngle() {
+		return this._spherical.phi;
+	}
+	getAzimuthalAngle() {
+		return this._spherical.theta;
+	}
+	getDistance() {
+		return this.object.position.distanceTo( this.target );
+	}
+	listenToKeyEvents( domElement ) {
+		domElement.addEventListener( 'keydown', this._onKeyDown );
+		this._domElementKeyEvents = domElement;
+	}
+	stopListenToKeyEvents() {
+		if ( this._domElementKeyEvents !== null ) {
+			this._domElementKeyEvents.removeEventListener( 'keydown', this._onKeyDown );
+			this._domElementKeyEvents = null;
+		}
+	}
+	saveState() {
+		this.target0.copy( this.target );
+		this.position0.copy( this.object.position );
+		this.zoom0 = this.object.zoom;
+	}
+	reset() {
+		this.target.copy( this.target0 );
+		this.object.position.copy( this.position0 );
+		this.object.zoom = this.zoom0;
+		this.object.updateProjectionMatrix();
+		this.dispatchEvent( _changeEvent );
+		this.update();
+		this.state = _STATE.NONE;
+	}
+	update( deltaTime = null ) {
+		const position = this.object.position;
+		_v.copy( position ).sub( this.target );
+		// rotate offset to "y-axis-is-up" space
+		_v.applyQuaternion( this._quat );
+		// angle from z-axis around y-axis
+		this._spherical.setFromVector3( _v );
+		if ( this.autoRotate && this.state === _STATE.NONE ) {
+			this._rotateLeft( this._getAutoRotationAngle( deltaTime ) );
+		}
+		if ( this.enableDamping ) {
+			this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor;
+			this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor;
+		} else {
+			this._spherical.theta += this._sphericalDelta.theta;
+			this._spherical.phi += this._sphericalDelta.phi;
+		}
+		// restrict theta to be between desired limits
+		let min = this.minAzimuthAngle;
+		let max = this.maxAzimuthAngle;
+		if ( isFinite( min ) && isFinite( max ) ) {
+			if ( min < - Math.PI ) min += _twoPI; else if ( min > Math.PI ) min -= _twoPI;
+			if ( max < - Math.PI ) max += _twoPI; else if ( max > Math.PI ) max -= _twoPI;
+			if ( min <= max ) {
+				this._spherical.theta = Math.max( min, Math.min( max, this._spherical.theta ) );
+			} else {
+				this._spherical.theta = ( this._spherical.theta > ( min + max ) / 2 ) ?
+					Math.max( min, this._spherical.theta ) :
+					Math.min( max, this._spherical.theta );
+			}
+		}
+		// restrict phi to be between desired limits
+		this._spherical.phi = Math.max( this.minPolarAngle, Math.min( this.maxPolarAngle, this._spherical.phi ) );
+		this._spherical.makeSafe();
+		// move target to panned location
+		if ( this.enableDamping === true ) {
+			this.target.addScaledVector( this._panOffset, this.dampingFactor );
+		} else {
+			this.target.add( this._panOffset );
+		}
+		// Limit the target distance from the cursor to create a sphere around the center of interest
+		this.target.sub( this.cursor );
+		this.target.clampLength( this.minTargetRadius, this.maxTargetRadius );
+		this.target.add( this.cursor );
+		let zoomChanged = false;
+		// adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera
+		// we adjust zoom later in these cases
+		if ( this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera ) {
+			this._spherical.radius = this._clampDistance( this._spherical.radius );
+		} else {
+			const prevRadius = this._spherical.radius;
+			this._spherical.radius = this._clampDistance( this._spherical.radius * this._scale );
+			zoomChanged = prevRadius != this._spherical.radius;
+		}
+		_v.setFromSpherical( this._spherical );
+		// rotate offset back to "camera-up-vector-is-up" space
+		_v.applyQuaternion( this._quatInverse );
+		position.copy( this.target ).add( _v );
+		this.object.lookAt( this.target );
+		if ( this.enableDamping === true ) {
+			this._sphericalDelta.theta *= ( 1 - this.dampingFactor );
+			this._sphericalDelta.phi *= ( 1 - this.dampingFactor );
+			this._panOffset.multiplyScalar( 1 - this.dampingFactor );
+		} else {
+			this._sphericalDelta.set( 0, 0, 0 );
+			this._panOffset.set( 0, 0, 0 );
+		}
+		// adjust camera position
+		if ( this.zoomToCursor && this._performCursorZoom ) {
+			let newRadius = null;
+			if ( this.object.isPerspectiveCamera ) {
+				// move the camera down the pointer ray
+				// this method avoids floating point error
+				const prevRadius = _v.length();
+				newRadius = this._clampDistance( prevRadius * this._scale );
+				const radiusDelta = prevRadius - newRadius;
+				this.object.position.addScaledVector( this._dollyDirection, radiusDelta );
+				this.object.updateMatrixWorld();
+				zoomChanged = !! radiusDelta;
+			} else if ( this.object.isOrthographicCamera ) {
+				// adjust the ortho camera position based on zoom changes
+				const mouseBefore = new Vector3( this._mouse.x, this._mouse.y, 0 );
+				mouseBefore.unproject( this.object );
+				const prevZoom = this.object.zoom;
+				this.object.zoom = Math.max( this.minZoom, Math.min( this.maxZoom, this.object.zoom / this._scale ) );
+				this.object.updateProjectionMatrix();
+				zoomChanged = prevZoom !== this.object.zoom;
+				const mouseAfter = new Vector3( this._mouse.x, this._mouse.y, 0 );
+				mouseAfter.unproject( this.object );
+				this.object.position.sub( mouseAfter ).add( mouseBefore );
+				this.object.updateMatrixWorld();
+				newRadius = _v.length();
+			} else {
+				console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.' );
+				this.zoomToCursor = false;
+			}
+			// handle the placement of the target
+			if ( newRadius !== null ) {
+				if ( this.screenSpacePanning ) {
+					// position the orbit target in front of the new camera position
+					this.target.set( 0, 0, - 1 )
+						.transformDirection( this.object.matrix )
+						.multiplyScalar( newRadius )
+						.add( this.object.position );
+				} else {
+					// get the ray and translation plane to compute target
+					_ray.origin.copy( this.object.position );
+					_ray.direction.set( 0, 0, - 1 ).transformDirection( this.object.matrix );
+					// if the camera is 20 degrees above the horizon then don't adjust the focus target to avoid
+					// extremely large values
+					if ( Math.abs( this.object.up.dot( _ray.direction ) ) < _TILT_LIMIT ) {
+						this.object.lookAt( this.target );
+					} else {
+						_plane.setFromNormalAndCoplanarPoint( this.object.up, this.target );
+						_ray.intersectPlane( _plane, this.target );
+					}
+				}
+			}
+		} else if ( this.object.isOrthographicCamera ) {
+			const prevZoom = this.object.zoom;
+			this.object.zoom = Math.max( this.minZoom, Math.min( this.maxZoom, this.object.zoom / this._scale ) );
+			if ( prevZoom !== this.object.zoom ) {
+				this.object.updateProjectionMatrix();
+				zoomChanged = true;
+			}
+		}
+		this._scale = 1;
+		this._performCursorZoom = false;
+		// update condition is:
+		// min(camera displacement, camera rotation in radians)^2 > EPS
+		// using small-angle approximation cos(x/2) = 1 - x^2 / 8
+		if ( zoomChanged ||
+			this._lastPosition.distanceToSquared( this.object.position ) > _EPS ||
+			8 * ( 1 - this._lastQuaternion.dot( this.object.quaternion ) ) > _EPS ||
+			this._lastTargetPosition.distanceToSquared( this.target ) > _EPS ) {
+			this.dispatchEvent( _changeEvent );
+			this._lastPosition.copy( this.object.position );
+			this._lastQuaternion.copy( this.object.quaternion );
+			this._lastTargetPosition.copy( this.target );
+			return true;
+		}
+		return false;
+	}
+	_getAutoRotationAngle( deltaTime ) {
+		if ( deltaTime !== null ) {
+			return ( _twoPI / 60 * this.autoRotateSpeed ) * deltaTime;
+		} else {
+			return _twoPI / 60 / 60 * this.autoRotateSpeed;
+		}
+	}
+	_getZoomScale( delta ) {
+		const normalizedDelta = Math.abs( delta * 0.01 );
+		return Math.pow( 0.95, this.zoomSpeed * normalizedDelta );
+	}
+	_rotateLeft( angle ) {
+		this._sphericalDelta.theta -= angle;
+	}
+	_rotateUp( angle ) {
+		this._sphericalDelta.phi -= angle;
+	}
+	_panLeft( distance, objectMatrix ) {
+		_v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix
+		_v.multiplyScalar( - distance );
+		this._panOffset.add( _v );
+	}
+	_panUp( distance, objectMatrix ) {
+		if ( this.screenSpacePanning === true ) {
+			_v.setFromMatrixColumn( objectMatrix, 1 );
+		} else {
+			_v.setFromMatrixColumn( objectMatrix, 0 );
+			_v.crossVectors( this.object.up, _v );
+		}
+		_v.multiplyScalar( distance );
+		this._panOffset.add( _v );
+	}
+	// deltaX and deltaY are in pixels; right and down are positive
+	_pan( deltaX, deltaY ) {
+		const element = this.domElement;
+		if ( this.object.isPerspectiveCamera ) {
+			// perspective
+			const position = this.object.position;
+			_v.copy( position ).sub( this.target );
+			let targetDistance = _v.length();
+			// half of the fov is center to top of screen
+			targetDistance *= Math.tan( ( this.object.fov / 2 ) * Math.PI / 180.0 );
+			// we use only clientHeight here so aspect ratio does not distort speed
+			this._panLeft( 2 * deltaX * targetDistance / element.clientHeight, this.object.matrix );
+			this._panUp( 2 * deltaY * targetDistance / element.clientHeight, this.object.matrix );
+		} else if ( this.object.isOrthographicCamera ) {
+			// orthographic
+			this._panLeft( deltaX * ( this.object.right - this.object.left ) / this.object.zoom / element.clientWidth, this.object.matrix );
+			this._panUp( deltaY * ( this.object.top - this.object.bottom ) / this.object.zoom / element.clientHeight, this.object.matrix );
+		} else {
+			// camera neither orthographic nor perspective
+			console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
+			this.enablePan = false;
+		}
+	}
+	_dollyOut( dollyScale ) {
+		if ( this.object.isPerspectiveCamera || this.object.isOrthographicCamera ) {
+			this._scale /= dollyScale;
+		} else {
+			console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+			this.enableZoom = false;
+		}
+	}
+	_dollyIn( dollyScale ) {
+		if ( this.object.isPerspectiveCamera || this.object.isOrthographicCamera ) {
+			this._scale *= dollyScale;
+		} else {
+			console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+			this.enableZoom = false;
+		}
+	}
+	_updateZoomParameters( x, y ) {
+		if ( ! this.zoomToCursor ) {
+			return;
+		}
+		this._performCursorZoom = true;
+		const rect = this.domElement.getBoundingClientRect();
+		const dx = x - rect.left;
+		const dy = y - rect.top;
+		const w = rect.width;
+		const h = rect.height;
+		this._mouse.x = ( dx / w ) * 2 - 1;
+		this._mouse.y = - ( dy / h ) * 2 + 1;
+		this._dollyDirection.set( this._mouse.x, this._mouse.y, 1 ).unproject( this.object ).sub( this.object.position ).normalize();
+	}
+	_clampDistance( dist ) {
+		return Math.max( this.minDistance, Math.min( this.maxDistance, dist ) );
+	}
+	//
+	// event callbacks - update the object state
+	//
+	_handleMouseDownRotate( event ) {
+		this._rotateStart.set( event.clientX, event.clientY );
+	}
+	_handleMouseDownDolly( event ) {
+		this._updateZoomParameters( event.clientX, event.clientX );
+		this._dollyStart.set( event.clientX, event.clientY );
+	}
+	_handleMouseDownPan( event ) {
+		this._panStart.set( event.clientX, event.clientY );
+	}
+	_handleMouseMoveRotate( event ) {
+		this._rotateEnd.set( event.clientX, event.clientY );
+		this._rotateDelta.subVectors( this._rotateEnd, this._rotateStart ).multiplyScalar( this.rotateSpeed );
+		const element = this.domElement;
+		this._rotateLeft( _twoPI * this._rotateDelta.x / element.clientHeight ); // yes, height
+		this._rotateUp( _twoPI * this._rotateDelta.y / element.clientHeight );
+		this._rotateStart.copy( this._rotateEnd );
+		this.update();
+	}
+	_handleMouseMoveDolly( event ) {
+		this._dollyEnd.set( event.clientX, event.clientY );
+		this._dollyDelta.subVectors( this._dollyEnd, this._dollyStart );
+		if ( this._dollyDelta.y > 0 ) {
+			this._dollyOut( this._getZoomScale( this._dollyDelta.y ) );
+		} else if ( this._dollyDelta.y < 0 ) {
+			this._dollyIn( this._getZoomScale( this._dollyDelta.y ) );
+		}
+		this._dollyStart.copy( this._dollyEnd );
+		this.update();
+	}
+	_handleMouseMovePan( event ) {
+		this._panEnd.set( event.clientX, event.clientY );
+		this._panDelta.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.panSpeed );
+		this._pan( this._panDelta.x, this._panDelta.y );
+		this._panStart.copy( this._panEnd );
+		this.update();
+	}
+	_handleMouseWheel( event ) {
+		this._updateZoomParameters( event.clientX, event.clientY );
+		if ( event.deltaY < 0 ) {
+			this._dollyIn( this._getZoomScale( event.deltaY ) );
+		} else if ( event.deltaY > 0 ) {
+			this._dollyOut( this._getZoomScale( event.deltaY ) );
+		}
+		this.update();
+	}
+	_handleKeyDown( event ) {
+		let needsUpdate = false;
+		switch ( event.code ) {
+			case this.keys.UP:
+				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+					if ( this.enableRotate ) {
+						this._rotateUp( _twoPI * this.keyRotateSpeed / this.domElement.clientHeight );
+					}
+				} else {
+					if ( this.enablePan ) {
+						this._pan( 0, this.keyPanSpeed );
+					}
+				}
+				needsUpdate = true;
+				break;
+			case this.keys.BOTTOM:
+				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+					if ( this.enableRotate ) {
+						this._rotateUp( - _twoPI * this.keyRotateSpeed / this.domElement.clientHeight );
+					}
+				} else {
+					if ( this.enablePan ) {
+						this._pan( 0, - this.keyPanSpeed );
+					}
+				}
+				needsUpdate = true;
+				break;
+			case this.keys.LEFT:
+				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+					if ( this.enableRotate ) {
+						this._rotateLeft( _twoPI * this.keyRotateSpeed / this.domElement.clientHeight );
+					}
+				} else {
+					if ( this.enablePan ) {
+						this._pan( this.keyPanSpeed, 0 );
+					}
+				}
+				needsUpdate = true;
+				break;
+			case this.keys.RIGHT:
+				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+					if ( this.enableRotate ) {
+						this._rotateLeft( - _twoPI * this.keyRotateSpeed / this.domElement.clientHeight );
+					}
+				} else {
+					if ( this.enablePan ) {
+						this._pan( - this.keyPanSpeed, 0 );
+					}
+				}
+				needsUpdate = true;
+				break;
+		}
+		if ( needsUpdate ) {
+			// prevent the browser from scrolling on cursor keys
+			event.preventDefault();
+			this.update();
+		}
+	}
+	_handleTouchStartRotate( event ) {
+		if ( this._pointers.length === 1 ) {
+			this._rotateStart.set( event.pageX, event.pageY );
+		} else {
+			const position = this._getSecondPointerPosition( event );
+			const x = 0.5 * ( event.pageX + position.x );
+			const y = 0.5 * ( event.pageY + position.y );
+			this._rotateStart.set( x, y );
+		}
+	}
+	_handleTouchStartPan( event ) {
+		if ( this._pointers.length === 1 ) {
+			this._panStart.set( event.pageX, event.pageY );
+		} else {
+			const position = this._getSecondPointerPosition( event );
+			const x = 0.5 * ( event.pageX + position.x );
+			const y = 0.5 * ( event.pageY + position.y );
+			this._panStart.set( x, y );
+		}
+	}
+	_handleTouchStartDolly( event ) {
+		const position = this._getSecondPointerPosition( event );
+		const dx = event.pageX - position.x;
+		const dy = event.pageY - position.y;
+		const distance = Math.sqrt( dx * dx + dy * dy );
+		this._dollyStart.set( 0, distance );
+	}
+	_handleTouchStartDollyPan( event ) {
+		if ( this.enableZoom ) this._handleTouchStartDolly( event );
+		if ( this.enablePan ) this._handleTouchStartPan( event );
+	}
+	_handleTouchStartDollyRotate( event ) {
+		if ( this.enableZoom ) this._handleTouchStartDolly( event );
+		if ( this.enableRotate ) this._handleTouchStartRotate( event );
+	}
+	_handleTouchMoveRotate( event ) {
+		if ( this._pointers.length == 1 ) {
+			this._rotateEnd.set( event.pageX, event.pageY );
+		} else {
+			const position = this._getSecondPointerPosition( event );
+			const x = 0.5 * ( event.pageX + position.x );
+			const y = 0.5 * ( event.pageY + position.y );
+			this._rotateEnd.set( x, y );
+		}
+		this._rotateDelta.subVectors( this._rotateEnd, this._rotateStart ).multiplyScalar( this.rotateSpeed );
+		const element = this.domElement;
+		this._rotateLeft( _twoPI * this._rotateDelta.x / element.clientHeight ); // yes, height
+		this._rotateUp( _twoPI * this._rotateDelta.y / element.clientHeight );
+		this._rotateStart.copy( this._rotateEnd );
+	}
+	_handleTouchMovePan( event ) {
+		if ( this._pointers.length === 1 ) {
+			this._panEnd.set( event.pageX, event.pageY );
+		} else {
+			const position = this._getSecondPointerPosition( event );
+			const x = 0.5 * ( event.pageX + position.x );
+			const y = 0.5 * ( event.pageY + position.y );
+			this._panEnd.set( x, y );
+		}
+		this._panDelta.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.panSpeed );
+		this._pan( this._panDelta.x, this._panDelta.y );
+		this._panStart.copy( this._panEnd );
+	}
+	_handleTouchMoveDolly( event ) {
+		const position = this._getSecondPointerPosition( event );
+		const dx = event.pageX - position.x;
+		const dy = event.pageY - position.y;
+		const distance = Math.sqrt( dx * dx + dy * dy );
+		this._dollyEnd.set( 0, distance );
+		this._dollyDelta.set( 0, Math.pow( this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed ) );
+		this._dollyOut( this._dollyDelta.y );
+		this._dollyStart.copy( this._dollyEnd );
+		const centerX = ( event.pageX + position.x ) * 0.5;
+		const centerY = ( event.pageY + position.y ) * 0.5;
+		this._updateZoomParameters( centerX, centerY );
+	}
+	_handleTouchMoveDollyPan( event ) {
+		if ( this.enableZoom ) this._handleTouchMoveDolly( event );
+		if ( this.enablePan ) this._handleTouchMovePan( event );
+	}
+	_handleTouchMoveDollyRotate( event ) {
+		if ( this.enableZoom ) this._handleTouchMoveDolly( event );
+		if ( this.enableRotate ) this._handleTouchMoveRotate( event );
+	}
+	// pointers
+	_addPointer( event ) {
+		this._pointers.push( event.pointerId );
+	}
+	_removePointer( event ) {
+		delete this._pointerPositions[ event.pointerId ];
+		for ( let i = 0; i < this._pointers.length; i ++ ) {
+			if ( this._pointers[ i ] == event.pointerId ) {
+				this._pointers.splice( i, 1 );
+				return;
+			}
+		}
+	}
+	_isTrackingPointer( event ) {
+		for ( let i = 0; i < this._pointers.length; i ++ ) {
+			if ( this._pointers[ i ] == event.pointerId ) return true;
+		}
+		return false;
+	}
+	_trackPointer( event ) {
+		let position = this._pointerPositions[ event.pointerId ];
+		if ( position === undefined ) {
+			position = new Vector2();
+			this._pointerPositions[ event.pointerId ] = position;
+		}
+		position.set( event.pageX, event.pageY );
+	}
+	_getSecondPointerPosition( event ) {
+		const pointerId = ( event.pointerId === this._pointers[ 0 ] ) ? this._pointers[ 1 ] : this._pointers[ 0 ];
+		return this._pointerPositions[ pointerId ];
+	}
+	//
+	_customWheelEvent( event ) {
+		const mode = event.deltaMode;
+		// minimal wheel event altered to meet delta-zoom demand
+		const newEvent = {
+			clientX: event.clientX,
+			clientY: event.clientY,
+			deltaY: event.deltaY,
+		};
+		switch ( mode ) {
+			case 1: // LINE_MODE
+				newEvent.deltaY *= 16;
+				break;
+			case 2: // PAGE_MODE
+				newEvent.deltaY *= 100;
+				break;
+		}
+		// detect if event was triggered by pinching
+		if ( event.ctrlKey && ! this._controlActive ) {
+			newEvent.deltaY *= 10;
+		}
+		return newEvent;
+	}
+}
+function onPointerDown( event ) {
+	if ( this.enabled === false ) return;
+	if ( this._pointers.length === 0 ) {
+		this.domElement.setPointerCapture( event.pointerId );
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+	}
+	//
+	if ( this._isTrackingPointer( event ) ) return;
+	//
+	this._addPointer( event );
+	if ( event.pointerType === 'touch' ) {
+		this._onTouchStart( event );
+	} else {
+		this._onMouseDown( event );
+	}
+}
+function onPointerMove( event ) {
+	if ( this.enabled === false ) return;
+	if ( event.pointerType === 'touch' ) {
+		this._onTouchMove( event );
+	} else {
+		this._onMouseMove( event );
+	}
+}
+function onPointerUp( event ) {
+	this._removePointer( event );
+	switch ( this._pointers.length ) {
+		case 0:
+			this.domElement.releasePointerCapture( event.pointerId );
+			this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+			this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+			this.dispatchEvent( _endEvent );
+			this.state = _STATE.NONE;
+			break;
+		case 1:
+			const pointerId = this._pointers[ 0 ];
+			const position = this._pointerPositions[ pointerId ];
+			// minimal placeholder event - allows state correction on pointer-up
+			this._onTouchStart( { pointerId: pointerId, pageX: position.x, pageY: position.y } );
+			break;
+	}
+}
+function onMouseDown( event ) {
+	let mouseAction;
+	switch ( event.button ) {
+		case 0:
+			mouseAction = this.mouseButtons.LEFT;
+			break;
+		case 1:
+			mouseAction = this.mouseButtons.MIDDLE;
+			break;
+		case 2:
+			mouseAction = this.mouseButtons.RIGHT;
+			break;
+		default:
+			mouseAction = - 1;
+	}
+	switch ( mouseAction ) {
+		case MOUSE.DOLLY:
+			if ( this.enableZoom === false ) return;
+			this._handleMouseDownDolly( event );
+			this.state = _STATE.DOLLY;
+			break;
+		case MOUSE.ROTATE:
+			if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+				if ( this.enablePan === false ) return;
+				this._handleMouseDownPan( event );
+				this.state = _STATE.PAN;
+			} else {
+				if ( this.enableRotate === false ) return;
+				this._handleMouseDownRotate( event );
+				this.state = _STATE.ROTATE;
+			}
+			break;
+		case MOUSE.PAN:
+			if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+				if ( this.enableRotate === false ) return;
+				this._handleMouseDownRotate( event );
+				this.state = _STATE.ROTATE;
+			} else {
+				if ( this.enablePan === false ) return;
+				this._handleMouseDownPan( event );
+				this.state = _STATE.PAN;
+			}
+			break;
+		default:
+			this.state = _STATE.NONE;
+	}
+	if ( this.state !== _STATE.NONE ) {
+		this.dispatchEvent( _startEvent );
+	}
+}
+function onMouseMove( event ) {
+	switch ( this.state ) {
+		case _STATE.ROTATE:
+			if ( this.enableRotate === false ) return;
+			this._handleMouseMoveRotate( event );
+			break;
+		case _STATE.DOLLY:
+			if ( this.enableZoom === false ) return;
+			this._handleMouseMoveDolly( event );
+			break;
+		case _STATE.PAN:
+			if ( this.enablePan === false ) return;
+			this._handleMouseMovePan( event );
+			break;
+	}
+}
+function onMouseWheel( event ) {
+	if ( this.enabled === false || this.enableZoom === false || this.state !== _STATE.NONE ) return;
+	event.preventDefault();
+	this.dispatchEvent( _startEvent );
+	this._handleMouseWheel( this._customWheelEvent( event ) );
+	this.dispatchEvent( _endEvent );
+}
+function onKeyDown( event ) {
+	if ( this.enabled === false ) return;
+	this._handleKeyDown( event );
+}
+function onTouchStart( event ) {
+	this._trackPointer( event );
+	switch ( this._pointers.length ) {
+		case 1:
+			switch ( this.touches.ONE ) {
+				case TOUCH.ROTATE:
+					if ( this.enableRotate === false ) return;
+					this._handleTouchStartRotate( event );
+					this.state = _STATE.TOUCH_ROTATE;
+					break;
+				case TOUCH.PAN:
+					if ( this.enablePan === false ) return;
+					this._handleTouchStartPan( event );
+					this.state = _STATE.TOUCH_PAN;
+					break;
+				default:
+					this.state = _STATE.NONE;
+			}
+			break;
+		case 2:
+			switch ( this.touches.TWO ) {
+				case TOUCH.DOLLY_PAN:
+					if ( this.enableZoom === false && this.enablePan === false ) return;
+					this._handleTouchStartDollyPan( event );
+					this.state = _STATE.TOUCH_DOLLY_PAN;
+					break;
+				case TOUCH.DOLLY_ROTATE:
+					if ( this.enableZoom === false && this.enableRotate === false ) return;
+					this._handleTouchStartDollyRotate( event );
+					this.state = _STATE.TOUCH_DOLLY_ROTATE;
+					break;
+				default:
+					this.state = _STATE.NONE;
+			}
+			break;
+		default:
+			this.state = _STATE.NONE;
+	}
+	if ( this.state !== _STATE.NONE ) {
+		this.dispatchEvent( _startEvent );
+	}
+}
+function onTouchMove( event ) {
+	this._trackPointer( event );
+	switch ( this.state ) {
+		case _STATE.TOUCH_ROTATE:
+			if ( this.enableRotate === false ) return;
+			this._handleTouchMoveRotate( event );
+			this.update();
+			break;
+		case _STATE.TOUCH_PAN:
+			if ( this.enablePan === false ) return;
+			this._handleTouchMovePan( event );
+			this.update();
+			break;
+		case _STATE.TOUCH_DOLLY_PAN:
+			if ( this.enableZoom === false && this.enablePan === false ) return;
+			this._handleTouchMoveDollyPan( event );
+			this.update();
+			break;
+		case _STATE.TOUCH_DOLLY_ROTATE:
+			if ( this.enableZoom === false && this.enableRotate === false ) return;
+			this._handleTouchMoveDollyRotate( event );
+			this.update();
+			break;
+		default:
+			this.state = _STATE.NONE;
+	}
+}
+function onContextMenu( event ) {
+	if ( this.enabled === false ) return;
+	event.preventDefault();
+}
+function interceptControlDown( event ) {
+	if ( event.key === 'Control' ) {
+		this._controlActive = true;
+		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
+		document.addEventListener( 'keyup', this._interceptControlUp, { passive: true, capture: true } );
+	}
+}
+function interceptControlUp( event ) {
+	if ( event.key === 'Control' ) {
+		this._controlActive = false;
+		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
+		document.removeEventListener( 'keyup', this._interceptControlUp, { passive: true, capture: true } );
+	}
+}
+export { OrbitControls };

libs/three.js/0.172.0/jsm/controls/PointerLockControls.js ADDED Viewed

	@@ -0,0 +1,168 @@

+import {
+	Controls,
+	Euler,
+	Vector3
+} from 'three';
+const _euler = new Euler( 0, 0, 0, 'YXZ' );
+const _vector = new Vector3();
+const _changeEvent = { type: 'change' };
+const _lockEvent = { type: 'lock' };
+const _unlockEvent = { type: 'unlock' };
+const _PI_2 = Math.PI / 2;
+class PointerLockControls extends Controls {
+	constructor( camera, domElement = null ) {
+		super( camera, domElement );
+		this.isLocked = false;
+		// Set to constrain the pitch of the camera
+		// Range is 0 to Math.PI radians
+		this.minPolarAngle = 0; // radians
+		this.maxPolarAngle = Math.PI; // radians
+		this.pointerSpeed = 1.0;
+		// event listeners
+		this._onMouseMove = onMouseMove.bind( this );
+		this._onPointerlockChange = onPointerlockChange.bind( this );
+		this._onPointerlockError = onPointerlockError.bind( this );
+		if ( this.domElement !== null ) {
+			this.connect();
+		}
+	}
+	connect() {
+		this.domElement.ownerDocument.addEventListener( 'mousemove', this._onMouseMove );
+		this.domElement.ownerDocument.addEventListener( 'pointerlockchange', this._onPointerlockChange );
+		this.domElement.ownerDocument.addEventListener( 'pointerlockerror', this._onPointerlockError );
+	}
+	disconnect() {
+		this.domElement.ownerDocument.removeEventListener( 'mousemove', this._onMouseMove );
+		this.domElement.ownerDocument.removeEventListener( 'pointerlockchange', this._onPointerlockChange );
+		this.domElement.ownerDocument.removeEventListener( 'pointerlockerror', this._onPointerlockError );
+	}
+	dispose() {
+		this.disconnect();
+	}
+	getObject() {
+		console.warn( 'THREE.PointerLockControls: getObject() has been deprecated. Use controls.object instead.' ); // @deprecated r169
+		return this.object;
+	}
+	getDirection( v ) {
+		return v.set( 0, 0, - 1 ).applyQuaternion( this.object.quaternion );
+	}
+	moveForward( distance ) {
+		if ( this.enabled === false ) return;
+		// move forward parallel to the xz-plane
+		// assumes camera.up is y-up
+		const camera = this.object;
+		_vector.setFromMatrixColumn( camera.matrix, 0 );
+		_vector.crossVectors( camera.up, _vector );
+		camera.position.addScaledVector( _vector, distance );
+	}
+	moveRight( distance ) {
+		if ( this.enabled === false ) return;
+		const camera = this.object;
+		_vector.setFromMatrixColumn( camera.matrix, 0 );
+		camera.position.addScaledVector( _vector, distance );
+	}
+	lock() {
+		this.domElement.requestPointerLock();
+	}
+	unlock() {
+		this.domElement.ownerDocument.exitPointerLock();
+	}
+}
+// event listeners
+function onMouseMove( event ) {
+	if ( this.enabled === false || this.isLocked === false ) return;
+	const camera = this.object;
+	_euler.setFromQuaternion( camera.quaternion );
+	_euler.y -= event.movementX * 0.002 * this.pointerSpeed;
+	_euler.x -= event.movementY * 0.002 * this.pointerSpeed;
+	_euler.x = Math.max( _PI_2 - this.maxPolarAngle, Math.min( _PI_2 - this.minPolarAngle, _euler.x ) );
+	camera.quaternion.setFromEuler( _euler );
+	this.dispatchEvent( _changeEvent );
+}
+function onPointerlockChange() {
+	if ( this.domElement.ownerDocument.pointerLockElement === this.domElement ) {
+		this.dispatchEvent( _lockEvent );
+		this.isLocked = true;
+	} else {
+		this.dispatchEvent( _unlockEvent );
+		this.isLocked = false;
+	}
+}
+function onPointerlockError() {
+	console.error( 'THREE.PointerLockControls: Unable to use Pointer Lock API' );
+}
+export { PointerLockControls };

libs/three.js/0.172.0/jsm/controls/TrackballControls.js ADDED Viewed

	@@ -0,0 +1,849 @@

+import {
+	Controls,
+	MathUtils,
+	MOUSE,
+	Quaternion,
+	Vector2,
+	Vector3
+} from 'three';
+const _changeEvent = { type: 'change' };
+const _startEvent = { type: 'start' };
+const _endEvent = { type: 'end' };
+const _EPS = 0.000001;
+const _STATE = { NONE: - 1, ROTATE: 0, ZOOM: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_ZOOM_PAN: 4 };
+const _v2 = new Vector2();
+const _mouseChange = new Vector2();
+const _objectUp = new Vector3();
+const _pan = new Vector3();
+const _axis = new Vector3();
+const _quaternion = new Quaternion();
+const _eyeDirection = new Vector3();
+const _objectUpDirection = new Vector3();
+const _objectSidewaysDirection = new Vector3();
+const _moveDirection = new Vector3();
+class TrackballControls extends Controls {
+	constructor( object, domElement = null ) {
+		super( object, domElement );
+		// API
+		this.enabled = true;
+		this.screen = { left: 0, top: 0, width: 0, height: 0 };
+		this.rotateSpeed = 1.0;
+		this.zoomSpeed = 1.2;
+		this.panSpeed = 0.3;
+		this.noRotate = false;
+		this.noZoom = false;
+		this.noPan = false;
+		this.staticMoving = false;
+		this.dynamicDampingFactor = 0.2;
+		this.minDistance = 0;
+		this.maxDistance = Infinity;
+		this.minZoom = 0;
+		this.maxZoom = Infinity;
+		this.keys = [ 'KeyA' /*A*/, 'KeyS' /*S*/, 'KeyD' /*D*/ ];
+		this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
+		this.state = _STATE.NONE;
+		this.keyState = _STATE.NONE;
+		this.target = new Vector3();
+		// internals
+		this._lastPosition = new Vector3();
+		this._lastZoom = 1;
+		this._touchZoomDistanceStart = 0;
+		this._touchZoomDistanceEnd = 0;
+		this._lastAngle = 0;
+		this._eye = new Vector3();
+		this._movePrev = new Vector2();
+		this._moveCurr = new Vector2();
+		this._lastAxis = new Vector3();
+		this._zoomStart = new Vector2();
+		this._zoomEnd = new Vector2();
+		this._panStart = new Vector2();
+		this._panEnd = new Vector2();
+		this._pointers = [];
+		this._pointerPositions = {};
+		// event listeners
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		this._onPointerCancel = onPointerCancel.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
+		this._onMouseWheel = onMouseWheel.bind( this );
+		this._onKeyDown = onKeyDown.bind( this );
+		this._onKeyUp = onKeyUp.bind( this );
+		this._onTouchStart = onTouchStart.bind( this );
+		this._onTouchMove = onTouchMove.bind( this );
+		this._onTouchEnd = onTouchEnd.bind( this );
+		this._onMouseDown = onMouseDown.bind( this );
+		this._onMouseMove = onMouseMove.bind( this );
+		this._onMouseUp = onMouseUp.bind( this );
+		// for reset
+		this._target0 = this.target.clone();
+		this._position0 = this.object.position.clone();
+		this._up0 = this.object.up.clone();
+		this._zoom0 = this.object.zoom;
+		if ( domElement !== null ) {
+			this.connect();
+			this.handleResize();
+		}
+		// force an update at start
+		this.update();
+	}
+	connect() {
+		window.addEventListener( 'keydown', this._onKeyDown );
+		window.addEventListener( 'keyup', this._onKeyUp );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.addEventListener( 'wheel', this._onMouseWheel, { passive: false } );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+		this.domElement.style.touchAction = 'none'; // disable touch scroll
+	}
+	disconnect() {
+		window.removeEventListener( 'keydown', this._onKeyDown );
+		window.removeEventListener( 'keyup', this._onKeyUp );
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.removeEventListener( 'pointercancel', this._onPointerCancel );
+		this.domElement.removeEventListener( 'wheel', this._onMouseWheel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+		this.domElement.style.touchAction = 'auto'; // disable touch scroll
+	}
+	dispose() {
+		this.disconnect();
+	}
+	handleResize() {
+		const box = this.domElement.getBoundingClientRect();
+		// adjustments come from similar code in the jquery offset() function
+		const d = this.domElement.ownerDocument.documentElement;
+		this.screen.left = box.left + window.pageXOffset - d.clientLeft;
+		this.screen.top = box.top + window.pageYOffset - d.clientTop;
+		this.screen.width = box.width;
+		this.screen.height = box.height;
+	}
+	update() {
+		this._eye.subVectors( this.object.position, this.target );
+		if ( ! this.noRotate ) {
+			this._rotateCamera();
+		}
+		if ( ! this.noZoom ) {
+			this._zoomCamera();
+		}
+		if ( ! this.noPan ) {
+			this._panCamera();
+		}
+		this.object.position.addVectors( this.target, this._eye );
+		if ( this.object.isPerspectiveCamera ) {
+			this._checkDistances();
+			this.object.lookAt( this.target );
+			if ( this._lastPosition.distanceToSquared( this.object.position ) > _EPS ) {
+				this.dispatchEvent( _changeEvent );
+				this._lastPosition.copy( this.object.position );
+			}
+		} else if ( this.object.isOrthographicCamera ) {
+			this.object.lookAt( this.target );
+			if ( this._lastPosition.distanceToSquared( this.object.position ) > _EPS || this._lastZoom !== this.object.zoom ) {
+				this.dispatchEvent( _changeEvent );
+				this._lastPosition.copy( this.object.position );
+				this._lastZoom = this.object.zoom;
+			}
+		} else {
+			console.warn( 'THREE.TrackballControls: Unsupported camera type.' );
+		}
+	}
+	reset() {
+		this.state = _STATE.NONE;
+		this.keyState = _STATE.NONE;
+		this.target.copy( this._target0 );
+		this.object.position.copy( this._position0 );
+		this.object.up.copy( this._up0 );
+		this.object.zoom = this._zoom0;
+		this.object.updateProjectionMatrix();
+		this._eye.subVectors( this.object.position, this.target );
+		this.object.lookAt( this.target );
+		this.dispatchEvent( _changeEvent );
+		this._lastPosition.copy( this.object.position );
+		this._lastZoom = this.object.zoom;
+	}
+	_panCamera() {
+		_mouseChange.copy( this._panEnd ).sub( this._panStart );
+		if ( _mouseChange.lengthSq() ) {
+			if ( this.object.isOrthographicCamera ) {
+				const scale_x = ( this.object.right - this.object.left ) / this.object.zoom / this.domElement.clientWidth;
+				const scale_y = ( this.object.top - this.object.bottom ) / this.object.zoom / this.domElement.clientWidth;
+				_mouseChange.x *= scale_x;
+				_mouseChange.y *= scale_y;
+			}
+			_mouseChange.multiplyScalar( this._eye.length() * this.panSpeed );
+			_pan.copy( this._eye ).cross( this.object.up ).setLength( _mouseChange.x );
+			_pan.add( _objectUp.copy( this.object.up ).setLength( _mouseChange.y ) );
+			this.object.position.add( _pan );
+			this.target.add( _pan );
+			if ( this.staticMoving ) {
+				this._panStart.copy( this._panEnd );
+			} else {
+				this._panStart.add( _mouseChange.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.dynamicDampingFactor ) );
+			}
+		}
+	}
+	_rotateCamera() {
+		_moveDirection.set( this._moveCurr.x - this._movePrev.x, this._moveCurr.y - this._movePrev.y, 0 );
+		let angle = _moveDirection.length();
+		if ( angle ) {
+			this._eye.copy( this.object.position ).sub( this.target );
+			_eyeDirection.copy( this._eye ).normalize();
+			_objectUpDirection.copy( this.object.up ).normalize();
+			_objectSidewaysDirection.crossVectors( _objectUpDirection, _eyeDirection ).normalize();
+			_objectUpDirection.setLength( this._moveCurr.y - this._movePrev.y );
+			_objectSidewaysDirection.setLength( this._moveCurr.x - this._movePrev.x );
+			_moveDirection.copy( _objectUpDirection.add( _objectSidewaysDirection ) );
+			_axis.crossVectors( _moveDirection, this._eye ).normalize();
+			angle *= this.rotateSpeed;
+			_quaternion.setFromAxisAngle( _axis, angle );
+			this._eye.applyQuaternion( _quaternion );
+			this.object.up.applyQuaternion( _quaternion );
+			this._lastAxis.copy( _axis );
+			this._lastAngle = angle;
+		} else if ( ! this.staticMoving && this._lastAngle ) {
+			this._lastAngle *= Math.sqrt( 1.0 - this.dynamicDampingFactor );
+			this._eye.copy( this.object.position ).sub( this.target );
+			_quaternion.setFromAxisAngle( this._lastAxis, this._lastAngle );
+			this._eye.applyQuaternion( _quaternion );
+			this.object.up.applyQuaternion( _quaternion );
+		}
+		this._movePrev.copy( this._moveCurr );
+	}
+	_zoomCamera() {
+		let factor;
+		if ( this.state === _STATE.TOUCH_ZOOM_PAN ) {
+			factor = this._touchZoomDistanceStart / this._touchZoomDistanceEnd;
+			this._touchZoomDistanceStart = this._touchZoomDistanceEnd;
+			if ( this.object.isPerspectiveCamera ) {
+				this._eye.multiplyScalar( factor );
+			} else if ( this.object.isOrthographicCamera ) {
+				this.object.zoom = MathUtils.clamp( this.object.zoom / factor, this.minZoom, this.maxZoom );
+				if ( this._lastZoom !== this.object.zoom ) {
+					this.object.updateProjectionMatrix();
+				}
+			} else {
+				console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+			}
+		} else {
+			factor = 1.0 + ( this._zoomEnd.y - this._zoomStart.y ) * this.zoomSpeed;
+			if ( factor !== 1.0 && factor > 0.0 ) {
+				if ( this.object.isPerspectiveCamera ) {
+					this._eye.multiplyScalar( factor );
+				} else if ( this.object.isOrthographicCamera ) {
+					this.object.zoom = MathUtils.clamp( this.object.zoom / factor, this.minZoom, this.maxZoom );
+					if ( this._lastZoom !== this.object.zoom ) {
+						this.object.updateProjectionMatrix();
+					}
+				} else {
+					console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+				}
+			}
+			if ( this.staticMoving ) {
+				this._zoomStart.copy( this._zoomEnd );
+			} else {
+				this._zoomStart.y += ( this._zoomEnd.y - this._zoomStart.y ) * this.dynamicDampingFactor;
+			}
+		}
+	}
+	_getMouseOnScreen( pageX, pageY ) {
+		_v2.set(
+			( pageX - this.screen.left ) / this.screen.width,
+			( pageY - this.screen.top ) / this.screen.height
+		);
+		return _v2;
+	}
+	_getMouseOnCircle( pageX, pageY ) {
+		_v2.set(
+			( ( pageX - this.screen.width * 0.5 - this.screen.left ) / ( this.screen.width * 0.5 ) ),
+			( ( this.screen.height + 2 * ( this.screen.top - pageY ) ) / this.screen.width ) // screen.width intentional
+		);
+		return _v2;
+	}
+	_addPointer( event ) {
+		this._pointers.push( event );
+	}
+	_removePointer( event ) {
+		delete this._pointerPositions[ event.pointerId ];
+		for ( let i = 0; i < this._pointers.length; i ++ ) {
+			if ( this._pointers[ i ].pointerId == event.pointerId ) {
+				this._pointers.splice( i, 1 );
+				return;
+			}
+		}
+	}
+	_trackPointer( event ) {
+		let position = this._pointerPositions[ event.pointerId ];
+		if ( position === undefined ) {
+			position = new Vector2();
+			this._pointerPositions[ event.pointerId ] = position;
+		}
+		position.set( event.pageX, event.pageY );
+	}
+	_getSecondPointerPosition( event ) {
+		const pointer = ( event.pointerId === this._pointers[ 0 ].pointerId ) ? this._pointers[ 1 ] : this._pointers[ 0 ];
+		return this._pointerPositions[ pointer.pointerId ];
+	}
+	_checkDistances() {
+		if ( ! this.noZoom || ! this.noPan ) {
+			if ( this._eye.lengthSq() > this.maxDistance * this.maxDistance ) {
+				this.object.position.addVectors( this.target, this._eye.setLength( this.maxDistance ) );
+				this._zoomStart.copy( this._zoomEnd );
+			}
+			if ( this._eye.lengthSq() < this.minDistance * this.minDistance ) {
+				this.object.position.addVectors( this.target, this._eye.setLength( this.minDistance ) );
+				this._zoomStart.copy( this._zoomEnd );
+			}
+		}
+	}
+}
+function onPointerDown( event ) {
+	if ( this.enabled === false ) return;
+	if ( this._pointers.length === 0 ) {
+		this.domElement.setPointerCapture( event.pointerId );
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+	}
+	//
+	this._addPointer( event );
+	if ( event.pointerType === 'touch' ) {
+		this._onTouchStart( event );
+	} else {
+		this._onMouseDown( event );
+	}
+}
+function onPointerMove( event ) {
+	if ( this.enabled === false ) return;
+	if ( event.pointerType === 'touch' ) {
+		this._onTouchMove( event );
+	} else {
+		this._onMouseMove( event );
+	}
+}
+function onPointerUp( event ) {
+	if ( this.enabled === false ) return;
+	if ( event.pointerType === 'touch' ) {
+		this._onTouchEnd( event );
+	} else {
+		this._onMouseUp();
+	}
+	//
+	this._removePointer( event );
+	if ( this._pointers.length === 0 ) {
+		this.domElement.releasePointerCapture( event.pointerId );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+	}
+}
+function onPointerCancel( event ) {
+	this._removePointer( event );
+}
+function onKeyUp() {
+	if ( this.enabled === false ) return;
+	this.keyState = _STATE.NONE;
+	window.addEventListener( 'keydown', this._onKeyDown );
+}
+function onKeyDown( event ) {
+	if ( this.enabled === false ) return;
+	window.removeEventListener( 'keydown', this._onKeyDown );
+	if ( this.keyState !== _STATE.NONE ) {
+		return;
+	} else if ( event.code === this.keys[ _STATE.ROTATE ] && ! this.noRotate ) {
+		this.keyState = _STATE.ROTATE;
+	} else if ( event.code === this.keys[ _STATE.ZOOM ] && ! this.noZoom ) {
+		this.keyState = _STATE.ZOOM;
+	} else if ( event.code === this.keys[ _STATE.PAN ] && ! this.noPan ) {
+		this.keyState = _STATE.PAN;
+	}
+}
+function onMouseDown( event ) {
+	let mouseAction;
+	switch ( event.button ) {
+		case 0:
+			mouseAction = this.mouseButtons.LEFT;
+			break;
+		case 1:
+			mouseAction = this.mouseButtons.MIDDLE;
+			break;
+		case 2:
+			mouseAction = this.mouseButtons.RIGHT;
+			break;
+		default:
+			mouseAction = - 1;
+	}
+	switch ( mouseAction ) {
+		case MOUSE.DOLLY:
+			this.state = _STATE.ZOOM;
+			break;
+		case MOUSE.ROTATE:
+			this.state = _STATE.ROTATE;
+			break;
+		case MOUSE.PAN:
+			this.state = _STATE.PAN;
+			break;
+		default:
+			this.state = _STATE.NONE;
+	}
+	const state = ( this.keyState !== _STATE.NONE ) ? this.keyState : this.state;
+	if ( state === _STATE.ROTATE && ! this.noRotate ) {
+		this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+		this._movePrev.copy( this._moveCurr );
+	} else if ( state === _STATE.ZOOM && ! this.noZoom ) {
+		this._zoomStart.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
+		this._zoomEnd.copy( this._zoomStart );
+	} else if ( state === _STATE.PAN && ! this.noPan ) {
+		this._panStart.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
+		this._panEnd.copy( this._panStart );
+	}
+	this.dispatchEvent( _startEvent );
+}
+function onMouseMove( event ) {
+	const state = ( this.keyState !== _STATE.NONE ) ? this.keyState : this.state;
+	if ( state === _STATE.ROTATE && ! this.noRotate ) {
+		this._movePrev.copy( this._moveCurr );
+		this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+	} else if ( state === _STATE.ZOOM && ! this.noZoom ) {
+		this._zoomEnd.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
+	} else if ( state === _STATE.PAN && ! this.noPan ) {
+		this._panEnd.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
+	}
+}
+function onMouseUp() {
+	this.state = _STATE.NONE;
+	this.dispatchEvent( _endEvent );
+}
+function onMouseWheel( event ) {
+	if ( this.enabled === false ) return;
+	if ( this.noZoom === true ) return;
+	event.preventDefault();
+	switch ( event.deltaMode ) {
+		case 2:
+			// Zoom in pages
+			this._zoomStart.y -= event.deltaY * 0.025;
+			break;
+		case 1:
+			// Zoom in lines
+			this._zoomStart.y -= event.deltaY * 0.01;
+			break;
+		default:
+			// undefined, 0, assume pixels
+			this._zoomStart.y -= event.deltaY * 0.00025;
+			break;
+	}
+	this.dispatchEvent( _startEvent );
+	this.dispatchEvent( _endEvent );
+}
+function onContextMenu( event ) {
+	if ( this.enabled === false ) return;
+	event.preventDefault();
+}
+function onTouchStart( event ) {
+	this._trackPointer( event );
+	switch ( this._pointers.length ) {
+		case 1:
+			this.state = _STATE.TOUCH_ROTATE;
+			this._moveCurr.copy( this._getMouseOnCircle( this._pointers[ 0 ].pageX, this._pointers[ 0 ].pageY ) );
+			this._movePrev.copy( this._moveCurr );
+			break;
+		default: // 2 or more
+			this.state = _STATE.TOUCH_ZOOM_PAN;
+			const dx = this._pointers[ 0 ].pageX - this._pointers[ 1 ].pageX;
+			const dy = this._pointers[ 0 ].pageY - this._pointers[ 1 ].pageY;
+			this._touchZoomDistanceEnd = this._touchZoomDistanceStart = Math.sqrt( dx * dx + dy * dy );
+			const x = ( this._pointers[ 0 ].pageX + this._pointers[ 1 ].pageX ) / 2;
+			const y = ( this._pointers[ 0 ].pageY + this._pointers[ 1 ].pageY ) / 2;
+			this._panStart.copy( this._getMouseOnScreen( x, y ) );
+			this._panEnd.copy( this._panStart );
+			break;
+	}
+	this.dispatchEvent( _startEvent );
+}
+function onTouchMove( event ) {
+	this._trackPointer( event );
+	switch ( this._pointers.length ) {
+		case 1:
+			this._movePrev.copy( this._moveCurr );
+			this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+			break;
+		default: // 2 or more
+			const position = this._getSecondPointerPosition( event );
+			const dx = event.pageX - position.x;
+			const dy = event.pageY - position.y;
+			this._touchZoomDistanceEnd = Math.sqrt( dx * dx + dy * dy );
+			const x = ( event.pageX + position.x ) / 2;
+			const y = ( event.pageY + position.y ) / 2;
+			this._panEnd.copy( this._getMouseOnScreen( x, y ) );
+			break;
+	}
+}
+function onTouchEnd( event ) {
+	switch ( this._pointers.length ) {
+		case 0:
+			this.state = _STATE.NONE;
+			break;
+		case 1:
+			this.state = _STATE.TOUCH_ROTATE;
+			this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+			this._movePrev.copy( this._moveCurr );
+			break;
+		case 2:
+			this.state = _STATE.TOUCH_ZOOM_PAN;
+			for ( let i = 0; i < this._pointers.length; i ++ ) {
+				if ( this._pointers[ i ].pointerId !== event.pointerId ) {
+					const position = this._pointerPositions[ this._pointers[ i ].pointerId ];
+					this._moveCurr.copy( this._getMouseOnCircle( position.x, position.y ) );
+					this._movePrev.copy( this._moveCurr );
+					break;
+				}
+			}
+			break;
+	}
+	this.dispatchEvent( _endEvent );
+}
+export { TrackballControls };

libs/three.js/0.172.0/jsm/controls/TransformControls.js ADDED Viewed

	@@ -0,0 +1,1624 @@

+import {
+	BoxGeometry,
+	BufferGeometry,
+	Controls,
+	CylinderGeometry,
+	DoubleSide,
+	Euler,
+	Float32BufferAttribute,
+	Line,
+	LineBasicMaterial,
+	Matrix4,
+	Mesh,
+	MeshBasicMaterial,
+	Object3D,
+	OctahedronGeometry,
+	PlaneGeometry,
+	Quaternion,
+	Raycaster,
+	SphereGeometry,
+	TorusGeometry,
+	Vector3
+} from 'three';
+const _raycaster = new Raycaster();
+const _tempVector = new Vector3();
+const _tempVector2 = new Vector3();
+const _tempQuaternion = new Quaternion();
+const _unit = {
+	X: new Vector3( 1, 0, 0 ),
+	Y: new Vector3( 0, 1, 0 ),
+	Z: new Vector3( 0, 0, 1 )
+};
+const _changeEvent = { type: 'change' };
+const _mouseDownEvent = { type: 'mouseDown', mode: null };
+const _mouseUpEvent = { type: 'mouseUp', mode: null };
+const _objectChangeEvent = { type: 'objectChange' };
+class TransformControls extends Controls {
+	constructor( camera, domElement = null ) {
+		super( undefined, domElement );
+		const root = new TransformControlsRoot( this );
+		this._root = root;
+		const gizmo = new TransformControlsGizmo();
+		this._gizmo = gizmo;
+		root.add( gizmo );
+		const plane = new TransformControlsPlane();
+		this._plane = plane;
+		root.add( plane );
+		const scope = this;
+		// Defined getter, setter and store for a property
+		function defineProperty( propName, defaultValue ) {
+			let propValue = defaultValue;
+			Object.defineProperty( scope, propName, {
+				get: function () {
+					return propValue !== undefined ? propValue : defaultValue;
+				},
+				set: function ( value ) {
+					if ( propValue !== value ) {
+						propValue = value;
+						plane[ propName ] = value;
+						gizmo[ propName ] = value;
+						scope.dispatchEvent( { type: propName + '-changed', value: value } );
+						scope.dispatchEvent( _changeEvent );
+					}
+				}
+			} );
+			scope[ propName ] = defaultValue;
+			plane[ propName ] = defaultValue;
+			gizmo[ propName ] = defaultValue;
+		}
+		// Define properties with getters/setter
+		// Setting the defined property will automatically trigger change event
+		// Defined properties are passed down to gizmo and plane
+		defineProperty( 'camera', camera );
+		defineProperty( 'object', undefined );
+		defineProperty( 'enabled', true );
+		defineProperty( 'axis', null );
+		defineProperty( 'mode', 'translate' );
+		defineProperty( 'translationSnap', null );
+		defineProperty( 'rotationSnap', null );
+		defineProperty( 'scaleSnap', null );
+		defineProperty( 'space', 'world' );
+		defineProperty( 'size', 1 );
+		defineProperty( 'dragging', false );
+		defineProperty( 'showX', true );
+		defineProperty( 'showY', true );
+		defineProperty( 'showZ', true );
+		defineProperty( 'minX', - Infinity );
+		defineProperty( 'maxX', Infinity );
+		defineProperty( 'minY', - Infinity );
+		defineProperty( 'maxY', Infinity );
+		defineProperty( 'minZ', - Infinity );
+		defineProperty( 'maxZ', Infinity );
+		// Reusable utility variables
+		const worldPosition = new Vector3();
+		const worldPositionStart = new Vector3();
+		const worldQuaternion = new Quaternion();
+		const worldQuaternionStart = new Quaternion();
+		const cameraPosition = new Vector3();
+		const cameraQuaternion = new Quaternion();
+		const pointStart = new Vector3();
+		const pointEnd = new Vector3();
+		const rotationAxis = new Vector3();
+		const rotationAngle = 0;
+		const eye = new Vector3();
+		// TODO: remove properties unused in plane and gizmo
+		defineProperty( 'worldPosition', worldPosition );
+		defineProperty( 'worldPositionStart', worldPositionStart );
+		defineProperty( 'worldQuaternion', worldQuaternion );
+		defineProperty( 'worldQuaternionStart', worldQuaternionStart );
+		defineProperty( 'cameraPosition', cameraPosition );
+		defineProperty( 'cameraQuaternion', cameraQuaternion );
+		defineProperty( 'pointStart', pointStart );
+		defineProperty( 'pointEnd', pointEnd );
+		defineProperty( 'rotationAxis', rotationAxis );
+		defineProperty( 'rotationAngle', rotationAngle );
+		defineProperty( 'eye', eye );
+		this._offset = new Vector3();
+		this._startNorm = new Vector3();
+		this._endNorm = new Vector3();
+		this._cameraScale = new Vector3();
+		this._parentPosition = new Vector3();
+		this._parentQuaternion = new Quaternion();
+		this._parentQuaternionInv = new Quaternion();
+		this._parentScale = new Vector3();
+		this._worldScaleStart = new Vector3();
+		this._worldQuaternionInv = new Quaternion();
+		this._worldScale = new Vector3();
+		this._positionStart = new Vector3();
+		this._quaternionStart = new Quaternion();
+		this._scaleStart = new Vector3();
+		this._getPointer = getPointer.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerHover = onPointerHover.bind( this );
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerUp = onPointerUp.bind( this );
+		if ( domElement !== null ) {
+			this.connect();
+		}
+	}
+	connect() {
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointermove', this._onPointerHover );
+		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.style.touchAction = 'none'; // disable touch scroll
+	}
+	disconnect() {
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerHover );
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+		this.domElement.style.touchAction = 'auto';
+	}
+	getHelper() {
+		return this._root;
+	}
+	pointerHover( pointer ) {
+		if ( this.object === undefined || this.dragging === true ) return;
+		if ( pointer !== null ) _raycaster.setFromCamera( pointer, this.camera );
+		const intersect = intersectObjectWithRay( this._gizmo.picker[ this.mode ], _raycaster );
+		if ( intersect ) {
+			this.axis = intersect.object.name;
+		} else {
+			this.axis = null;
+		}
+	}
+	pointerDown( pointer ) {
+		if ( this.object === undefined || this.dragging === true || ( pointer != null && pointer.button !== 0 ) ) return;
+		if ( this.axis !== null ) {
+			if ( pointer !== null ) _raycaster.setFromCamera( pointer, this.camera );
+			const planeIntersect = intersectObjectWithRay( this._plane, _raycaster, true );
+			if ( planeIntersect ) {
+				this.object.updateMatrixWorld();
+				this.object.parent.updateMatrixWorld();
+				this._positionStart.copy( this.object.position );
+				this._quaternionStart.copy( this.object.quaternion );
+				this._scaleStart.copy( this.object.scale );
+				this.object.matrixWorld.decompose( this.worldPositionStart, this.worldQuaternionStart, this._worldScaleStart );
+				this.pointStart.copy( planeIntersect.point ).sub( this.worldPositionStart );
+			}
+			this.dragging = true;
+			_mouseDownEvent.mode = this.mode;
+			this.dispatchEvent( _mouseDownEvent );
+		}
+	}
+	pointerMove( pointer ) {
+		const axis = this.axis;
+		const mode = this.mode;
+		const object = this.object;
+		let space = this.space;
+		if ( mode === 'scale' ) {
+			space = 'local';
+		} else if ( axis === 'E' || axis === 'XYZE' || axis === 'XYZ' ) {
+			space = 'world';
+		}
+		if ( object === undefined || axis === null || this.dragging === false || ( pointer !== null && pointer.button !== - 1 ) ) return;
+		if ( pointer !== null ) _raycaster.setFromCamera( pointer, this.camera );
+		const planeIntersect = intersectObjectWithRay( this._plane, _raycaster, true );
+		if ( ! planeIntersect ) return;
+		this.pointEnd.copy( planeIntersect.point ).sub( this.worldPositionStart );
+		if ( mode === 'translate' ) {
+			// Apply translate
+			this._offset.copy( this.pointEnd ).sub( this.pointStart );
+			if ( space === 'local' && axis !== 'XYZ' ) {
+				this._offset.applyQuaternion( this._worldQuaternionInv );
+			}
+			if ( axis.indexOf( 'X' ) === - 1 ) this._offset.x = 0;
+			if ( axis.indexOf( 'Y' ) === - 1 ) this._offset.y = 0;
+			if ( axis.indexOf( 'Z' ) === - 1 ) this._offset.z = 0;
+			if ( space === 'local' && axis !== 'XYZ' ) {
+				this._offset.applyQuaternion( this._quaternionStart ).divide( this._parentScale );
+			} else {
+				this._offset.applyQuaternion( this._parentQuaternionInv ).divide( this._parentScale );
+			}
+			object.position.copy( this._offset ).add( this._positionStart );
+			// Apply translation snap
+			if ( this.translationSnap ) {
+				if ( space === 'local' ) {
+					object.position.applyQuaternion( _tempQuaternion.copy( this._quaternionStart ).invert() );
+					if ( axis.search( 'X' ) !== - 1 ) {
+						object.position.x = Math.round( object.position.x / this.translationSnap ) * this.translationSnap;
+					}
+					if ( axis.search( 'Y' ) !== - 1 ) {
+						object.position.y = Math.round( object.position.y / this.translationSnap ) * this.translationSnap;
+					}
+					if ( axis.search( 'Z' ) !== - 1 ) {
+						object.position.z = Math.round( object.position.z / this.translationSnap ) * this.translationSnap;
+					}
+					object.position.applyQuaternion( this._quaternionStart );
+				}
+				if ( space === 'world' ) {
+					if ( object.parent ) {
+						object.position.add( _tempVector.setFromMatrixPosition( object.parent.matrixWorld ) );
+					}
+					if ( axis.search( 'X' ) !== - 1 ) {
+						object.position.x = Math.round( object.position.x / this.translationSnap ) * this.translationSnap;
+					}
+					if ( axis.search( 'Y' ) !== - 1 ) {
+						object.position.y = Math.round( object.position.y / this.translationSnap ) * this.translationSnap;
+					}
+					if ( axis.search( 'Z' ) !== - 1 ) {
+						object.position.z = Math.round( object.position.z / this.translationSnap ) * this.translationSnap;
+					}
+					if ( object.parent ) {
+						object.position.sub( _tempVector.setFromMatrixPosition( object.parent.matrixWorld ) );
+					}
+				}
+			}
+			object.position.x = Math.max( this.minX, Math.min( this.maxX, object.position.x ) );
+			object.position.y = Math.max( this.minY, Math.min( this.maxY, object.position.y ) );
+			object.position.z = Math.max( this.minZ, Math.min( this.maxZ, object.position.z ) );
+		} else if ( mode === 'scale' ) {
+			if ( axis.search( 'XYZ' ) !== - 1 ) {
+				let d = this.pointEnd.length() / this.pointStart.length();
+				if ( this.pointEnd.dot( this.pointStart ) < 0 ) d *= - 1;
+				_tempVector2.set( d, d, d );
+			} else {
+				_tempVector.copy( this.pointStart );
+				_tempVector2.copy( this.pointEnd );
+				_tempVector.applyQuaternion( this._worldQuaternionInv );
+				_tempVector2.applyQuaternion( this._worldQuaternionInv );
+				_tempVector2.divide( _tempVector );
+				if ( axis.search( 'X' ) === - 1 ) {
+					_tempVector2.x = 1;
+				}
+				if ( axis.search( 'Y' ) === - 1 ) {
+					_tempVector2.y = 1;
+				}
+				if ( axis.search( 'Z' ) === - 1 ) {
+					_tempVector2.z = 1;
+				}
+			}
+			// Apply scale
+			object.scale.copy( this._scaleStart ).multiply( _tempVector2 );
+			if ( this.scaleSnap ) {
+				if ( axis.search( 'X' ) !== - 1 ) {
+					object.scale.x = Math.round( object.scale.x / this.scaleSnap ) * this.scaleSnap || this.scaleSnap;
+				}
+				if ( axis.search( 'Y' ) !== - 1 ) {
+					object.scale.y = Math.round( object.scale.y / this.scaleSnap ) * this.scaleSnap || this.scaleSnap;
+				}
+				if ( axis.search( 'Z' ) !== - 1 ) {
+					object.scale.z = Math.round( object.scale.z / this.scaleSnap ) * this.scaleSnap || this.scaleSnap;
+				}
+			}
+		} else if ( mode === 'rotate' ) {
+			this._offset.copy( this.pointEnd ).sub( this.pointStart );
+			const ROTATION_SPEED = 20 / this.worldPosition.distanceTo( _tempVector.setFromMatrixPosition( this.camera.matrixWorld ) );
+			let _inPlaneRotation = false;
+			if ( axis === 'XYZE' ) {
+				this.rotationAxis.copy( this._offset ).cross( this.eye ).normalize();
+				this.rotationAngle = this._offset.dot( _tempVector.copy( this.rotationAxis ).cross( this.eye ) ) * ROTATION_SPEED;
+			} else if ( axis === 'X' || axis === 'Y' || axis === 'Z' ) {
+				this.rotationAxis.copy( _unit[ axis ] );
+				_tempVector.copy( _unit[ axis ] );
+				if ( space === 'local' ) {
+					_tempVector.applyQuaternion( this.worldQuaternion );
+				}
+				_tempVector.cross( this.eye );
+				// When _tempVector is 0 after cross with this.eye the vectors are parallel and should use in-plane rotation logic.
+				if ( _tempVector.length() === 0 ) {
+					_inPlaneRotation = true;
+				} else {
+					this.rotationAngle = this._offset.dot( _tempVector.normalize() ) * ROTATION_SPEED;
+				}
+			}
+			if ( axis === 'E' || _inPlaneRotation ) {
+				this.rotationAxis.copy( this.eye );
+				this.rotationAngle = this.pointEnd.angleTo( this.pointStart );
+				this._startNorm.copy( this.pointStart ).normalize();
+				this._endNorm.copy( this.pointEnd ).normalize();
+				this.rotationAngle *= ( this._endNorm.cross( this._startNorm ).dot( this.eye ) < 0 ? 1 : - 1 );
+			}
+			// Apply rotation snap
+			if ( this.rotationSnap ) this.rotationAngle = Math.round( this.rotationAngle / this.rotationSnap ) * this.rotationSnap;
+			// Apply rotate
+			if ( space === 'local' && axis !== 'E' && axis !== 'XYZE' ) {
+				object.quaternion.copy( this._quaternionStart );
+				object.quaternion.multiply( _tempQuaternion.setFromAxisAngle( this.rotationAxis, this.rotationAngle ) ).normalize();
+			} else {
+				this.rotationAxis.applyQuaternion( this._parentQuaternionInv );
+				object.quaternion.copy( _tempQuaternion.setFromAxisAngle( this.rotationAxis, this.rotationAngle ) );
+				object.quaternion.multiply( this._quaternionStart ).normalize();
+			}
+		}
+		this.dispatchEvent( _changeEvent );
+		this.dispatchEvent( _objectChangeEvent );
+	}
+	pointerUp( pointer ) {
+		if ( pointer !== null && pointer.button !== 0 ) return;
+		if ( this.dragging && ( this.axis !== null ) ) {
+			_mouseUpEvent.mode = this.mode;
+			this.dispatchEvent( _mouseUpEvent );
+		}
+		this.dragging = false;
+		this.axis = null;
+	}
+	dispose() {
+		this.disconnect();
+		this._root.dispose();
+	}
+	// Set current object
+	attach( object ) {
+		this.object = object;
+		this._root.visible = true;
+		return this;
+	}
+	// Detach from object
+	detach() {
+		this.object = undefined;
+		this.axis = null;
+		this._root.visible = false;
+		return this;
+	}
+	reset() {
+		if ( ! this.enabled ) return;
+		if ( this.dragging ) {
+			this.object.position.copy( this._positionStart );
+			this.object.quaternion.copy( this._quaternionStart );
+			this.object.scale.copy( this._scaleStart );
+			this.dispatchEvent( _changeEvent );
+			this.dispatchEvent( _objectChangeEvent );
+			this.pointStart.copy( this.pointEnd );
+		}
+	}
+	getRaycaster() {
+		return _raycaster;
+	}
+	// TODO: deprecate
+	getMode() {
+		return this.mode;
+	}
+	setMode( mode ) {
+		this.mode = mode;
+	}
+	setTranslationSnap( translationSnap ) {
+		this.translationSnap = translationSnap;
+	}
+	setRotationSnap( rotationSnap ) {
+		this.rotationSnap = rotationSnap;
+	}
+	setScaleSnap( scaleSnap ) {
+		this.scaleSnap = scaleSnap;
+	}
+	setSize( size ) {
+		this.size = size;
+	}
+	setSpace( space ) {
+		this.space = space;
+	}
+}
+// mouse / touch event handlers
+function getPointer( event ) {
+	if ( this.domElement.ownerDocument.pointerLockElement ) {
+		return {
+			x: 0,
+			y: 0,
+			button: event.button
+		};
+	} else {
+		const rect = this.domElement.getBoundingClientRect();
+		return {
+			x: ( event.clientX - rect.left ) / rect.width * 2 - 1,
+			y: - ( event.clientY - rect.top ) / rect.height * 2 + 1,
+			button: event.button
+		};
+	}
+}
+function onPointerHover( event ) {
+	if ( ! this.enabled ) return;
+	switch ( event.pointerType ) {
+		case 'mouse':
+		case 'pen':
+			this.pointerHover( this._getPointer( event ) );
+			break;
+	}
+}
+function onPointerDown( event ) {
+	if ( ! this.enabled ) return;
+	if ( ! document.pointerLockElement ) {
+		this.domElement.setPointerCapture( event.pointerId );
+	}
+	this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+	this.pointerHover( this._getPointer( event ) );
+	this.pointerDown( this._getPointer( event ) );
+}
+function onPointerMove( event ) {
+	if ( ! this.enabled ) return;
+	this.pointerMove( this._getPointer( event ) );
+}
+function onPointerUp( event ) {
+	if ( ! this.enabled ) return;
+	this.domElement.releasePointerCapture( event.pointerId );
+	this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+	this.pointerUp( this._getPointer( event ) );
+}
+function intersectObjectWithRay( object, raycaster, includeInvisible ) {
+	const allIntersections = raycaster.intersectObject( object, true );
+	for ( let i = 0; i < allIntersections.length; i ++ ) {
+		if ( allIntersections[ i ].object.visible || includeInvisible ) {
+			return allIntersections[ i ];
+		}
+	}
+	return false;
+}
+//
+// Reusable utility variables
+const _tempEuler = new Euler();
+const _alignVector = new Vector3( 0, 1, 0 );
+const _zeroVector = new Vector3( 0, 0, 0 );
+const _lookAtMatrix = new Matrix4();
+const _tempQuaternion2 = new Quaternion();
+const _identityQuaternion = new Quaternion();
+const _dirVector = new Vector3();
+const _tempMatrix = new Matrix4();
+const _unitX = new Vector3( 1, 0, 0 );
+const _unitY = new Vector3( 0, 1, 0 );
+const _unitZ = new Vector3( 0, 0, 1 );
+const _v1 = new Vector3();
+const _v2 = new Vector3();
+const _v3 = new Vector3();
+class TransformControlsRoot extends Object3D {
+	constructor( controls ) {
+		super();
+		this.isTransformControlsRoot = true;
+		this.controls = controls;
+		this.visible = false;
+	}
+	// updateMatrixWorld updates key transformation variables
+	updateMatrixWorld( force ) {
+		const controls = this.controls;
+		if ( controls.object !== undefined ) {
+			controls.object.updateMatrixWorld();
+			if ( controls.object.parent === null ) {
+				console.error( 'TransformControls: The attached 3D object must be a part of the scene graph.' );
+			} else {
+				controls.object.parent.matrixWorld.decompose( controls._parentPosition, controls._parentQuaternion, controls._parentScale );
+			}
+			controls.object.matrixWorld.decompose( controls.worldPosition, controls.worldQuaternion, controls._worldScale );
+			controls._parentQuaternionInv.copy( controls._parentQuaternion ).invert();
+			controls._worldQuaternionInv.copy( controls.worldQuaternion ).invert();
+		}
+		controls.camera.updateMatrixWorld();
+		controls.camera.matrixWorld.decompose( controls.cameraPosition, controls.cameraQuaternion, controls._cameraScale );
+		if ( controls.camera.isOrthographicCamera ) {
+			controls.camera.getWorldDirection( controls.eye ).negate();
+		} else {
+			controls.eye.copy( controls.cameraPosition ).sub( controls.worldPosition ).normalize();
+		}
+		super.updateMatrixWorld( force );
+	}
+	dispose() {
+		this.traverse( function ( child ) {
+			if ( child.geometry ) child.geometry.dispose();
+			if ( child.material ) child.material.dispose();
+		} );
+	}
+}
+class TransformControlsGizmo extends Object3D {
+	constructor() {
+		super();
+		this.isTransformControlsGizmo = true;
+		this.type = 'TransformControlsGizmo';
+		// shared materials
+		const gizmoMaterial = new MeshBasicMaterial( {
+			depthTest: false,
+			depthWrite: false,
+			fog: false,
+			toneMapped: false,
+			transparent: true
+		} );
+		const gizmoLineMaterial = new LineBasicMaterial( {
+			depthTest: false,
+			depthWrite: false,
+			fog: false,
+			toneMapped: false,
+			transparent: true
+		} );
+		// Make unique material for each axis/color
+		const matInvisible = gizmoMaterial.clone();
+		matInvisible.opacity = 0.15;
+		const matHelper = gizmoLineMaterial.clone();
+		matHelper.opacity = 0.5;
+		const matRed = gizmoMaterial.clone();
+		matRed.color.setHex( 0xff0000 );
+		const matGreen = gizmoMaterial.clone();
+		matGreen.color.setHex( 0x00ff00 );
+		const matBlue = gizmoMaterial.clone();
+		matBlue.color.setHex( 0x0000ff );
+		const matRedTransparent = gizmoMaterial.clone();
+		matRedTransparent.color.setHex( 0xff0000 );
+		matRedTransparent.opacity = 0.5;
+		const matGreenTransparent = gizmoMaterial.clone();
+		matGreenTransparent.color.setHex( 0x00ff00 );
+		matGreenTransparent.opacity = 0.5;
+		const matBlueTransparent = gizmoMaterial.clone();
+		matBlueTransparent.color.setHex( 0x0000ff );
+		matBlueTransparent.opacity = 0.5;
+		const matWhiteTransparent = gizmoMaterial.clone();
+		matWhiteTransparent.opacity = 0.25;
+		const matYellowTransparent = gizmoMaterial.clone();
+		matYellowTransparent.color.setHex( 0xffff00 );
+		matYellowTransparent.opacity = 0.25;
+		const matYellow = gizmoMaterial.clone();
+		matYellow.color.setHex( 0xffff00 );
+		const matGray = gizmoMaterial.clone();
+		matGray.color.setHex( 0x787878 );
+		// reusable geometry
+		const arrowGeometry = new CylinderGeometry( 0, 0.04, 0.1, 12 );
+		arrowGeometry.translate( 0, 0.05, 0 );
+		const scaleHandleGeometry = new BoxGeometry( 0.08, 0.08, 0.08 );
+		scaleHandleGeometry.translate( 0, 0.04, 0 );
+		const lineGeometry = new BufferGeometry();
+		lineGeometry.setAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0,	1, 0, 0 ], 3 ) );
+		const lineGeometry2 = new CylinderGeometry( 0.0075, 0.0075, 0.5, 3 );
+		lineGeometry2.translate( 0, 0.25, 0 );
+		function CircleGeometry( radius, arc ) {
+			const geometry = new TorusGeometry( radius, 0.0075, 3, 64, arc * Math.PI * 2 );
+			geometry.rotateY( Math.PI / 2 );
+			geometry.rotateX( Math.PI / 2 );
+			return geometry;
+		}
+		// Special geometry for transform helper. If scaled with position vector it spans from [0,0,0] to position
+		function TranslateHelperGeometry() {
+			const geometry = new BufferGeometry();
+			geometry.setAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 1, 1, 1 ], 3 ) );
+			return geometry;
+		}
+		// Gizmo definitions - custom hierarchy definitions for setupGizmo() function
+		const gizmoTranslate = {
+			X: [
+				[ new Mesh( arrowGeometry, matRed ), [ 0.5, 0, 0 ], [ 0, 0, - Math.PI / 2 ]],
+				[ new Mesh( arrowGeometry, matRed ), [ - 0.5, 0, 0 ], [ 0, 0, Math.PI / 2 ]],
+				[ new Mesh( lineGeometry2, matRed ), [ 0, 0, 0 ], [ 0, 0, - Math.PI / 2 ]]
+			],
+			Y: [
+				[ new Mesh( arrowGeometry, matGreen ), [ 0, 0.5, 0 ]],
+				[ new Mesh( arrowGeometry, matGreen ), [ 0, - 0.5, 0 ], [ Math.PI, 0, 0 ]],
+				[ new Mesh( lineGeometry2, matGreen ) ]
+			],
+			Z: [
+				[ new Mesh( arrowGeometry, matBlue ), [ 0, 0, 0.5 ], [ Math.PI / 2, 0, 0 ]],
+				[ new Mesh( arrowGeometry, matBlue ), [ 0, 0, - 0.5 ], [ - Math.PI / 2, 0, 0 ]],
+				[ new Mesh( lineGeometry2, matBlue ), null, [ Math.PI / 2, 0, 0 ]]
+			],
+			XYZ: [
+				[ new Mesh( new OctahedronGeometry( 0.1, 0 ), matWhiteTransparent.clone() ), [ 0, 0, 0 ]]
+			],
+			XY: [
+				[ new Mesh( new BoxGeometry( 0.15, 0.15, 0.01 ), matBlueTransparent.clone() ), [ 0.15, 0.15, 0 ]]
+			],
+			YZ: [
+				[ new Mesh( new BoxGeometry( 0.15, 0.15, 0.01 ), matRedTransparent.clone() ), [ 0, 0.15, 0.15 ], [ 0, Math.PI / 2, 0 ]]
+			],
+			XZ: [
+				[ new Mesh( new BoxGeometry( 0.15, 0.15, 0.01 ), matGreenTransparent.clone() ), [ 0.15, 0, 0.15 ], [ - Math.PI / 2, 0, 0 ]]
+			]
+		};
+		const pickerTranslate = {
+			X: [
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0.3, 0, 0 ], [ 0, 0, - Math.PI / 2 ]],
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ - 0.3, 0, 0 ], [ 0, 0, Math.PI / 2 ]]
+			],
+			Y: [
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, 0.3, 0 ]],
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, - 0.3, 0 ], [ 0, 0, Math.PI ]]
+			],
+			Z: [
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, 0, 0.3 ], [ Math.PI / 2, 0, 0 ]],
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, 0, - 0.3 ], [ - Math.PI / 2, 0, 0 ]]
+			],
+			XYZ: [
+				[ new Mesh( new OctahedronGeometry( 0.2, 0 ), matInvisible ) ]
+			],
+			XY: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.01 ), matInvisible ), [ 0.15, 0.15, 0 ]]
+			],
+			YZ: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.01 ), matInvisible ), [ 0, 0.15, 0.15 ], [ 0, Math.PI / 2, 0 ]]
+			],
+			XZ: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.01 ), matInvisible ), [ 0.15, 0, 0.15 ], [ - Math.PI / 2, 0, 0 ]]
+			]
+		};
+		const helperTranslate = {
+			START: [
+				[ new Mesh( new OctahedronGeometry( 0.01, 2 ), matHelper ), null, null, null, 'helper' ]
+			],
+			END: [
+				[ new Mesh( new OctahedronGeometry( 0.01, 2 ), matHelper ), null, null, null, 'helper' ]
+			],
+			DELTA: [
+				[ new Line( TranslateHelperGeometry(), matHelper ), null, null, null, 'helper' ]
+			],
+			X: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ - 1e3, 0, 0 ], null, [ 1e6, 1, 1 ], 'helper' ]
+			],
+			Y: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ 0, - 1e3, 0 ], [ 0, 0, Math.PI / 2 ], [ 1e6, 1, 1 ], 'helper' ]
+			],
+			Z: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ 0, 0, - 1e3 ], [ 0, - Math.PI / 2, 0 ], [ 1e6, 1, 1 ], 'helper' ]
+			]
+		};
+		const gizmoRotate = {
+			XYZE: [
+				[ new Mesh( CircleGeometry( 0.5, 1 ), matGray ), null, [ 0, Math.PI / 2, 0 ]]
+			],
+			X: [
+				[ new Mesh( CircleGeometry( 0.5, 0.5 ), matRed ) ]
+			],
+			Y: [
+				[ new Mesh( CircleGeometry( 0.5, 0.5 ), matGreen ), null, [ 0, 0, - Math.PI / 2 ]]
+			],
+			Z: [
+				[ new Mesh( CircleGeometry( 0.5, 0.5 ), matBlue ), null, [ 0, Math.PI / 2, 0 ]]
+			],
+			E: [
+				[ new Mesh( CircleGeometry( 0.75, 1 ), matYellowTransparent ), null, [ 0, Math.PI / 2, 0 ]]
+			]
+		};
+		const helperRotate = {
+			AXIS: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ - 1e3, 0, 0 ], null, [ 1e6, 1, 1 ], 'helper' ]
+			]
+		};
+		const pickerRotate = {
+			XYZE: [
+				[ new Mesh( new SphereGeometry( 0.25, 10, 8 ), matInvisible ) ]
+			],
+			X: [
+				[ new Mesh( new TorusGeometry( 0.5, 0.1, 4, 24 ), matInvisible ), [ 0, 0, 0 ], [ 0, - Math.PI / 2, - Math.PI / 2 ]],
+			],
+			Y: [
+				[ new Mesh( new TorusGeometry( 0.5, 0.1, 4, 24 ), matInvisible ), [ 0, 0, 0 ], [ Math.PI / 2, 0, 0 ]],
+			],
+			Z: [
+				[ new Mesh( new TorusGeometry( 0.5, 0.1, 4, 24 ), matInvisible ), [ 0, 0, 0 ], [ 0, 0, - Math.PI / 2 ]],
+			],
+			E: [
+				[ new Mesh( new TorusGeometry( 0.75, 0.1, 2, 24 ), matInvisible ) ]
+			]
+		};
+		const gizmoScale = {
+			X: [
+				[ new Mesh( scaleHandleGeometry, matRed ), [ 0.5, 0, 0 ], [ 0, 0, - Math.PI / 2 ]],
+				[ new Mesh( lineGeometry2, matRed ), [ 0, 0, 0 ], [ 0, 0, - Math.PI / 2 ]],
+				[ new Mesh( scaleHandleGeometry, matRed ), [ - 0.5, 0, 0 ], [ 0, 0, Math.PI / 2 ]],
+			],
+			Y: [
+				[ new Mesh( scaleHandleGeometry, matGreen ), [ 0, 0.5, 0 ]],
+				[ new Mesh( lineGeometry2, matGreen ) ],
+				[ new Mesh( scaleHandleGeometry, matGreen ), [ 0, - 0.5, 0 ], [ 0, 0, Math.PI ]],
+			],
+			Z: [
+				[ new Mesh( scaleHandleGeometry, matBlue ), [ 0, 0, 0.5 ], [ Math.PI / 2, 0, 0 ]],
+				[ new Mesh( lineGeometry2, matBlue ), [ 0, 0, 0 ], [ Math.PI / 2, 0, 0 ]],
+				[ new Mesh( scaleHandleGeometry, matBlue ), [ 0, 0, - 0.5 ], [ - Math.PI / 2, 0, 0 ]]
+			],
+			XY: [
+				[ new Mesh( new BoxGeometry( 0.15, 0.15, 0.01 ), matBlueTransparent ), [ 0.15, 0.15, 0 ]]
+			],
+			YZ: [
+				[ new Mesh( new BoxGeometry( 0.15, 0.15, 0.01 ), matRedTransparent ), [ 0, 0.15, 0.15 ], [ 0, Math.PI / 2, 0 ]]
+			],
+			XZ: [
+				[ new Mesh( new BoxGeometry( 0.15, 0.15, 0.01 ), matGreenTransparent ), [ 0.15, 0, 0.15 ], [ - Math.PI / 2, 0, 0 ]]
+			],
+			XYZ: [
+				[ new Mesh( new BoxGeometry( 0.1, 0.1, 0.1 ), matWhiteTransparent.clone() ) ],
+			]
+		};
+		const pickerScale = {
+			X: [
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0.3, 0, 0 ], [ 0, 0, - Math.PI / 2 ]],
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ - 0.3, 0, 0 ], [ 0, 0, Math.PI / 2 ]]
+			],
+			Y: [
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, 0.3, 0 ]],
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, - 0.3, 0 ], [ 0, 0, Math.PI ]]
+			],
+			Z: [
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, 0, 0.3 ], [ Math.PI / 2, 0, 0 ]],
+				[ new Mesh( new CylinderGeometry( 0.2, 0, 0.6, 4 ), matInvisible ), [ 0, 0, - 0.3 ], [ - Math.PI / 2, 0, 0 ]]
+			],
+			XY: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.01 ), matInvisible ), [ 0.15, 0.15, 0 ]],
+			],
+			YZ: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.01 ), matInvisible ), [ 0, 0.15, 0.15 ], [ 0, Math.PI / 2, 0 ]],
+			],
+			XZ: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.01 ), matInvisible ), [ 0.15, 0, 0.15 ], [ - Math.PI / 2, 0, 0 ]],
+			],
+			XYZ: [
+				[ new Mesh( new BoxGeometry( 0.2, 0.2, 0.2 ), matInvisible ), [ 0, 0, 0 ]],
+			]
+		};
+		const helperScale = {
+			X: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ - 1e3, 0, 0 ], null, [ 1e6, 1, 1 ], 'helper' ]
+			],
+			Y: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ 0, - 1e3, 0 ], [ 0, 0, Math.PI / 2 ], [ 1e6, 1, 1 ], 'helper' ]
+			],
+			Z: [
+				[ new Line( lineGeometry, matHelper.clone() ), [ 0, 0, - 1e3 ], [ 0, - Math.PI / 2, 0 ], [ 1e6, 1, 1 ], 'helper' ]
+			]
+		};
+		// Creates an Object3D with gizmos described in custom hierarchy definition.
+		function setupGizmo( gizmoMap ) {
+			const gizmo = new Object3D();
+			for ( const name in gizmoMap ) {
+				for ( let i = gizmoMap[ name ].length; i --; ) {
+					const object = gizmoMap[ name ][ i ][ 0 ].clone();
+					const position = gizmoMap[ name ][ i ][ 1 ];
+					const rotation = gizmoMap[ name ][ i ][ 2 ];
+					const scale = gizmoMap[ name ][ i ][ 3 ];
+					const tag = gizmoMap[ name ][ i ][ 4 ];
+					// name and tag properties are essential for picking and updating logic.
+					object.name = name;
+					object.tag = tag;
+					if ( position ) {
+						object.position.set( position[ 0 ], position[ 1 ], position[ 2 ] );
+					}
+					if ( rotation ) {
+						object.rotation.set( rotation[ 0 ], rotation[ 1 ], rotation[ 2 ] );
+					}
+					if ( scale ) {
+						object.scale.set( scale[ 0 ], scale[ 1 ], scale[ 2 ] );
+					}
+					object.updateMatrix();
+					const tempGeometry = object.geometry.clone();
+					tempGeometry.applyMatrix4( object.matrix );
+					object.geometry = tempGeometry;
+					object.renderOrder = Infinity;
+					object.position.set( 0, 0, 0 );
+					object.rotation.set( 0, 0, 0 );
+					object.scale.set( 1, 1, 1 );
+					gizmo.add( object );
+				}
+			}
+			return gizmo;
+		}
+		// Gizmo creation
+		this.gizmo = {};
+		this.picker = {};
+		this.helper = {};
+		this.add( this.gizmo[ 'translate' ] = setupGizmo( gizmoTranslate ) );
+		this.add( this.gizmo[ 'rotate' ] = setupGizmo( gizmoRotate ) );
+		this.add( this.gizmo[ 'scale' ] = setupGizmo( gizmoScale ) );
+		this.add( this.picker[ 'translate' ] = setupGizmo( pickerTranslate ) );
+		this.add( this.picker[ 'rotate' ] = setupGizmo( pickerRotate ) );
+		this.add( this.picker[ 'scale' ] = setupGizmo( pickerScale ) );
+		this.add( this.helper[ 'translate' ] = setupGizmo( helperTranslate ) );
+		this.add( this.helper[ 'rotate' ] = setupGizmo( helperRotate ) );
+		this.add( this.helper[ 'scale' ] = setupGizmo( helperScale ) );
+		// Pickers should be hidden always
+		this.picker[ 'translate' ].visible = false;
+		this.picker[ 'rotate' ].visible = false;
+		this.picker[ 'scale' ].visible = false;
+	}
+	// updateMatrixWorld will update transformations and appearance of individual handles
+	updateMatrixWorld( force ) {
+		const space = ( this.mode === 'scale' ) ? 'local' : this.space; // scale always oriented to local rotation
+		const quaternion = ( space === 'local' ) ? this.worldQuaternion : _identityQuaternion;
+		// Show only gizmos for current transform mode
+		this.gizmo[ 'translate' ].visible = this.mode === 'translate';
+		this.gizmo[ 'rotate' ].visible = this.mode === 'rotate';
+		this.gizmo[ 'scale' ].visible = this.mode === 'scale';
+		this.helper[ 'translate' ].visible = this.mode === 'translate';
+		this.helper[ 'rotate' ].visible = this.mode === 'rotate';
+		this.helper[ 'scale' ].visible = this.mode === 'scale';
+		let handles = [];
+		handles = handles.concat( this.picker[ this.mode ].children );
+		handles = handles.concat( this.gizmo[ this.mode ].children );
+		handles = handles.concat( this.helper[ this.mode ].children );
+		for ( let i = 0; i < handles.length; i ++ ) {
+			const handle = handles[ i ];
+			// hide aligned to camera
+			handle.visible = true;
+			handle.rotation.set( 0, 0, 0 );
+			handle.position.copy( this.worldPosition );
+			let factor;
+			if ( this.camera.isOrthographicCamera ) {
+				factor = ( this.camera.top - this.camera.bottom ) / this.camera.zoom;
+			} else {
+				factor = this.worldPosition.distanceTo( this.cameraPosition ) * Math.min( 1.9 * Math.tan( Math.PI * this.camera.fov / 360 ) / this.camera.zoom, 7 );
+			}
+			handle.scale.set( 1, 1, 1 ).multiplyScalar( factor * this.size / 4 );
+			// TODO: simplify helpers and consider decoupling from gizmo
+			if ( handle.tag === 'helper' ) {
+				handle.visible = false;
+				if ( handle.name === 'AXIS' ) {
+					handle.visible = !! this.axis;
+					if ( this.axis === 'X' ) {
+						_tempQuaternion.setFromEuler( _tempEuler.set( 0, 0, 0 ) );
+						handle.quaternion.copy( quaternion ).multiply( _tempQuaternion );
+						if ( Math.abs( _alignVector.copy( _unitX ).applyQuaternion( quaternion ).dot( this.eye ) ) > 0.9 ) {
+							handle.visible = false;
+						}
+					}
+					if ( this.axis === 'Y' ) {
+						_tempQuaternion.setFromEuler( _tempEuler.set( 0, 0, Math.PI / 2 ) );
+						handle.quaternion.copy( quaternion ).multiply( _tempQuaternion );
+						if ( Math.abs( _alignVector.copy( _unitY ).applyQuaternion( quaternion ).dot( this.eye ) ) > 0.9 ) {
+							handle.visible = false;
+						}
+					}
+					if ( this.axis === 'Z' ) {
+						_tempQuaternion.setFromEuler( _tempEuler.set( 0, Math.PI / 2, 0 ) );
+						handle.quaternion.copy( quaternion ).multiply( _tempQuaternion );
+						if ( Math.abs( _alignVector.copy( _unitZ ).applyQuaternion( quaternion ).dot( this.eye ) ) > 0.9 ) {
+							handle.visible = false;
+						}
+					}
+					if ( this.axis === 'XYZE' ) {
+						_tempQuaternion.setFromEuler( _tempEuler.set( 0, Math.PI / 2, 0 ) );
+						_alignVector.copy( this.rotationAxis );
+						handle.quaternion.setFromRotationMatrix( _lookAtMatrix.lookAt( _zeroVector, _alignVector, _unitY ) );
+						handle.quaternion.multiply( _tempQuaternion );
+						handle.visible = this.dragging;
+					}
+					if ( this.axis === 'E' ) {
+						handle.visible = false;
+					}
+				} else if ( handle.name === 'START' ) {
+					handle.position.copy( this.worldPositionStart );
+					handle.visible = this.dragging;
+				} else if ( handle.name === 'END' ) {
+					handle.position.copy( this.worldPosition );
+					handle.visible = this.dragging;
+				} else if ( handle.name === 'DELTA' ) {
+					handle.position.copy( this.worldPositionStart );
+					handle.quaternion.copy( this.worldQuaternionStart );
+					_tempVector.set( 1e-10, 1e-10, 1e-10 ).add( this.worldPositionStart ).sub( this.worldPosition ).multiplyScalar( - 1 );
+					_tempVector.applyQuaternion( this.worldQuaternionStart.clone().invert() );
+					handle.scale.copy( _tempVector );
+					handle.visible = this.dragging;
+				} else {
+					handle.quaternion.copy( quaternion );
+					if ( this.dragging ) {
+						handle.position.copy( this.worldPositionStart );
+					} else {
+						handle.position.copy( this.worldPosition );
+					}
+					if ( this.axis ) {
+						handle.visible = this.axis.search( handle.name ) !== - 1;
+					}
+				}
+				// If updating helper, skip rest of the loop
+				continue;
+			}
+			// Align handles to current local or world rotation
+			handle.quaternion.copy( quaternion );
+			if ( this.mode === 'translate' || this.mode === 'scale' ) {
+				// Hide translate and scale axis facing the camera
+				const AXIS_HIDE_THRESHOLD = 0.99;
+				const PLANE_HIDE_THRESHOLD = 0.2;
+				if ( handle.name === 'X' ) {
+					if ( Math.abs( _alignVector.copy( _unitX ).applyQuaternion( quaternion ).dot( this.eye ) ) > AXIS_HIDE_THRESHOLD ) {
+						handle.scale.set( 1e-10, 1e-10, 1e-10 );
+						handle.visible = false;
+					}
+				}
+				if ( handle.name === 'Y' ) {
+					if ( Math.abs( _alignVector.copy( _unitY ).applyQuaternion( quaternion ).dot( this.eye ) ) > AXIS_HIDE_THRESHOLD ) {
+						handle.scale.set( 1e-10, 1e-10, 1e-10 );
+						handle.visible = false;
+					}
+				}
+				if ( handle.name === 'Z' ) {
+					if ( Math.abs( _alignVector.copy( _unitZ ).applyQuaternion( quaternion ).dot( this.eye ) ) > AXIS_HIDE_THRESHOLD ) {
+						handle.scale.set( 1e-10, 1e-10, 1e-10 );
+						handle.visible = false;
+					}
+				}
+				if ( handle.name === 'XY' ) {
+					if ( Math.abs( _alignVector.copy( _unitZ ).applyQuaternion( quaternion ).dot( this.eye ) ) < PLANE_HIDE_THRESHOLD ) {
+						handle.scale.set( 1e-10, 1e-10, 1e-10 );
+						handle.visible = false;
+					}
+				}
+				if ( handle.name === 'YZ' ) {
+					if ( Math.abs( _alignVector.copy( _unitX ).applyQuaternion( quaternion ).dot( this.eye ) ) < PLANE_HIDE_THRESHOLD ) {
+						handle.scale.set( 1e-10, 1e-10, 1e-10 );
+						handle.visible = false;
+					}
+				}
+				if ( handle.name === 'XZ' ) {
+					if ( Math.abs( _alignVector.copy( _unitY ).applyQuaternion( quaternion ).dot( this.eye ) ) < PLANE_HIDE_THRESHOLD ) {
+						handle.scale.set( 1e-10, 1e-10, 1e-10 );
+						handle.visible = false;
+					}
+				}
+			} else if ( this.mode === 'rotate' ) {
+				// Align handles to current local or world rotation
+				_tempQuaternion2.copy( quaternion );
+				_alignVector.copy( this.eye ).applyQuaternion( _tempQuaternion.copy( quaternion ).invert() );
+				if ( handle.name.search( 'E' ) !== - 1 ) {
+					handle.quaternion.setFromRotationMatrix( _lookAtMatrix.lookAt( this.eye, _zeroVector, _unitY ) );
+				}
+				if ( handle.name === 'X' ) {
+					_tempQuaternion.setFromAxisAngle( _unitX, Math.atan2( - _alignVector.y, _alignVector.z ) );
+					_tempQuaternion.multiplyQuaternions( _tempQuaternion2, _tempQuaternion );
+					handle.quaternion.copy( _tempQuaternion );
+				}
+				if ( handle.name === 'Y' ) {
+					_tempQuaternion.setFromAxisAngle( _unitY, Math.atan2( _alignVector.x, _alignVector.z ) );
+					_tempQuaternion.multiplyQuaternions( _tempQuaternion2, _tempQuaternion );
+					handle.quaternion.copy( _tempQuaternion );
+				}
+				if ( handle.name === 'Z' ) {
+					_tempQuaternion.setFromAxisAngle( _unitZ, Math.atan2( _alignVector.y, _alignVector.x ) );
+					_tempQuaternion.multiplyQuaternions( _tempQuaternion2, _tempQuaternion );
+					handle.quaternion.copy( _tempQuaternion );
+				}
+			}
+			// Hide disabled axes
+			handle.visible = handle.visible && ( handle.name.indexOf( 'X' ) === - 1 || this.showX );
+			handle.visible = handle.visible && ( handle.name.indexOf( 'Y' ) === - 1 || this.showY );
+			handle.visible = handle.visible && ( handle.name.indexOf( 'Z' ) === - 1 || this.showZ );
+			handle.visible = handle.visible && ( handle.name.indexOf( 'E' ) === - 1 || ( this.showX && this.showY && this.showZ ) );
+			// highlight selected axis
+			handle.material._color = handle.material._color || handle.material.color.clone();
+			handle.material._opacity = handle.material._opacity || handle.material.opacity;
+			handle.material.color.copy( handle.material._color );
+			handle.material.opacity = handle.material._opacity;
+			if ( this.enabled && this.axis ) {
+				if ( handle.name === this.axis ) {
+					handle.material.color.setHex( 0xffff00 );
+					handle.material.opacity = 1.0;
+				} else if ( this.axis.split( '' ).some( function ( a ) {
+					return handle.name === a;
+				} ) ) {
+					handle.material.color.setHex( 0xffff00 );
+					handle.material.opacity = 1.0;
+				}
+			}
+		}
+		super.updateMatrixWorld( force );
+	}
+}
+//
+class TransformControlsPlane extends Mesh {
+	constructor() {
+		super(
+			new PlaneGeometry( 100000, 100000, 2, 2 ),
+			new MeshBasicMaterial( { visible: false, wireframe: true, side: DoubleSide, transparent: true, opacity: 0.1, toneMapped: false } )
+		);
+		this.isTransformControlsPlane = true;
+		this.type = 'TransformControlsPlane';
+	}
+	updateMatrixWorld( force ) {
+		let space = this.space;
+		this.position.copy( this.worldPosition );
+		if ( this.mode === 'scale' ) space = 'local'; // scale always oriented to local rotation
+		_v1.copy( _unitX ).applyQuaternion( space === 'local' ? this.worldQuaternion : _identityQuaternion );
+		_v2.copy( _unitY ).applyQuaternion( space === 'local' ? this.worldQuaternion : _identityQuaternion );
+		_v3.copy( _unitZ ).applyQuaternion( space === 'local' ? this.worldQuaternion : _identityQuaternion );
+		// Align the plane for current transform mode, axis and space.
+		_alignVector.copy( _v2 );
+		switch ( this.mode ) {
+			case 'translate':
+			case 'scale':
+				switch ( this.axis ) {
+					case 'X':
+						_alignVector.copy( this.eye ).cross( _v1 );
+						_dirVector.copy( _v1 ).cross( _alignVector );
+						break;
+					case 'Y':
+						_alignVector.copy( this.eye ).cross( _v2 );
+						_dirVector.copy( _v2 ).cross( _alignVector );
+						break;
+					case 'Z':
+						_alignVector.copy( this.eye ).cross( _v3 );
+						_dirVector.copy( _v3 ).cross( _alignVector );
+						break;
+					case 'XY':
+						_dirVector.copy( _v3 );
+						break;
+					case 'YZ':
+						_dirVector.copy( _v1 );
+						break;
+					case 'XZ':
+						_alignVector.copy( _v3 );
+						_dirVector.copy( _v2 );
+						break;
+					case 'XYZ':
+					case 'E':
+						_dirVector.set( 0, 0, 0 );
+						break;
+				}
+				break;
+			case 'rotate':
+			default:
+				// special case for rotate
+				_dirVector.set( 0, 0, 0 );
+		}
+		if ( _dirVector.length() === 0 ) {
+			// If in rotate mode, make the plane parallel to camera
+			this.quaternion.copy( this.cameraQuaternion );
+		} else {
+			_tempMatrix.lookAt( _tempVector.set( 0, 0, 0 ), _dirVector, _alignVector );
+			this.quaternion.setFromRotationMatrix( _tempMatrix );
+		}
+		super.updateMatrixWorld( force );
+	}
+}
+export { TransformControls, TransformControlsGizmo, TransformControlsPlane };

libs/three.js/0.172.0/jsm/csm/CSM.js ADDED Viewed

	@@ -0,0 +1,384 @@

+import {
+	Vector2,
+	Vector3,
+	DirectionalLight,
+	MathUtils,
+	ShaderChunk,
+	Matrix4,
+	Box3
+} from 'three';
+import { CSMFrustum } from './CSMFrustum.js';
+import { CSMShader } from './CSMShader.js';
+const _cameraToLightMatrix = new Matrix4();
+const _lightSpaceFrustum = new CSMFrustum( { webGL: true } );
+const _center = new Vector3();
+const _bbox = new Box3();
+const _uniformArray = [];
+const _logArray = [];
+const _lightOrientationMatrix = new Matrix4();
+const _lightOrientationMatrixInverse = new Matrix4();
+const _up = new Vector3( 0, 1, 0 );
+export class CSM {
+	constructor( data ) {
+		this.camera = data.camera;
+		this.parent = data.parent;
+		this.cascades = data.cascades || 3;
+		this.maxFar = data.maxFar || 100000;
+		this.mode = data.mode || 'practical';
+		this.shadowMapSize = data.shadowMapSize || 2048;
+		this.shadowBias = data.shadowBias || 0.000001;
+		this.lightDirection = data.lightDirection || new Vector3( 1, - 1, 1 ).normalize();
+		this.lightIntensity = data.lightIntensity || 3;
+		this.lightNear = data.lightNear || 1;
+		this.lightFar = data.lightFar || 2000;
+		this.lightMargin = data.lightMargin || 200;
+		this.customSplitsCallback = data.customSplitsCallback;
+		this.fade = false;
+		this.mainFrustum = new CSMFrustum( { webGL: true } );
+		this.frustums = [];
+		this.breaks = [];
+		this.lights = [];
+		this.shaders = new Map();
+		this.createLights();
+		this.updateFrustums();
+		this.injectInclude();
+	}
+	createLights() {
+		for ( let i = 0; i < this.cascades; i ++ ) {
+			const light = new DirectionalLight( 0xffffff, this.lightIntensity );
+			light.castShadow = true;
+			light.shadow.mapSize.width = this.shadowMapSize;
+			light.shadow.mapSize.height = this.shadowMapSize;
+			light.shadow.camera.near = this.lightNear;
+			light.shadow.camera.far = this.lightFar;
+			light.shadow.bias = this.shadowBias;
+			this.parent.add( light );
+			this.parent.add( light.target );
+			this.lights.push( light );
+		}
+	}
+	initCascades() {
+		const camera = this.camera;
+		camera.updateProjectionMatrix();
+		this.mainFrustum.setFromProjectionMatrix( camera.projectionMatrix, this.maxFar );
+		this.mainFrustum.split( this.breaks, this.frustums );
+	}
+	updateShadowBounds() {
+		const frustums = this.frustums;
+		for ( let i = 0; i < frustums.length; i ++ ) {
+			const light = this.lights[ i ];
+			const shadowCam = light.shadow.camera;
+			const frustum = this.frustums[ i ];
+			// Get the two points that represent that furthest points on the frustum assuming
+			// that's either the diagonal across the far plane or the diagonal across the whole
+			// frustum itself.
+			const nearVerts = frustum.vertices.near;
+			const farVerts = frustum.vertices.far;
+			const point1 = farVerts[ 0 ];
+			let point2;
+			if ( point1.distanceTo( farVerts[ 2 ] ) > point1.distanceTo( nearVerts[ 2 ] ) ) {
+				point2 = farVerts[ 2 ];
+			} else {
+				point2 = nearVerts[ 2 ];
+			}
+			let squaredBBWidth = point1.distanceTo( point2 );
+			if ( this.fade ) {
+				// expand the shadow extents by the fade margin if fade is enabled.
+				const camera = this.camera;
+				const far = Math.max( camera.far, this.maxFar );
+				const linearDepth = frustum.vertices.far[ 0 ].z / ( far - camera.near );
+				const margin = 0.25 * Math.pow( linearDepth, 2.0 ) * ( far - camera.near );
+				squaredBBWidth += margin;
+			}
+			shadowCam.left = - squaredBBWidth / 2;
+			shadowCam.right = squaredBBWidth / 2;
+			shadowCam.top = squaredBBWidth / 2;
+			shadowCam.bottom = - squaredBBWidth / 2;
+			shadowCam.updateProjectionMatrix();
+		}
+	}
+	getBreaks() {
+		const camera = this.camera;
+		const far = Math.min( camera.far, this.maxFar );
+		this.breaks.length = 0;
+		switch ( this.mode ) {
+			case 'uniform':
+				uniformSplit( this.cascades, camera.near, far, this.breaks );
+				break;
+			case 'logarithmic':
+				logarithmicSplit( this.cascades, camera.near, far, this.breaks );
+				break;
+			case 'practical':
+				practicalSplit( this.cascades, camera.near, far, 0.5, this.breaks );
+				break;
+			case 'custom':
+				if ( this.customSplitsCallback === undefined ) console.error( 'CSM: Custom split scheme callback not defined.' );
+				this.customSplitsCallback( this.cascades, camera.near, far, this.breaks );
+				break;
+		}
+		function uniformSplit( amount, near, far, target ) {
+			for ( let i = 1; i < amount; i ++ ) {
+				target.push( ( near + ( far - near ) * i / amount ) / far );
+			}
+			target.push( 1 );
+		}
+		function logarithmicSplit( amount, near, far, target ) {
+			for ( let i = 1; i < amount; i ++ ) {
+				target.push( ( near * ( far / near ) ** ( i / amount ) ) / far );
+			}
+			target.push( 1 );
+		}
+		function practicalSplit( amount, near, far, lambda, target ) {
+			_uniformArray.length = 0;
+			_logArray.length = 0;
+			logarithmicSplit( amount, near, far, _logArray );
+			uniformSplit( amount, near, far, _uniformArray );
+			for ( let i = 1; i < amount; i ++ ) {
+				target.push( MathUtils.lerp( _uniformArray[ i - 1 ], _logArray[ i - 1 ], lambda ) );
+			}
+			target.push( 1 );
+		}
+	}
+	update() {
+		const camera = this.camera;
+		const frustums = this.frustums;
+		// for each frustum we need to find its min-max box aligned with the light orientation
+		// the position in _lightOrientationMatrix does not matter, as we transform there and back
+		_lightOrientationMatrix.lookAt( new Vector3(), this.lightDirection, _up );
+		_lightOrientationMatrixInverse.copy( _lightOrientationMatrix ).invert();
+		for ( let i = 0; i < frustums.length; i ++ ) {
+			const light = this.lights[ i ];
+			const shadowCam = light.shadow.camera;
+			const texelWidth = ( shadowCam.right - shadowCam.left ) / this.shadowMapSize;
+			const texelHeight = ( shadowCam.top - shadowCam.bottom ) / this.shadowMapSize;
+			_cameraToLightMatrix.multiplyMatrices( _lightOrientationMatrixInverse, camera.matrixWorld );
+			frustums[ i ].toSpace( _cameraToLightMatrix, _lightSpaceFrustum );
+			const nearVerts = _lightSpaceFrustum.vertices.near;
+			const farVerts = _lightSpaceFrustum.vertices.far;
+			_bbox.makeEmpty();
+			for ( let j = 0; j < 4; j ++ ) {
+				_bbox.expandByPoint( nearVerts[ j ] );
+				_bbox.expandByPoint( farVerts[ j ] );
+			}
+			_bbox.getCenter( _center );
+			_center.z = _bbox.max.z + this.lightMargin;
+			_center.x = Math.floor( _center.x / texelWidth ) * texelWidth;
+			_center.y = Math.floor( _center.y / texelHeight ) * texelHeight;
+			_center.applyMatrix4( _lightOrientationMatrix );
+			light.position.copy( _center );
+			light.target.position.copy( _center );
+			light.target.position.x += this.lightDirection.x;
+			light.target.position.y += this.lightDirection.y;
+			light.target.position.z += this.lightDirection.z;
+		}
+	}
+	injectInclude() {
+		ShaderChunk.lights_fragment_begin = CSMShader.lights_fragment_begin;
+		ShaderChunk.lights_pars_begin = CSMShader.lights_pars_begin;
+	}
+	setupMaterial( material ) {
+		material.defines = material.defines || {};
+		material.defines.USE_CSM = 1;
+		material.defines.CSM_CASCADES = this.cascades;
+		if ( this.fade ) {
+			material.defines.CSM_FADE = '';
+		}
+		const breaksVec2 = [];
+		const scope = this;
+		const shaders = this.shaders;
+		material.onBeforeCompile = function ( shader ) {
+			const far = Math.min( scope.camera.far, scope.maxFar );
+			scope.getExtendedBreaks( breaksVec2 );
+			shader.uniforms.CSM_cascades = { value: breaksVec2 };
+			shader.uniforms.cameraNear = { value: scope.camera.near };
+			shader.uniforms.shadowFar = { value: far };
+			shaders.set( material, shader );
+		};
+		shaders.set( material, null );
+	}
+	updateUniforms() {
+		const far = Math.min( this.camera.far, this.maxFar );
+		const shaders = this.shaders;
+		shaders.forEach( function ( shader, material ) {
+			if ( shader !== null ) {
+				const uniforms = shader.uniforms;
+				this.getExtendedBreaks( uniforms.CSM_cascades.value );
+				uniforms.cameraNear.value = this.camera.near;
+				uniforms.shadowFar.value = far;
+			}
+			if ( ! this.fade && 'CSM_FADE' in material.defines ) {
+				delete material.defines.CSM_FADE;
+				material.needsUpdate = true;
+			} else if ( this.fade && ! ( 'CSM_FADE' in material.defines ) ) {
+				material.defines.CSM_FADE = '';
+				material.needsUpdate = true;
+			}
+		}, this );
+	}
+	getExtendedBreaks( target ) {
+		while ( target.length < this.breaks.length ) {
+			target.push( new Vector2() );
+		}
+		target.length = this.breaks.length;
+		for ( let i = 0; i < this.cascades; i ++ ) {
+			const amount = this.breaks[ i ];
+			const prev = this.breaks[ i - 1 ] || 0;
+			target[ i ].x = prev;
+			target[ i ].y = amount;
+		}
+	}
+	updateFrustums() {
+		this.getBreaks();
+		this.initCascades();
+		this.updateShadowBounds();
+		this.updateUniforms();
+	}
+	remove() {
+		for ( let i = 0; i < this.lights.length; i ++ ) {
+			this.parent.remove( this.lights[ i ].target );
+			this.parent.remove( this.lights[ i ] );
+		}
+	}
+	dispose() {
+		const shaders = this.shaders;
+		shaders.forEach( function ( shader, material ) {
+			delete material.onBeforeCompile;
+			delete material.defines.USE_CSM;
+			delete material.defines.CSM_CASCADES;
+			delete material.defines.CSM_FADE;
+			if ( shader !== null ) {
+				delete shader.uniforms.CSM_cascades;
+				delete shader.uniforms.cameraNear;
+				delete shader.uniforms.shadowFar;
+			}
+			material.needsUpdate = true;
+		} );
+		shaders.clear();
+	}
+}

libs/three.js/0.172.0/jsm/csm/CSMFrustum.js ADDED Viewed

	@@ -0,0 +1,155 @@

+import { Vector3, Matrix4 } from 'three';
+const inverseProjectionMatrix = new Matrix4();
+class CSMFrustum {
+	constructor( data ) {
+		data = data || {};
+		this.zNear = data.webGL === true ? - 1 : 0;
+		this.vertices = {
+			near: [
+				new Vector3(),
+				new Vector3(),
+				new Vector3(),
+				new Vector3()
+			],
+			far: [
+				new Vector3(),
+				new Vector3(),
+				new Vector3(),
+				new Vector3()
+			]
+		};
+		if ( data.projectionMatrix !== undefined ) {
+			this.setFromProjectionMatrix( data.projectionMatrix, data.maxFar || 10000 );
+		}
+	}
+	setFromProjectionMatrix( projectionMatrix, maxFar ) {
+		const zNear = this.zNear;
+		const isOrthographic = projectionMatrix.elements[ 2 * 4 + 3 ] === 0;
+		inverseProjectionMatrix.copy( projectionMatrix ).invert();
+		// 3 --- 0  vertices.near/far order
+		// |     |
+		// 2 --- 1
+		// clip space spans from [-1, 1]
+		this.vertices.near[ 0 ].set( 1, 1, zNear );
+		this.vertices.near[ 1 ].set( 1, - 1, zNear );
+		this.vertices.near[ 2 ].set( - 1, - 1, zNear );
+		this.vertices.near[ 3 ].set( - 1, 1, zNear );
+		this.vertices.near.forEach( function ( v ) {
+			v.applyMatrix4( inverseProjectionMatrix );
+		} );
+		this.vertices.far[ 0 ].set( 1, 1, 1 );
+		this.vertices.far[ 1 ].set( 1, - 1, 1 );
+		this.vertices.far[ 2 ].set( - 1, - 1, 1 );
+		this.vertices.far[ 3 ].set( - 1, 1, 1 );
+		this.vertices.far.forEach( function ( v ) {
+			v.applyMatrix4( inverseProjectionMatrix );
+			const absZ = Math.abs( v.z );
+			if ( isOrthographic ) {
+				v.z *= Math.min( maxFar / absZ, 1.0 );
+			} else {
+				v.multiplyScalar( Math.min( maxFar / absZ, 1.0 ) );
+			}
+		} );
+		return this.vertices;
+	}
+	split( breaks, target ) {
+		while ( breaks.length > target.length ) {
+			target.push( new CSMFrustum() );
+		}
+		target.length = breaks.length;
+		for ( let i = 0; i < breaks.length; i ++ ) {
+			const cascade = target[ i ];
+			if ( i === 0 ) {
+				for ( let j = 0; j < 4; j ++ ) {
+					cascade.vertices.near[ j ].copy( this.vertices.near[ j ] );
+				}
+			} else {
+				for ( let j = 0; j < 4; j ++ ) {
+					cascade.vertices.near[ j ].lerpVectors( this.vertices.near[ j ], this.vertices.far[ j ], breaks[ i - 1 ] );
+				}
+			}
+			if ( i === breaks.length - 1 ) {
+				for ( let j = 0; j < 4; j ++ ) {
+					cascade.vertices.far[ j ].copy( this.vertices.far[ j ] );
+				}
+			} else {
+				for ( let j = 0; j < 4; j ++ ) {
+					cascade.vertices.far[ j ].lerpVectors( this.vertices.near[ j ], this.vertices.far[ j ], breaks[ i ] );
+				}
+			}
+		}
+	}
+	toSpace( cameraMatrix, target ) {
+		for ( let i = 0; i < 4; i ++ ) {
+			target.vertices.near[ i ]
+				.copy( this.vertices.near[ i ] )
+				.applyMatrix4( cameraMatrix );
+			target.vertices.far[ i ]
+				.copy( this.vertices.far[ i ] )
+				.applyMatrix4( cameraMatrix );
+		}
+	}
+}
+export { CSMFrustum };

libs/three.js/0.172.0/jsm/csm/CSMHelper.js ADDED Viewed

	@@ -0,0 +1,195 @@

+import {
+	Group,
+	Mesh,
+	LineSegments,
+	BufferGeometry,
+	LineBasicMaterial,
+	Box3Helper,
+	Box3,
+	PlaneGeometry,
+	MeshBasicMaterial,
+	BufferAttribute,
+	DoubleSide
+} from 'three';
+class CSMHelper extends Group {
+	constructor( csm ) {
+		super();
+		this.csm = csm;
+		this.displayFrustum = true;
+		this.displayPlanes = true;
+		this.displayShadowBounds = true;
+		const indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );
+		const positions = new Float32Array( 24 );
+		const frustumGeometry = new BufferGeometry();
+		frustumGeometry.setIndex( new BufferAttribute( indices, 1 ) );
+		frustumGeometry.setAttribute( 'position', new BufferAttribute( positions, 3, false ) );
+		const frustumLines = new LineSegments( frustumGeometry, new LineBasicMaterial() );
+		this.add( frustumLines );
+		this.frustumLines = frustumLines;
+		this.cascadeLines = [];
+		this.cascadePlanes = [];
+		this.shadowLines = [];
+	}
+	updateVisibility() {
+		const displayFrustum = this.displayFrustum;
+		const displayPlanes = this.displayPlanes;
+		const displayShadowBounds = this.displayShadowBounds;
+		const frustumLines = this.frustumLines;
+		const cascadeLines = this.cascadeLines;
+		const cascadePlanes = this.cascadePlanes;
+		const shadowLines = this.shadowLines;
+		for ( let i = 0, l = cascadeLines.length; i < l; i ++ ) {
+			const cascadeLine = cascadeLines[ i ];
+			const cascadePlane = cascadePlanes[ i ];
+			const shadowLineGroup = shadowLines[ i ];
+			cascadeLine.visible = displayFrustum;
+			cascadePlane.visible = displayFrustum && displayPlanes;
+			shadowLineGroup.visible = displayShadowBounds;
+		}
+		frustumLines.visible = displayFrustum;
+	}
+	update() {
+		const csm = this.csm;
+		const camera = csm.camera;
+		const cascades = csm.cascades;
+		const mainFrustum = csm.mainFrustum;
+		const frustums = csm.frustums;
+		const lights = csm.lights;
+		const frustumLines = this.frustumLines;
+		const frustumLinePositions = frustumLines.geometry.getAttribute( 'position' );
+		const cascadeLines = this.cascadeLines;
+		const cascadePlanes = this.cascadePlanes;
+		const shadowLines = this.shadowLines;
+		if ( camera === null ) return;
+		this.position.copy( camera.position );
+		this.quaternion.copy( camera.quaternion );
+		this.scale.copy( camera.scale );
+		this.updateMatrixWorld( true );
+		while ( cascadeLines.length > cascades ) {
+			this.remove( cascadeLines.pop() );
+			this.remove( cascadePlanes.pop() );
+			this.remove( shadowLines.pop() );
+		}
+		while ( cascadeLines.length < cascades ) {
+			const cascadeLine = new Box3Helper( new Box3(), 0xffffff );
+			const planeMat = new MeshBasicMaterial( { transparent: true, opacity: 0.1, depthWrite: false, side: DoubleSide } );
+			const cascadePlane = new Mesh( new PlaneGeometry(), planeMat );
+			const shadowLineGroup = new Group();
+			const shadowLine = new Box3Helper( new Box3(), 0xffff00 );
+			shadowLineGroup.add( shadowLine );
+			this.add( cascadeLine );
+			this.add( cascadePlane );
+			this.add( shadowLineGroup );
+			cascadeLines.push( cascadeLine );
+			cascadePlanes.push( cascadePlane );
+			shadowLines.push( shadowLineGroup );
+		}
+		for ( let i = 0; i < cascades; i ++ ) {
+			const frustum = frustums[ i ];
+			const light = lights[ i ];
+			const shadowCam = light.shadow.camera;
+			const farVerts = frustum.vertices.far;
+			const cascadeLine = cascadeLines[ i ];
+			const cascadePlane = cascadePlanes[ i ];
+			const shadowLineGroup = shadowLines[ i ];
+			const shadowLine = shadowLineGroup.children[ 0 ];
+			cascadeLine.box.min.copy( farVerts[ 2 ] );
+			cascadeLine.box.max.copy( farVerts[ 0 ] );
+			cascadeLine.box.max.z += 1e-4;
+			cascadePlane.position.addVectors( farVerts[ 0 ], farVerts[ 2 ] );
+			cascadePlane.position.multiplyScalar( 0.5 );
+			cascadePlane.scale.subVectors( farVerts[ 0 ], farVerts[ 2 ] );
+			cascadePlane.scale.z = 1e-4;
+			this.remove( shadowLineGroup );
+			shadowLineGroup.position.copy( shadowCam.position );
+			shadowLineGroup.quaternion.copy( shadowCam.quaternion );
+			shadowLineGroup.scale.copy( shadowCam.scale );
+			shadowLineGroup.updateMatrixWorld( true );
+			this.attach( shadowLineGroup );
+			shadowLine.box.min.set( shadowCam.bottom, shadowCam.left, - shadowCam.far );
+			shadowLine.box.max.set( shadowCam.top, shadowCam.right, - shadowCam.near );
+		}
+		const nearVerts = mainFrustum.vertices.near;
+		const farVerts = mainFrustum.vertices.far;
+		frustumLinePositions.setXYZ( 0, farVerts[ 0 ].x, farVerts[ 0 ].y, farVerts[ 0 ].z );
+		frustumLinePositions.setXYZ( 1, farVerts[ 3 ].x, farVerts[ 3 ].y, farVerts[ 3 ].z );
+		frustumLinePositions.setXYZ( 2, farVerts[ 2 ].x, farVerts[ 2 ].y, farVerts[ 2 ].z );
+		frustumLinePositions.setXYZ( 3, farVerts[ 1 ].x, farVerts[ 1 ].y, farVerts[ 1 ].z );
+		frustumLinePositions.setXYZ( 4, nearVerts[ 0 ].x, nearVerts[ 0 ].y, nearVerts[ 0 ].z );
+		frustumLinePositions.setXYZ( 5, nearVerts[ 3 ].x, nearVerts[ 3 ].y, nearVerts[ 3 ].z );
+		frustumLinePositions.setXYZ( 6, nearVerts[ 2 ].x, nearVerts[ 2 ].y, nearVerts[ 2 ].z );
+		frustumLinePositions.setXYZ( 7, nearVerts[ 1 ].x, nearVerts[ 1 ].y, nearVerts[ 1 ].z );
+		frustumLinePositions.needsUpdate = true;
+	}
+	dispose() {
+		const frustumLines = this.frustumLines;
+		const cascadeLines = this.cascadeLines;
+		const cascadePlanes = this.cascadePlanes;
+		const shadowLines = this.shadowLines;
+		frustumLines.geometry.dispose();
+		frustumLines.material.dispose();
+		const cascades = this.csm.cascades;
+		for ( let i = 0; i < cascades; i ++ ) {
+			const cascadeLine = cascadeLines[ i ];
+			const cascadePlane = cascadePlanes[ i ];
+			const shadowLineGroup = shadowLines[ i ];
+			const shadowLine = shadowLineGroup.children[ 0 ];
+			cascadeLine.dispose(); // Box3Helper
+			cascadePlane.geometry.dispose();
+			cascadePlane.material.dispose();
+			shadowLine.dispose(); // Box3Helper
+		}
+	}
+}
+export { CSMHelper };

libs/three.js/0.172.0/jsm/csm/CSMShader.js ADDED Viewed

	@@ -0,0 +1,295 @@

+import { ShaderChunk } from 'three';
+const CSMShader = {
+	lights_fragment_begin: /* glsl */`
+vec3 geometryPosition = - vViewPosition;
+vec3 geometryNormal = normal;
+vec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );
+vec3 geometryClearcoatNormal = vec3( 0.0 );
+#ifdef USE_CLEARCOAT
+	geometryClearcoatNormal = clearcoatNormal;
+#endif
+#ifdef USE_IRIDESCENCE
+	float dotNVi = saturate( dot( normal, geometryViewDir ) );
+	if ( material.iridescenceThickness == 0.0 ) {
+		material.iridescence = 0.0;
+	} else {
+		material.iridescence = saturate( material.iridescence );
+	}
+	if ( material.iridescence > 0.0 ) {
+		material.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );
+		// Iridescence F0 approximation
+		material.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );
+	}
+#endif
+IncidentLight directLight;
+#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
+	PointLight pointLight;
+	#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0
+	PointLightShadow pointLightShadow;
+	#endif
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
+		pointLight = pointLights[ i ];
+		getPointLightInfo( pointLight, geometryPosition, directLight );
+		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )
+		pointLightShadow = pointLightShadows[ i ];
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;
+		#endif
+		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+	}
+	#pragma unroll_loop_end
+#endif
+#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )
+	SpotLight spotLight;
+ 	vec4 spotColor;
+	vec3 spotLightCoord;
+	bool inSpotLightMap;
+	#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0
+	SpotLightShadow spotLightShadow;
+	#endif
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
+		spotLight = spotLights[ i ];
+		getSpotLightInfo( spotLight, geometryPosition, directLight );
+  		// spot lights are ordered [shadows with maps, shadows without maps, maps without shadows, none]
+		#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )
+		#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX
+		#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
+		#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS
+		#else
+		#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )
+		#endif
+		#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )
+			spotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;
+			inSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );
+			spotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );
+			directLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;
+		#endif
+		#undef SPOT_LIGHT_MAP_INDEX
+		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )
+		spotLightShadow = spotLightShadows[ i ];
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;
+		#endif
+		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+	}
+	#pragma unroll_loop_end
+#endif
+#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct ) && defined( USE_CSM ) && defined( CSM_CASCADES )
+	DirectionalLight directionalLight;
+	float linearDepth = (vViewPosition.z) / (shadowFar - cameraNear);
+	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
+	DirectionalLightShadow directionalLightShadow;
+	#endif
+	#if defined( USE_SHADOWMAP ) && defined( CSM_FADE )
+		vec2 cascade;
+		float cascadeCenter;
+		float closestEdge;
+		float margin;
+		float csmx;
+		float csmy;
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
+			directionalLight = directionalLights[ i ];
+			getDirectionalLightInfo( directionalLight, directLight );
+			#if ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
+				// NOTE: Depth gets larger away from the camera.
+				// cascade.x is closer, cascade.y is further
+				cascade = CSM_cascades[ i ];
+				cascadeCenter = ( cascade.x + cascade.y ) / 2.0;
+				closestEdge = linearDepth < cascadeCenter ? cascade.x : cascade.y;
+				margin = 0.25 * pow( closestEdge, 2.0 );
+				csmx = cascade.x - margin / 2.0;
+				csmy = cascade.y + margin / 2.0;
+				if( linearDepth >= csmx && ( linearDepth < csmy || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 ) ) {
+					float dist = min( linearDepth - csmx, csmy - linearDepth );
+					float ratio = clamp( dist / margin, 0.0, 1.0 );
+					vec3 prevColor = directLight.color;
+					directionalLightShadow = directionalLightShadows[ i ];
+					directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+					bool shouldFadeLastCascade = UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth > cascadeCenter;
+					directLight.color = mix( prevColor, directLight.color, shouldFadeLastCascade ? ratio : 1.0 );
+					ReflectedLight prevLight = reflectedLight;
+					RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+					bool shouldBlend = UNROLLED_LOOP_INDEX != CSM_CASCADES - 1 || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth < cascadeCenter;
+					float blendRatio = shouldBlend ? ratio : 1.0;
+					reflectedLight.directDiffuse = mix( prevLight.directDiffuse, reflectedLight.directDiffuse, blendRatio );
+					reflectedLight.directSpecular = mix( prevLight.directSpecular, reflectedLight.directSpecular, blendRatio );
+					reflectedLight.indirectDiffuse = mix( prevLight.indirectDiffuse, reflectedLight.indirectDiffuse, blendRatio );
+					reflectedLight.indirectSpecular = mix( prevLight.indirectSpecular, reflectedLight.indirectSpecular, blendRatio );
+				}
+			#endif
+		}
+		#pragma unroll_loop_end
+	#elif defined (USE_SHADOWMAP)
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
+			directionalLight = directionalLights[ i ];
+			getDirectionalLightInfo( directionalLight, directLight );
+			#if ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
+				directionalLightShadow = directionalLightShadows[ i ];
+				if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y) directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+				if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && (linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1)) RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+			#endif
+		}
+		#pragma unroll_loop_end
+	#elif ( NUM_DIR_LIGHT_SHADOWS > 0 )
+		// note: no loop here - all CSM lights are in fact one light only
+		getDirectionalLightInfo( directionalLights[0], directLight );
+		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+	#endif
+	#if ( NUM_DIR_LIGHTS > NUM_DIR_LIGHT_SHADOWS)
+		// compute the lights not casting shadows (if any)
+		#pragma unroll_loop_start
+		for ( int i = NUM_DIR_LIGHT_SHADOWS; i < NUM_DIR_LIGHTS; i ++ ) {
+			directionalLight = directionalLights[ i ];
+			getDirectionalLightInfo( directionalLight, directLight );
+			RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+		}
+		#pragma unroll_loop_end
+	#endif
+#endif
+#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct ) && !defined( USE_CSM ) && !defined( CSM_CASCADES )
+	DirectionalLight directionalLight;
+	#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0
+	DirectionalLightShadow directionalLightShadow;
+	#endif
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
+		directionalLight = directionalLights[ i ];
+		getDirectionalLightInfo( directionalLight, directLight );
+		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )
+		directionalLightShadow = directionalLightShadows[ i ];
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;
+		#endif
+		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+	}
+	#pragma unroll_loop_end
+#endif
+#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )
+	RectAreaLight rectAreaLight;
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {
+		rectAreaLight = rectAreaLights[ i ];
+		RE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+	}
+	#pragma unroll_loop_end
+#endif
+#if defined( RE_IndirectDiffuse )
+	vec3 iblIrradiance = vec3( 0.0 );
+	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );
+	#if defined( USE_LIGHT_PROBES )
+		irradiance += getLightProbeIrradiance( lightProbe, geometryNormal );
+	#endif
+	#if ( NUM_HEMI_LIGHTS > 0 )
+		#pragma unroll_loop_start
+		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
+			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );
+		}
+		#pragma unroll_loop_end
+	#endif
+#endif
+#if defined( RE_IndirectSpecular )
+	vec3 radiance = vec3( 0.0 );
+	vec3 clearcoatRadiance = vec3( 0.0 );
+#endif
+`,
+	lights_pars_begin: /* glsl */`
+#if defined( USE_CSM ) && defined( CSM_CASCADES )
+uniform vec2 CSM_cascades[CSM_CASCADES];
+uniform float cameraNear;
+uniform float shadowFar;
+#endif
+	` + ShaderChunk.lights_pars_begin
+};
+export { CSMShader };

libs/three.js/0.172.0/jsm/csm/CSMShadowNode.js ADDED Viewed

	@@ -0,0 +1,442 @@

+import {
+	Vector2,
+	Vector3,
+	MathUtils,
+	Matrix4,
+	Box3,
+	Object3D,
+	WebGLCoordinateSystem,
+	ShadowBaseNode
+} from 'three/webgpu';
+import { CSMFrustum } from './CSMFrustum.js';
+import { viewZToOrthographicDepth, reference, uniform, float, vec4, vec2, If, Fn, min, renderGroup, positionView, shadow } from 'three/tsl';
+const _cameraToLightMatrix = new Matrix4();
+const _lightSpaceFrustum = new CSMFrustum();
+const _center = new Vector3();
+const _bbox = new Box3();
+const _uniformArray = [];
+const _logArray = [];
+const _lightDirection = new Vector3();
+const _lightOrientationMatrix = new Matrix4();
+const _lightOrientationMatrixInverse = new Matrix4();
+const _up = new Vector3( 0, 1, 0 );
+class LwLight extends Object3D {
+	constructor() {
+		super();
+		this.target = new Object3D();
+	}
+}
+class CSMShadowNode extends ShadowBaseNode {
+	constructor( light, data = {} ) {
+		super( light );
+		this.camera = null;
+		this.cascades = data.cascades || 3;
+		this.maxFar = data.maxFar || 100000;
+		this.mode = data.mode || 'practical';
+		this.lightMargin = data.lightMargin || 200;
+		this.customSplitsCallback = data.customSplitsCallback;
+		this.fade = false;
+		this.breaks = [];
+		this._cascades = [];
+		this.mainFrustum = null;
+		this.frustums = [];
+		this.lights = [];
+		this._shadowNodes = [];
+	}
+	init( { camera, renderer } ) {
+		this.camera = camera;
+		const data = { webGL: renderer.coordinateSystem === WebGLCoordinateSystem };
+		this.mainFrustum = new CSMFrustum( data );
+		const light = this.light;
+		const parent = light.parent;
+		for ( let i = 0; i < this.cascades; i ++ ) {
+			const lwLight = new LwLight();
+			lwLight.castShadow = true;
+			const lShadow = light.shadow.clone();
+			lShadow.bias = lShadow.bias * ( i + 1 );
+			this.lights.push( lwLight );
+			parent.add( lwLight );
+			parent.add( lwLight.target );
+			lwLight.shadow = lShadow;
+			this._shadowNodes.push( shadow( lwLight, lShadow ) );
+			this._cascades.push( new Vector2() );
+		}
+		this.updateFrustums();
+	}
+	initCascades() {
+		const camera = this.camera;
+		camera.updateProjectionMatrix();
+		this.mainFrustum.setFromProjectionMatrix( camera.projectionMatrix, this.maxFar );
+		this.mainFrustum.split( this.breaks, this.frustums );
+	}
+	getBreaks() {
+		const camera = this.camera;
+		const far = Math.min( camera.far, this.maxFar );
+		this.breaks.length = 0;
+		switch ( this.mode ) {
+			case 'uniform':
+				uniformSplit( this.cascades, camera.near, far, this.breaks );
+				break;
+			case 'logarithmic':
+				logarithmicSplit( this.cascades, camera.near, far, this.breaks );
+				break;
+			case 'practical':
+				practicalSplit( this.cascades, camera.near, far, 0.5, this.breaks );
+				break;
+			case 'custom':
+				if ( this.customSplitsCallback === undefined ) console.error( 'CSM: Custom split scheme callback not defined.' );
+				this.customSplitsCallback( this.cascades, camera.near, far, this.breaks );
+				break;
+		}
+		function uniformSplit( amount, near, far, target ) {
+			for ( let i = 1; i < amount; i ++ ) {
+				target.push( ( near + ( far - near ) * i / amount ) / far );
+			}
+			target.push( 1 );
+		}
+		function logarithmicSplit( amount, near, far, target ) {
+			for ( let i = 1; i < amount; i ++ ) {
+				target.push( ( near * ( far / near ) ** ( i / amount ) ) / far );
+			}
+			target.push( 1 );
+		}
+		function practicalSplit( amount, near, far, lambda, target ) {
+			_uniformArray.length = 0;
+			_logArray.length = 0;
+			logarithmicSplit( amount, near, far, _logArray );
+			uniformSplit( amount, near, far, _uniformArray );
+			for ( let i = 1; i < amount; i ++ ) {
+				target.push( MathUtils.lerp( _uniformArray[ i - 1 ], _logArray[ i - 1 ], lambda ) );
+			}
+			target.push( 1 );
+		}
+	}
+	setLightBreaks() {
+		for ( let i = 0, l = this.cascades; i < l; i ++ ) {
+			const amount = this.breaks[ i ];
+			const prev = this.breaks[ i - 1 ] || 0;
+			this._cascades[ i ].set( prev, amount );
+		}
+	}
+	updateShadowBounds() {
+		const frustums = this.frustums;
+		for ( let i = 0; i < frustums.length; i ++ ) {
+			const shadowCam = this.lights[ i ].shadow.camera;
+			const frustum = this.frustums[ i ];
+			// Get the two points that represent that furthest points on the frustum assuming
+			// that's either the diagonal across the far plane or the diagonal across the whole
+			// frustum itself.
+			const nearVerts = frustum.vertices.near;
+			const farVerts = frustum.vertices.far;
+			const point1 = farVerts[ 0 ];
+			let point2;
+			if ( point1.distanceTo( farVerts[ 2 ] ) > point1.distanceTo( nearVerts[ 2 ] ) ) {
+				point2 = farVerts[ 2 ];
+			} else {
+				point2 = nearVerts[ 2 ];
+			}
+			let squaredBBWidth = point1.distanceTo( point2 );
+			if ( this.fade ) {
+				// expand the shadow extents by the fade margin if fade is enabled.
+				const camera = this.camera;
+				const far = Math.max( camera.far, this.maxFar );
+				const linearDepth = frustum.vertices.far[ 0 ].z / ( far - camera.near );
+				const margin = 0.25 * Math.pow( linearDepth, 2.0 ) * ( far - camera.near );
+				squaredBBWidth += margin;
+			}
+			shadowCam.left = - squaredBBWidth / 2;
+			shadowCam.right = squaredBBWidth / 2;
+			shadowCam.top = squaredBBWidth / 2;
+			shadowCam.bottom = - squaredBBWidth / 2;
+			shadowCam.updateProjectionMatrix();
+		}
+	}
+	updateFrustums() {
+		this.getBreaks();
+		this.initCascades();
+		this.updateShadowBounds();
+		this.setLightBreaks();
+	}
+	setupFade() {
+		const cameraNear = reference( 'camera.near', 'float', this ).setGroup( renderGroup );
+		const cascades = reference( '_cascades', 'vec2', this ).setGroup( renderGroup ).label( 'cascades' );
+		const shadowFar = uniform( 'float' ).setGroup( renderGroup ).label( 'shadowFar' )
+			.onRenderUpdate( () => Math.min( this.maxFar, this.camera.far ) );
+		const linearDepth = viewZToOrthographicDepth( positionView.z, cameraNear, shadowFar ).toVar( 'linearDepth' );
+		const lastCascade = this.cascades - 1;
+		return Fn( ( builder ) => {
+			this.setupShadowPosition( builder );
+			const ret = vec4( 1, 1, 1, 1 ).toVar( 'shadowValue' );
+			const cascade = vec2().toVar( 'cascade' );
+			const cascadeCenter = float().toVar( 'cascadeCenter' );
+			const margin = float().toVar( 'margin' );
+			const csmX = float().toVar( 'csmX' );
+			const csmY = float().toVar( 'csmY' );
+			for ( let i = 0; i < this.cascades; i ++ ) {
+				const isLastCascade = i === lastCascade;
+				cascade.assign( cascades.element( i ) );
+				cascadeCenter.assign( cascade.x.add( cascade.y ).div( 2.0 ) );
+				const closestEdge = linearDepth.lessThan( cascadeCenter ).select( cascade.x, cascade.y );
+				margin.assign( float( 0.25 ).mul( closestEdge.pow( 2.0 ) ) );
+				csmX.assign( cascade.x.sub( margin.div( 2.0 ) ) );
+				if ( isLastCascade ) {
+					csmY.assign( cascade.y );
+				} else {
+					csmY.assign( cascade.y.add( margin.div( 2.0 ) ) );
+				}
+				const inRange = linearDepth.greaterThanEqual( csmX ).and( linearDepth.lessThanEqual( csmY ) );
+				If( inRange, () => {
+					const dist = min( linearDepth.sub( csmX ), csmY.sub( linearDepth ) ).toVar();
+					let ratio = dist.div( margin ).clamp( 0.0, 1.0 );
+					if ( i === 0 ) {
+						// don't fade at nearest edge
+						ratio = linearDepth.greaterThan( cascadeCenter ).select( ratio, 1 );
+					}
+					ret.subAssign( this._shadowNodes[ i ].oneMinus().mul( ratio ) );
+				} );
+			}
+			return ret;
+		} )();
+	}
+	setupStandard() {
+		const cameraNear = reference( 'camera.near', 'float', this ).setGroup( renderGroup );
+		const cascades = reference( '_cascades', 'vec2', this ).setGroup( renderGroup ).label( 'cascades' );
+		const shadowFar = uniform( 'float' ).setGroup( renderGroup ).label( 'shadowFar' )
+			.onRenderUpdate( () => Math.min( this.maxFar, this.camera.far ) );
+		const linearDepth = viewZToOrthographicDepth( positionView.z, cameraNear, shadowFar ).toVar( 'linearDepth' );
+		return Fn( ( builder ) => {
+			this.setupShadowPosition( builder );
+			const ret = vec4( 1, 1, 1, 1 ).toVar( 'shadowValue' );
+			const cascade = vec2().toVar( 'cascade' );
+			for ( let i = 0; i < this.cascades; i ++ ) {
+				cascade.assign( cascades.element( i ) );
+				If( linearDepth.greaterThanEqual( cascade.x ).and( linearDepth.lessThanEqual( cascade.y ) ), () => {
+					ret.assign( this._shadowNodes[ i ] );
+				} );
+			}
+			return ret;
+		} )();
+	}
+	setup( builder ) {
+		if ( this.camera === null ) this.init( builder );
+		return this.fade === true ? this.setupFade() : this.setupStandard();
+	}
+	updateBefore( /*builder*/ ) {
+		const light = this.light;
+		const camera = this.camera;
+		const frustums = this.frustums;
+		_lightDirection.subVectors( light.target.position, light.position ).normalize();
+		// for each frustum we need to find its min-max box aligned with the light orientation
+		// the position in _lightOrientationMatrix does not matter, as we transform there and back
+		_lightOrientationMatrix.lookAt( light.position, light.target.position, _up );
+		_lightOrientationMatrixInverse.copy( _lightOrientationMatrix ).invert();
+		for ( let i = 0; i < frustums.length; i ++ ) {
+			const lwLight = this.lights[ i ];
+			const shadow = lwLight.shadow;
+			const shadowCam = shadow.camera;
+			const texelWidth = ( shadowCam.right - shadowCam.left ) / shadow.mapSize.width;
+			const texelHeight = ( shadowCam.top - shadowCam.bottom ) / shadow.mapSize.height;
+			_cameraToLightMatrix.multiplyMatrices( _lightOrientationMatrixInverse, camera.matrixWorld );
+			frustums[ i ].toSpace( _cameraToLightMatrix, _lightSpaceFrustum );
+			const nearVerts = _lightSpaceFrustum.vertices.near;
+			const farVerts = _lightSpaceFrustum.vertices.far;
+			_bbox.makeEmpty();
+			for ( let j = 0; j < 4; j ++ ) {
+				_bbox.expandByPoint( nearVerts[ j ] );
+				_bbox.expandByPoint( farVerts[ j ] );
+			}
+			_bbox.getCenter( _center );
+			_center.z = _bbox.max.z + this.lightMargin;
+			_center.x = Math.floor( _center.x / texelWidth ) * texelWidth;
+			_center.y = Math.floor( _center.y / texelHeight ) * texelHeight;
+			_center.applyMatrix4( _lightOrientationMatrix );
+			lwLight.position.copy( _center );
+			lwLight.target.position.copy( _center );
+			lwLight.target.position.add( _lightDirection );
+		}
+	}
+	dispose() {
+		for ( let i = 0; i < this.lights.length; i ++ ) {
+			const light = this.lights[ i ];
+			const parent = light.parent;
+			parent.remove( light.target );
+			parent.remove( light );
+		}
+		super.dispose();
+	}
+}
+export { CSMShadowNode };

libs/three.js/0.172.0/jsm/curves/CurveExtras.js ADDED Viewed

	@@ -0,0 +1,422 @@

+import {
+	Curve,
+	Vector3
+} from 'three';
+/**
+ * A bunch of parametric curves
+ *
+ * Formulas collected from various sources
+ * http://mathworld.wolfram.com/HeartCurve.html
+ * http://en.wikipedia.org/wiki/Viviani%27s_curve
+ * http://www.mi.sanu.ac.rs/vismath/taylorapril2011/Taylor.pdf
+ * https://prideout.net/blog/old/blog/index.html@p=44.html
+ */
+// GrannyKnot
+class GrannyKnot extends Curve {
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t = 2 * Math.PI * t;
+		const x = - 0.22 * Math.cos( t ) - 1.28 * Math.sin( t ) - 0.44 * Math.cos( 3 * t ) - 0.78 * Math.sin( 3 * t );
+		const y = - 0.1 * Math.cos( 2 * t ) - 0.27 * Math.sin( 2 * t ) + 0.38 * Math.cos( 4 * t ) + 0.46 * Math.sin( 4 * t );
+		const z = 0.7 * Math.cos( 3 * t ) - 0.4 * Math.sin( 3 * t );
+		return point.set( x, y, z ).multiplyScalar( 20 );
+	}
+}
+// HeartCurve
+class HeartCurve extends Curve {
+	constructor( scale = 5 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t *= 2 * Math.PI;
+		const x = 16 * Math.pow( Math.sin( t ), 3 );
+		const y = 13 * Math.cos( t ) - 5 * Math.cos( 2 * t ) - 2 * Math.cos( 3 * t ) - Math.cos( 4 * t );
+		const z = 0;
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// Viviani's Curve
+class VivianiCurve extends Curve {
+	constructor( scale = 70 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t = t * 4 * Math.PI; // normalized to 0..1
+		const a = this.scale / 2;
+		const x = a * ( 1 + Math.cos( t ) );
+		const y = a * Math.sin( t );
+		const z = 2 * a * Math.sin( t / 2 );
+		return point.set( x, y, z );
+	}
+}
+// KnotCurve
+class KnotCurve extends Curve {
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t *= 2 * Math.PI;
+		const R = 10;
+		const s = 50;
+		const x = s * Math.sin( t );
+		const y = Math.cos( t ) * ( R + s * Math.cos( t ) );
+		const z = Math.sin( t ) * ( R + s * Math.cos( t ) );
+		return point.set( x, y, z );
+	}
+}
+// HelixCurve
+class HelixCurve extends Curve {
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const a = 30; // radius
+		const b = 150; // height
+		const t2 = 2 * Math.PI * t * b / 30;
+		const x = Math.cos( t2 ) * a;
+		const y = Math.sin( t2 ) * a;
+		const z = b * t;
+		return point.set( x, y, z );
+	}
+}
+// TrefoilKnot
+class TrefoilKnot extends Curve {
+	constructor( scale = 10 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t *= Math.PI * 2;
+		const x = ( 2 + Math.cos( 3 * t ) ) * Math.cos( 2 * t );
+		const y = ( 2 + Math.cos( 3 * t ) ) * Math.sin( 2 * t );
+		const z = Math.sin( 3 * t );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// TorusKnot
+class TorusKnot extends Curve {
+	constructor( scale = 10 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const p = 3;
+		const q = 4;
+		t *= Math.PI * 2;
+		const x = ( 2 + Math.cos( q * t ) ) * Math.cos( p * t );
+		const y = ( 2 + Math.cos( q * t ) ) * Math.sin( p * t );
+		const z = Math.sin( q * t );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// CinquefoilKnot
+class CinquefoilKnot extends Curve {
+	constructor( scale = 10 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const p = 2;
+		const q = 5;
+		t *= Math.PI * 2;
+		const x = ( 2 + Math.cos( q * t ) ) * Math.cos( p * t );
+		const y = ( 2 + Math.cos( q * t ) ) * Math.sin( p * t );
+		const z = Math.sin( q * t );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// TrefoilPolynomialKnot
+class TrefoilPolynomialKnot extends Curve {
+	constructor( scale = 10 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t = t * 4 - 2;
+		const x = Math.pow( t, 3 ) - 3 * t;
+		const y = Math.pow( t, 4 ) - 4 * t * t;
+		const z = 1 / 5 * Math.pow( t, 5 ) - 2 * t;
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+function scaleTo( x, y, t ) {
+	const r = y - x;
+	return t * r + x;
+}
+// FigureEightPolynomialKnot
+class FigureEightPolynomialKnot extends Curve {
+	constructor( scale = 1 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t = scaleTo( - 4, 4, t );
+		const x = 2 / 5 * t * ( t * t - 7 ) * ( t * t - 10 );
+		const y = Math.pow( t, 4 ) - 13 * t * t;
+		const z = 1 / 10 * t * ( t * t - 4 ) * ( t * t - 9 ) * ( t * t - 12 );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// DecoratedTorusKnot4a
+class DecoratedTorusKnot4a extends Curve {
+	constructor( scale = 40 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		t *= Math.PI * 2;
+		const x = Math.cos( 2 * t ) * ( 1 + 0.6 * ( Math.cos( 5 * t ) + 0.75 * Math.cos( 10 * t ) ) );
+		const y = Math.sin( 2 * t ) * ( 1 + 0.6 * ( Math.cos( 5 * t ) + 0.75 * Math.cos( 10 * t ) ) );
+		const z = 0.35 * Math.sin( 5 * t );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// DecoratedTorusKnot4b
+class DecoratedTorusKnot4b extends Curve {
+	constructor( scale = 40 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const fi = t * Math.PI * 2;
+		const x = Math.cos( 2 * fi ) * ( 1 + 0.45 * Math.cos( 3 * fi ) + 0.4 * Math.cos( 9 * fi ) );
+		const y = Math.sin( 2 * fi ) * ( 1 + 0.45 * Math.cos( 3 * fi ) + 0.4 * Math.cos( 9 * fi ) );
+		const z = 0.2 * Math.sin( 9 * fi );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// DecoratedTorusKnot5a
+class DecoratedTorusKnot5a extends Curve {
+	constructor( scale = 40 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const fi = t * Math.PI * 2;
+		const x = Math.cos( 3 * fi ) * ( 1 + 0.3 * Math.cos( 5 * fi ) + 0.5 * Math.cos( 10 * fi ) );
+		const y = Math.sin( 3 * fi ) * ( 1 + 0.3 * Math.cos( 5 * fi ) + 0.5 * Math.cos( 10 * fi ) );
+		const z = 0.2 * Math.sin( 20 * fi );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+// DecoratedTorusKnot5c
+class DecoratedTorusKnot5c extends Curve {
+	constructor( scale = 40 ) {
+		super();
+		this.scale = scale;
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const fi = t * Math.PI * 2;
+		const x = Math.cos( 4 * fi ) * ( 1 + 0.5 * ( Math.cos( 5 * fi ) + 0.4 * Math.cos( 20 * fi ) ) );
+		const y = Math.sin( 4 * fi ) * ( 1 + 0.5 * ( Math.cos( 5 * fi ) + 0.4 * Math.cos( 20 * fi ) ) );
+		const z = 0.35 * Math.sin( 15 * fi );
+		return point.set( x, y, z ).multiplyScalar( this.scale );
+	}
+}
+export {
+	GrannyKnot,
+	HeartCurve,
+	VivianiCurve,
+	KnotCurve,
+	HelixCurve,
+	TrefoilKnot,
+	TorusKnot,
+	CinquefoilKnot,
+	TrefoilPolynomialKnot,
+	FigureEightPolynomialKnot,
+	DecoratedTorusKnot4a,
+	DecoratedTorusKnot4b,
+	DecoratedTorusKnot5a,
+	DecoratedTorusKnot5c
+};

libs/three.js/0.172.0/jsm/curves/NURBSCurve.js ADDED Viewed

	@@ -0,0 +1,111 @@

+import {
+	Curve,
+	Vector3,
+	Vector4
+} from 'three';
+import * as NURBSUtils from '../curves/NURBSUtils.js';
+/**
+ * NURBS curve object
+ *
+ * Derives from Curve, overriding getPoint and getTangent.
+ *
+ * Implementation is based on (x, y [, z=0 [, w=1]]) control points with w=weight.
+ *
+ **/
+class NURBSCurve extends Curve {
+	constructor(
+		degree,
+		knots /* array of reals */,
+		controlPoints /* array of Vector(2|3|4) */,
+		startKnot /* index in knots */,
+		endKnot /* index in knots */
+	) {
+		super();
+		const knotsLength = knots ? knots.length - 1 : 0;
+		const pointsLength = controlPoints ? controlPoints.length : 0;
+		this.degree = degree;
+		this.knots = knots;
+		this.controlPoints = [];
+		// Used by periodic NURBS to remove hidden spans
+		this.startKnot = startKnot || 0;
+		this.endKnot = endKnot || knotsLength;
+		for ( let i = 0; i < pointsLength; ++ i ) {
+			// ensure Vector4 for control points
+			const point = controlPoints[ i ];
+			this.controlPoints[ i ] = new Vector4( point.x, point.y, point.z, point.w );
+		}
+	}
+	getPoint( t, optionalTarget = new Vector3() ) {
+		const point = optionalTarget;
+		const u = this.knots[ this.startKnot ] + t * ( this.knots[ this.endKnot ] - this.knots[ this.startKnot ] ); // linear mapping t->u
+		// following results in (wx, wy, wz, w) homogeneous point
+		const hpoint = NURBSUtils.calcBSplinePoint( this.degree, this.knots, this.controlPoints, u );
+		if ( hpoint.w !== 1.0 ) {
+			// project to 3D space: (wx, wy, wz, w) -> (x, y, z, 1)
+			hpoint.divideScalar( hpoint.w );
+		}
+		return point.set( hpoint.x, hpoint.y, hpoint.z );
+	}
+	getTangent( t, optionalTarget = new Vector3() ) {
+		const tangent = optionalTarget;
+		const u = this.knots[ 0 ] + t * ( this.knots[ this.knots.length - 1 ] - this.knots[ 0 ] );
+		const ders = NURBSUtils.calcNURBSDerivatives( this.degree, this.knots, this.controlPoints, u, 1 );
+		tangent.copy( ders[ 1 ] ).normalize();
+		return tangent;
+	}
+	toJSON() {
+		const data = super.toJSON();
+		data.degree = this.degree;
+		data.knots = [ ...this.knots ];
+		data.controlPoints = this.controlPoints.map( p => p.toArray() );
+		data.startKnot = this.startKnot;
+		data.endKnot = this.endKnot;
+		return data;
+	}
+	fromJSON( json ) {
+		super.fromJSON( json );
+		this.degree = json.degree;
+		this.knots = [ ...json.knots ];
+		this.controlPoints = json.controlPoints.map( p => new Vector4( p[ 0 ], p[ 1 ], p[ 2 ], p[ 3 ] ) );
+		this.startKnot = json.startKnot;
+		this.endKnot = json.endKnot;
+		return this;
+	}
+}
+export { NURBSCurve };

libs/three.js/0.172.0/jsm/curves/NURBSSurface.js ADDED Viewed

	@@ -0,0 +1,52 @@

+import {
+	Vector4
+} from 'three';
+import * as NURBSUtils from '../curves/NURBSUtils.js';
+/**
+ * NURBS surface object
+ *
+ * Implementation is based on (x, y [, z=0 [, w=1]]) control points with w=weight.
+ **/
+class NURBSSurface {
+	constructor( degree1, degree2, knots1, knots2 /* arrays of reals */, controlPoints /* array^2 of Vector(2|3|4) */ ) {
+		this.degree1 = degree1;
+		this.degree2 = degree2;
+		this.knots1 = knots1;
+		this.knots2 = knots2;
+		this.controlPoints = [];
+		const len1 = knots1.length - degree1 - 1;
+		const len2 = knots2.length - degree2 - 1;
+		// ensure Vector4 for control points
+		for ( let i = 0; i < len1; ++ i ) {
+			this.controlPoints[ i ] = [];
+			for ( let j = 0; j < len2; ++ j ) {
+				const point = controlPoints[ i ][ j ];
+				this.controlPoints[ i ][ j ] = new Vector4( point.x, point.y, point.z, point.w );
+			}
+		}
+	}
+	getPoint( t1, t2, target ) {
+		const u = this.knots1[ 0 ] + t1 * ( this.knots1[ this.knots1.length - 1 ] - this.knots1[ 0 ] ); // linear mapping t1->u
+		const v = this.knots2[ 0 ] + t2 * ( this.knots2[ this.knots2.length - 1 ] - this.knots2[ 0 ] ); // linear mapping t2->u
+		NURBSUtils.calcSurfacePoint( this.degree1, this.degree2, this.knots1, this.knots2, this.controlPoints, u, v, target );
+	}
+}
+export { NURBSSurface };

libs/three.js/0.172.0/jsm/curves/NURBSUtils.js ADDED Viewed

	@@ -0,0 +1,545 @@

+import {
+	Vector3,
+	Vector4
+} from 'three';
+/**
+ * NURBS utils
+ *
+ * See NURBSCurve and NURBSSurface.
+ **/
+/**************************************************************
+ *	NURBS Utils
+ **************************************************************/
+/*
+Finds knot vector span.
+p : degree
+u : parametric value
+U : knot vector
+returns the span
+*/
+function findSpan( p, u, U ) {
+	const n = U.length - p - 1;
+	if ( u >= U[ n ] ) {
+		return n - 1;
+	}
+	if ( u <= U[ p ] ) {
+		return p;
+	}
+	let low = p;
+	let high = n;
+	let mid = Math.floor( ( low + high ) / 2 );
+	while ( u < U[ mid ] || u >= U[ mid + 1 ] ) {
+		if ( u < U[ mid ] ) {
+			high = mid;
+		} else {
+			low = mid;
+		}
+		mid = Math.floor( ( low + high ) / 2 );
+	}
+	return mid;
+}
+/*
+Calculate basis functions. See The NURBS Book, page 70, algorithm A2.2
+span : span in which u lies
+u    : parametric point
+p    : degree
+U    : knot vector
+returns array[p+1] with basis functions values.
+*/
+function calcBasisFunctions( span, u, p, U ) {
+	const N = [];
+	const left = [];
+	const right = [];
+	N[ 0 ] = 1.0;
+	for ( let j = 1; j <= p; ++ j ) {
+		left[ j ] = u - U[ span + 1 - j ];
+		right[ j ] = U[ span + j ] - u;
+		let saved = 0.0;
+		for ( let r = 0; r < j; ++ r ) {
+			const rv = right[ r + 1 ];
+			const lv = left[ j - r ];
+			const temp = N[ r ] / ( rv + lv );
+			N[ r ] = saved + rv * temp;
+			saved = lv * temp;
+		}
+		N[ j ] = saved;
+	}
+	return N;
+}
+/*
+Calculate B-Spline curve points. See The NURBS Book, page 82, algorithm A3.1.
+p : degree of B-Spline
+U : knot vector
+P : control points (x, y, z, w)
+u : parametric point
+returns point for given u
+*/
+function calcBSplinePoint( p, U, P, u ) {
+	const span = findSpan( p, u, U );
+	const N = calcBasisFunctions( span, u, p, U );
+	const C = new Vector4( 0, 0, 0, 0 );
+	for ( let j = 0; j <= p; ++ j ) {
+		const point = P[ span - p + j ];
+		const Nj = N[ j ];
+		const wNj = point.w * Nj;
+		C.x += point.x * wNj;
+		C.y += point.y * wNj;
+		C.z += point.z * wNj;
+		C.w += point.w * Nj;
+	}
+	return C;
+}
+/*
+Calculate basis functions derivatives. See The NURBS Book, page 72, algorithm A2.3.
+span : span in which u lies
+u    : parametric point
+p    : degree
+n    : number of derivatives to calculate
+U    : knot vector
+returns array[n+1][p+1] with basis functions derivatives
+*/
+function calcBasisFunctionDerivatives( span, u, p, n, U ) {
+	const zeroArr = [];
+	for ( let i = 0; i <= p; ++ i )
+		zeroArr[ i ] = 0.0;
+	const ders = [];
+	for ( let i = 0; i <= n; ++ i )
+		ders[ i ] = zeroArr.slice( 0 );
+	const ndu = [];
+	for ( let i = 0; i <= p; ++ i )
+		ndu[ i ] = zeroArr.slice( 0 );
+	ndu[ 0 ][ 0 ] = 1.0;
+	const left = zeroArr.slice( 0 );
+	const right = zeroArr.slice( 0 );
+	for ( let j = 1; j <= p; ++ j ) {
+		left[ j ] = u - U[ span + 1 - j ];
+		right[ j ] = U[ span + j ] - u;
+		let saved = 0.0;
+		for ( let r = 0; r < j; ++ r ) {
+			const rv = right[ r + 1 ];
+			const lv = left[ j - r ];
+			ndu[ j ][ r ] = rv + lv;
+			const temp = ndu[ r ][ j - 1 ] / ndu[ j ][ r ];
+			ndu[ r ][ j ] = saved + rv * temp;
+			saved = lv * temp;
+		}
+		ndu[ j ][ j ] = saved;
+	}
+	for ( let j = 0; j <= p; ++ j ) {
+		ders[ 0 ][ j ] = ndu[ j ][ p ];
+	}
+	for ( let r = 0; r <= p; ++ r ) {
+		let s1 = 0;
+		let s2 = 1;
+		const a = [];
+		for ( let i = 0; i <= p; ++ i ) {
+			a[ i ] = zeroArr.slice( 0 );
+		}
+		a[ 0 ][ 0 ] = 1.0;
+		for ( let k = 1; k <= n; ++ k ) {
+			let d = 0.0;
+			const rk = r - k;
+			const pk = p - k;
+			if ( r >= k ) {
+				a[ s2 ][ 0 ] = a[ s1 ][ 0 ] / ndu[ pk + 1 ][ rk ];
+				d = a[ s2 ][ 0 ] * ndu[ rk ][ pk ];
+			}
+			const j1 = ( rk >= - 1 ) ? 1 : - rk;
+			const j2 = ( r - 1 <= pk ) ? k - 1 : p - r;
+			for ( let j = j1; j <= j2; ++ j ) {
+				a[ s2 ][ j ] = ( a[ s1 ][ j ] - a[ s1 ][ j - 1 ] ) / ndu[ pk + 1 ][ rk + j ];
+				d += a[ s2 ][ j ] * ndu[ rk + j ][ pk ];
+			}
+			if ( r <= pk ) {
+				a[ s2 ][ k ] = - a[ s1 ][ k - 1 ] / ndu[ pk + 1 ][ r ];
+				d += a[ s2 ][ k ] * ndu[ r ][ pk ];
+			}
+			ders[ k ][ r ] = d;
+			const j = s1;
+			s1 = s2;
+			s2 = j;
+		}
+	}
+	let r = p;
+	for ( let k = 1; k <= n; ++ k ) {
+		for ( let j = 0; j <= p; ++ j ) {
+			ders[ k ][ j ] *= r;
+		}
+		r *= p - k;
+	}
+	return ders;
+}
+/*
+	Calculate derivatives of a B-Spline. See The NURBS Book, page 93, algorithm A3.2.
+	p  : degree
+	U  : knot vector
+	P  : control points
+	u  : Parametric points
+	nd : number of derivatives
+	returns array[d+1] with derivatives
+	*/
+function calcBSplineDerivatives( p, U, P, u, nd ) {
+	const du = nd < p ? nd : p;
+	const CK = [];
+	const span = findSpan( p, u, U );
+	const nders = calcBasisFunctionDerivatives( span, u, p, du, U );
+	const Pw = [];
+	for ( let i = 0; i < P.length; ++ i ) {
+		const point = P[ i ].clone();
+		const w = point.w;
+		point.x *= w;
+		point.y *= w;
+		point.z *= w;
+		Pw[ i ] = point;
+	}
+	for ( let k = 0; k <= du; ++ k ) {
+		const point = Pw[ span - p ].clone().multiplyScalar( nders[ k ][ 0 ] );
+		for ( let j = 1; j <= p; ++ j ) {
+			point.add( Pw[ span - p + j ].clone().multiplyScalar( nders[ k ][ j ] ) );
+		}
+		CK[ k ] = point;
+	}
+	for ( let k = du + 1; k <= nd + 1; ++ k ) {
+		CK[ k ] = new Vector4( 0, 0, 0 );
+	}
+	return CK;
+}
+/*
+Calculate "K over I"
+returns k!/(i!(k-i)!)
+*/
+function calcKoverI( k, i ) {
+	let nom = 1;
+	for ( let j = 2; j <= k; ++ j ) {
+		nom *= j;
+	}
+	let denom = 1;
+	for ( let j = 2; j <= i; ++ j ) {
+		denom *= j;
+	}
+	for ( let j = 2; j <= k - i; ++ j ) {
+		denom *= j;
+	}
+	return nom / denom;
+}
+/*
+Calculate derivatives (0-nd) of rational curve. See The NURBS Book, page 127, algorithm A4.2.
+Pders : result of function calcBSplineDerivatives
+returns array with derivatives for rational curve.
+*/
+function calcRationalCurveDerivatives( Pders ) {
+	const nd = Pders.length;
+	const Aders = [];
+	const wders = [];
+	for ( let i = 0; i < nd; ++ i ) {
+		const point = Pders[ i ];
+		Aders[ i ] = new Vector3( point.x, point.y, point.z );
+		wders[ i ] = point.w;
+	}
+	const CK = [];
+	for ( let k = 0; k < nd; ++ k ) {
+		const v = Aders[ k ].clone();
+		for ( let i = 1; i <= k; ++ i ) {
+			v.sub( CK[ k - i ].clone().multiplyScalar( calcKoverI( k, i ) * wders[ i ] ) );
+		}
+		CK[ k ] = v.divideScalar( wders[ 0 ] );
+	}
+	return CK;
+}
+/*
+Calculate NURBS curve derivatives. See The NURBS Book, page 127, algorithm A4.2.
+p  : degree
+U  : knot vector
+P  : control points in homogeneous space
+u  : parametric points
+nd : number of derivatives
+returns array with derivatives.
+*/
+function calcNURBSDerivatives( p, U, P, u, nd ) {
+	const Pders = calcBSplineDerivatives( p, U, P, u, nd );
+	return calcRationalCurveDerivatives( Pders );
+}
+/*
+Calculate rational B-Spline surface point. See The NURBS Book, page 134, algorithm A4.3.
+p, q : degrees of B-Spline surface
+U, V : knot vectors
+P    : control points (x, y, z, w)
+u, v : parametric values
+returns point for given (u, v)
+*/
+function calcSurfacePoint( p, q, U, V, P, u, v, target ) {
+	const uspan = findSpan( p, u, U );
+	const vspan = findSpan( q, v, V );
+	const Nu = calcBasisFunctions( uspan, u, p, U );
+	const Nv = calcBasisFunctions( vspan, v, q, V );
+	const temp = [];
+	for ( let l = 0; l <= q; ++ l ) {
+		temp[ l ] = new Vector4( 0, 0, 0, 0 );
+		for ( let k = 0; k <= p; ++ k ) {
+			const point = P[ uspan - p + k ][ vspan - q + l ].clone();
+			const w = point.w;
+			point.x *= w;
+			point.y *= w;
+			point.z *= w;
+			temp[ l ].add( point.multiplyScalar( Nu[ k ] ) );
+		}
+	}
+	const Sw = new Vector4( 0, 0, 0, 0 );
+	for ( let l = 0; l <= q; ++ l ) {
+		Sw.add( temp[ l ].multiplyScalar( Nv[ l ] ) );
+	}
+	Sw.divideScalar( Sw.w );
+	target.set( Sw.x, Sw.y, Sw.z );
+}
+/*
+Calculate rational B-Spline volume point. See The NURBS Book, page 134, algorithm A4.3.
+p, q, r   : degrees of B-Splinevolume
+U, V, W   : knot vectors
+P         : control points (x, y, z, w)
+u, v, w   : parametric values
+returns point for given (u, v, w)
+*/
+function calcVolumePoint( p, q, r, U, V, W, P, u, v, w, target ) {
+	const uspan = findSpan( p, u, U );
+	const vspan = findSpan( q, v, V );
+	const wspan = findSpan( r, w, W );
+	const Nu = calcBasisFunctions( uspan, u, p, U );
+	const Nv = calcBasisFunctions( vspan, v, q, V );
+	const Nw = calcBasisFunctions( wspan, w, r, W );
+	const temp = [];
+	for ( let m = 0; m <= r; ++ m ) {
+		temp[ m ] = [];
+		for ( let l = 0; l <= q; ++ l ) {
+			temp[ m ][ l ] = new Vector4( 0, 0, 0, 0 );
+			for ( let k = 0; k <= p; ++ k ) {
+				const point = P[ uspan - p + k ][ vspan - q + l ][ wspan - r + m ].clone();
+				const w = point.w;
+				point.x *= w;
+				point.y *= w;
+				point.z *= w;
+				temp[ m ][ l ].add( point.multiplyScalar( Nu[ k ] ) );
+			}
+		}
+	}
+	const Sw = new Vector4( 0, 0, 0, 0 );
+	for ( let m = 0; m <= r; ++ m ) {
+		for ( let l = 0; l <= q; ++ l ) {
+			Sw.add( temp[ m ][ l ].multiplyScalar( Nw[ m ] ).multiplyScalar( Nv[ l ] ) );
+		}
+	}
+	Sw.divideScalar( Sw.w );
+	target.set( Sw.x, Sw.y, Sw.z );
+}
+export {
+	findSpan,
+	calcBasisFunctions,
+	calcBSplinePoint,
+	calcBasisFunctionDerivatives,
+	calcBSplineDerivatives,
+	calcKoverI,
+	calcRationalCurveDerivatives,
+	calcNURBSDerivatives,
+	calcSurfacePoint,
+	calcVolumePoint,
+};

libs/three.js/0.172.0/jsm/curves/NURBSVolume.js ADDED Viewed

	@@ -0,0 +1,62 @@

+import {
+	Vector4
+} from 'three';
+import * as NURBSUtils from '../curves/NURBSUtils.js';
+/**
+ * NURBS volume object
+ *
+ * Implementation is based on (x, y, z [, w=1]]) control points with w=weight.
+ **/
+class NURBSVolume {
+	constructor( degree1, degree2, degree3, knots1, knots2, knots3 /* arrays of reals */, controlPoints /* array^3 of Vector(2|3|4) */ ) {
+		this.degree1 = degree1;
+		this.degree2 = degree2;
+		this.degree3 = degree3;
+		this.knots1 = knots1;
+		this.knots2 = knots2;
+		this.knots3 = knots3;
+		this.controlPoints = [];
+		const len1 = knots1.length - degree1 - 1;
+		const len2 = knots2.length - degree2 - 1;
+		const len3 = knots3.length - degree3 - 1;
+		// ensure Vector4 for control points
+		for ( let i = 0; i < len1; ++ i ) {
+			this.controlPoints[ i ] = [];
+			for ( let j = 0; j < len2; ++ j ) {
+				this.controlPoints[ i ][ j ] = [];
+				for ( let k = 0; k < len3; ++ k ) {
+					const point = controlPoints[ i ][ j ][ k ];
+					this.controlPoints[ i ][ j ][ k ] = new Vector4( point.x, point.y, point.z, point.w );
+				}
+			}
+		}
+	}
+	getPoint( t1, t2, t3, target ) {
+		const u = this.knots1[ 0 ] + t1 * ( this.knots1[ this.knots1.length - 1 ] - this.knots1[ 0 ] ); // linear mapping t1->u
+		const v = this.knots2[ 0 ] + t2 * ( this.knots2[ this.knots2.length - 1 ] - this.knots2[ 0 ] ); // linear mapping t2->v
+		const w = this.knots3[ 0 ] + t3 * ( this.knots3[ this.knots3.length - 1 ] - this.knots3[ 0 ] ); // linear mapping t3->w
+		NURBSUtils.calcVolumePoint( this.degree1, this.degree2, this.degree3, this.knots1, this.knots2, this.knots3, this.controlPoints, u, v, w, target );
+	}
+}
+export { NURBSVolume };

libs/three.js/0.172.0/jsm/effects/AnaglyphEffect.js ADDED Viewed

	@@ -0,0 +1,147 @@

+import {
+	LinearFilter,
+	Matrix3,
+	NearestFilter,
+	RGBAFormat,
+	ShaderMaterial,
+	StereoCamera,
+	WebGLRenderTarget
+} from 'three';
+import { FullScreenQuad } from '../postprocessing/Pass.js';
+class AnaglyphEffect {
+	constructor( renderer, width = 512, height = 512 ) {
+		// Dubois matrices from https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.7.6968&rep=rep1&type=pdf#page=4
+		this.colorMatrixLeft = new Matrix3().fromArray( [
+			0.456100, - 0.0400822, - 0.0152161,
+			0.500484, - 0.0378246, - 0.0205971,
+			0.176381, - 0.0157589, - 0.00546856
+		] );
+		this.colorMatrixRight = new Matrix3().fromArray( [
+			- 0.0434706, 0.378476, - 0.0721527,
+			- 0.0879388, 0.73364, - 0.112961,
+			- 0.00155529, - 0.0184503, 1.2264
+		] );
+		const _stereo = new StereoCamera();
+		const _params = { minFilter: LinearFilter, magFilter: NearestFilter, format: RGBAFormat };
+		const _renderTargetL = new WebGLRenderTarget( width, height, _params );
+		const _renderTargetR = new WebGLRenderTarget( width, height, _params );
+		const _material = new ShaderMaterial( {
+			uniforms: {
+				'mapLeft': { value: _renderTargetL.texture },
+				'mapRight': { value: _renderTargetR.texture },
+				'colorMatrixLeft': { value: this.colorMatrixLeft },
+				'colorMatrixRight': { value: this.colorMatrixRight }
+			},
+			vertexShader: [
+				'varying vec2 vUv;',
+				'void main() {',
+				'	vUv = vec2( uv.x, uv.y );',
+				'	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+				'}'
+			].join( '\n' ),
+			fragmentShader: [
+				'uniform sampler2D mapLeft;',
+				'uniform sampler2D mapRight;',
+				'varying vec2 vUv;',
+				'uniform mat3 colorMatrixLeft;',
+				'uniform mat3 colorMatrixRight;',
+				'void main() {',
+				'	vec2 uv = vUv;',
+				'	vec4 colorL = texture2D( mapLeft, uv );',
+				'	vec4 colorR = texture2D( mapRight, uv );',
+				'	vec3 color = clamp(',
+				'			colorMatrixLeft * colorL.rgb +',
+				'			colorMatrixRight * colorR.rgb, 0., 1. );',
+				'	gl_FragColor = vec4(',
+				'			color.r, color.g, color.b,',
+				'			max( colorL.a, colorR.a ) );',
+				'	#include <tonemapping_fragment>',
+				'	#include <colorspace_fragment>',
+				'}'
+			].join( '\n' )
+		} );
+		const _quad = new FullScreenQuad( _material );
+		this.setSize = function ( width, height ) {
+			renderer.setSize( width, height );
+			const pixelRatio = renderer.getPixelRatio();
+			_renderTargetL.setSize( width * pixelRatio, height * pixelRatio );
+			_renderTargetR.setSize( width * pixelRatio, height * pixelRatio );
+		};
+		this.render = function ( scene, camera ) {
+			const currentRenderTarget = renderer.getRenderTarget();
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+			_stereo.update( camera );
+			renderer.setRenderTarget( _renderTargetL );
+			renderer.clear();
+			renderer.render( scene, _stereo.cameraL );
+			renderer.setRenderTarget( _renderTargetR );
+			renderer.clear();
+			renderer.render( scene, _stereo.cameraR );
+			renderer.setRenderTarget( null );
+			_quad.render( renderer );
+			renderer.setRenderTarget( currentRenderTarget );
+		};
+		this.dispose = function () {
+			_renderTargetL.dispose();
+			_renderTargetR.dispose();
+			_material.dispose();
+			_quad.dispose();
+		};
+	}
+}
+export { AnaglyphEffect };

libs/three.js/0.172.0/jsm/effects/AsciiEffect.js ADDED Viewed

	@@ -0,0 +1,263 @@

+/**
+ * Ascii generation is based on https://github.com/hassadee/jsascii/blob/master/jsascii.js
+ *
+ * 16 April 2012 - @blurspline
+ */
+class AsciiEffect {
+	constructor( renderer, charSet = ' .:-=+*#%@', options = {} ) {
+		// ' .,:;=|iI+hHOE#`$';
+		// darker bolder character set from https://github.com/saw/Canvas-ASCII-Art/
+		// ' .\'`^",:;Il!i~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$'.split('');
+		// Some ASCII settings
+		const fResolution = options[ 'resolution' ] || 0.15; // Higher for more details
+		const iScale = options[ 'scale' ] || 1;
+		const bColor = options[ 'color' ] || false; // nice but slows down rendering!
+		const bAlpha = options[ 'alpha' ] || false; // Transparency
+		const bBlock = options[ 'block' ] || false; // blocked characters. like good O dos
+		const bInvert = options[ 'invert' ] || false; // black is white, white is black
+		const strResolution = options[ 'strResolution' ] || 'low';
+		let width, height;
+		const domElement = document.createElement( 'div' );
+		domElement.style.cursor = 'default';
+		const oAscii = document.createElement( 'table' );
+		domElement.appendChild( oAscii );
+		let iWidth, iHeight;
+		let oImg;
+		this.setSize = function ( w, h ) {
+			width = w;
+			height = h;
+			renderer.setSize( w, h );
+			initAsciiSize();
+		};
+		this.render = function ( scene, camera ) {
+			renderer.render( scene, camera );
+			asciifyImage( oAscii );
+		};
+		this.domElement = domElement;
+		// Throw in ascii library from https://github.com/hassadee/jsascii/blob/master/jsascii.js (MIT License)
+		function initAsciiSize() {
+			iWidth = Math.floor( width * fResolution );
+			iHeight = Math.floor( height * fResolution );
+			oCanvas.width = iWidth;
+			oCanvas.height = iHeight;
+			// oCanvas.style.display = "none";
+			// oCanvas.style.width = iWidth;
+			// oCanvas.style.height = iHeight;
+			oImg = renderer.domElement;
+			if ( oImg.style.backgroundColor ) {
+				oAscii.rows[ 0 ].cells[ 0 ].style.backgroundColor = oImg.style.backgroundColor;
+				oAscii.rows[ 0 ].cells[ 0 ].style.color = oImg.style.color;
+			}
+			oAscii.cellSpacing = 0;
+			oAscii.cellPadding = 0;
+			const oStyle = oAscii.style;
+			oStyle.whiteSpace = 'pre';
+			oStyle.margin = '0px';
+			oStyle.padding = '0px';
+			oStyle.letterSpacing = fLetterSpacing + 'px';
+			oStyle.fontFamily = strFont;
+			oStyle.fontSize = fFontSize + 'px';
+			oStyle.lineHeight = fLineHeight + 'px';
+			oStyle.textAlign = 'left';
+			oStyle.textDecoration = 'none';
+		}
+		const aDefaultCharList = ( ' .,:;i1tfLCG08@' ).split( '' );
+		const aDefaultColorCharList = ( ' CGO08@' ).split( '' );
+		const strFont = 'courier new, monospace';
+		const oCanvasImg = renderer.domElement;
+		const oCanvas = document.createElement( 'canvas' );
+		if ( ! oCanvas.getContext ) {
+			return;
+		}
+		const oCtx = oCanvas.getContext( '2d' );
+		if ( ! oCtx.getImageData ) {
+			return;
+		}
+		let aCharList = ( bColor ? aDefaultColorCharList : aDefaultCharList );
+		if ( charSet ) aCharList = charSet;
+		// Setup dom
+		const fFontSize = ( 2 / fResolution ) * iScale;
+		const fLineHeight = ( 2 / fResolution ) * iScale;
+		// adjust letter-spacing for all combinations of scale and resolution to get it to fit the image width.
+		let fLetterSpacing = 0;
+		if ( strResolution == 'low' ) {
+			switch ( iScale ) {
+				case 1 : fLetterSpacing = - 1; break;
+				case 2 :
+				case 3 : fLetterSpacing = - 2.1; break;
+				case 4 : fLetterSpacing = - 3.1; break;
+				case 5 : fLetterSpacing = - 4.15; break;
+			}
+		}
+		if ( strResolution == 'medium' ) {
+			switch ( iScale ) {
+				case 1 : fLetterSpacing = 0; break;
+				case 2 : fLetterSpacing = - 1; break;
+				case 3 : fLetterSpacing = - 1.04; break;
+				case 4 :
+				case 5 : fLetterSpacing = - 2.1; break;
+			}
+		}
+		if ( strResolution == 'high' ) {
+			switch ( iScale ) {
+				case 1 :
+				case 2 : fLetterSpacing = 0; break;
+				case 3 :
+				case 4 :
+				case 5 : fLetterSpacing = - 1; break;
+			}
+		}
+		// can't get a span or div to flow like an img element, but a table works?
+		// convert img element to ascii
+		function asciifyImage( oAscii ) {
+			oCtx.clearRect( 0, 0, iWidth, iHeight );
+			oCtx.drawImage( oCanvasImg, 0, 0, iWidth, iHeight );
+			const oImgData = oCtx.getImageData( 0, 0, iWidth, iHeight ).data;
+			// Coloring loop starts now
+			let strChars = '';
+			// console.time('rendering');
+			for ( let y = 0; y < iHeight; y += 2 ) {
+				for ( let x = 0; x < iWidth; x ++ ) {
+					const iOffset = ( y * iWidth + x ) * 4;
+					const iRed = oImgData[ iOffset ];
+					const iGreen = oImgData[ iOffset + 1 ];
+					const iBlue = oImgData[ iOffset + 2 ];
+					const iAlpha = oImgData[ iOffset + 3 ];
+					let iCharIdx;
+					let fBrightness;
+					fBrightness = ( 0.3 * iRed + 0.59 * iGreen + 0.11 * iBlue ) / 255;
+					// fBrightness = (0.3*iRed + 0.5*iGreen + 0.3*iBlue) / 255;
+					if ( iAlpha == 0 ) {
+						// should calculate alpha instead, but quick hack :)
+						//fBrightness *= (iAlpha / 255);
+						fBrightness = 1;
+					}
+					iCharIdx = Math.floor( ( 1 - fBrightness ) * ( aCharList.length - 1 ) );
+					if ( bInvert ) {
+						iCharIdx = aCharList.length - iCharIdx - 1;
+					}
+					// good for debugging
+					//fBrightness = Math.floor(fBrightness * 10);
+					//strThisChar = fBrightness;
+					let strThisChar = aCharList[ iCharIdx ];
+					if ( strThisChar === undefined || strThisChar == ' ' )
+						strThisChar = '&nbsp;';
+					if ( bColor ) {
+						strChars += '<span style=\''
+							+ 'color:rgb(' + iRed + ',' + iGreen + ',' + iBlue + ');'
+							+ ( bBlock ? 'background-color:rgb(' + iRed + ',' + iGreen + ',' + iBlue + ');' : '' )
+							+ ( bAlpha ? 'opacity:' + ( iAlpha / 255 ) + ';' : '' )
+							+ '\'>' + strThisChar + '</span>';
+					} else {
+						strChars += strThisChar;
+					}
+				}
+				strChars += '<br/>';
+			}
+			oAscii.innerHTML = `<tr><td style="display:block;width:${width}px;height:${height}px;overflow:hidden">${strChars}</td></tr>`;
+			// console.timeEnd('rendering');
+			// return oAscii;
+		}
+	}
+}
+export { AsciiEffect };

libs/three.js/0.172.0/jsm/effects/OutlineEffect.js ADDED Viewed

	@@ -0,0 +1,539 @@

+import {
+	BackSide,
+	Color,
+	ShaderMaterial,
+	UniformsLib,
+	UniformsUtils
+} from 'three';
+/**
+ * Reference: https://en.wikipedia.org/wiki/Cel_shading
+ *
+ * API
+ *
+ * 1. Traditional
+ *
+ * const effect = new OutlineEffect( renderer );
+ *
+ * function render() {
+ *
+ * 	effect.render( scene, camera );
+ *
+ * }
+ *
+ * 2. VR compatible
+ *
+ * const effect = new OutlineEffect( renderer );
+ * let renderingOutline = false;
+ *
+ * scene.onAfterRender = function () {
+ *
+ * 	if ( renderingOutline ) return;
+ *
+ * 	renderingOutline = true;
+ *
+ * 	effect.renderOutline( scene, camera );
+ *
+ * 	renderingOutline = false;
+ *
+ * };
+ *
+ * function render() {
+ *
+ * 	renderer.render( scene, camera );
+ *
+ * }
+ *
+ * // How to set default outline parameters
+ * new OutlineEffect( renderer, {
+ * 	defaultThickness: 0.01,
+ * 	defaultColor: [ 0, 0, 0 ],
+ * 	defaultAlpha: 0.8,
+ * 	defaultKeepAlive: true // keeps outline material in cache even if material is removed from scene
+ * } );
+ *
+ * // How to set outline parameters for each material
+ * material.userData.outlineParameters = {
+ * 	thickness: 0.01,
+ * 	color: [ 0, 0, 0 ],
+ * 	alpha: 0.8,
+ * 	visible: true,
+ * 	keepAlive: true
+ * };
+ */
+class OutlineEffect {
+	constructor( renderer, parameters = {} ) {
+		this.enabled = true;
+		const defaultThickness = parameters.defaultThickness !== undefined ? parameters.defaultThickness : 0.003;
+		const defaultColor = new Color().fromArray( parameters.defaultColor !== undefined ? parameters.defaultColor : [ 0, 0, 0 ] );
+		const defaultAlpha = parameters.defaultAlpha !== undefined ? parameters.defaultAlpha : 1.0;
+		const defaultKeepAlive = parameters.defaultKeepAlive !== undefined ? parameters.defaultKeepAlive : false;
+		// object.material.uuid -> outlineMaterial or
+		// object.material[ n ].uuid -> outlineMaterial
+		// save at the outline material creation and release
+		// if it's unused removeThresholdCount frames
+		// unless keepAlive is true.
+		const cache = {};
+		const removeThresholdCount = 60;
+		// outlineMaterial.uuid -> object.material or
+		// outlineMaterial.uuid -> object.material[ n ]
+		// save before render and release after render.
+		const originalMaterials = {};
+		// object.uuid -> originalOnBeforeRender
+		// save before render and release after render.
+		const originalOnBeforeRenders = {};
+		//this.cache = cache;  // for debug
+		const uniformsOutline = {
+			outlineThickness: { value: defaultThickness },
+			outlineColor: { value: defaultColor },
+			outlineAlpha: { value: defaultAlpha }
+		};
+		const vertexShader = [
+			'#include <common>',
+			'#include <uv_pars_vertex>',
+			'#include <displacementmap_pars_vertex>',
+			'#include <fog_pars_vertex>',
+			'#include <morphtarget_pars_vertex>',
+			'#include <skinning_pars_vertex>',
+			'#include <logdepthbuf_pars_vertex>',
+			'#include <clipping_planes_pars_vertex>',
+			'uniform float outlineThickness;',
+			'vec4 calculateOutline( vec4 pos, vec3 normal, vec4 skinned ) {',
+			'	float thickness = outlineThickness;',
+			'	const float ratio = 1.0;', // TODO: support outline thickness ratio for each vertex
+			'	vec4 pos2 = projectionMatrix * modelViewMatrix * vec4( skinned.xyz + normal, 1.0 );',
+			// NOTE: subtract pos2 from pos because BackSide objectNormal is negative
+			'	vec4 norm = normalize( pos - pos2 );',
+			'	return pos + norm * thickness * pos.w * ratio;',
+			'}',
+			'void main() {',
+			'	#include <uv_vertex>',
+			'	#include <beginnormal_vertex>',
+			'	#include <morphnormal_vertex>',
+			'	#include <skinbase_vertex>',
+			'	#include <skinnormal_vertex>',
+			'	#include <begin_vertex>',
+			'	#include <morphtarget_vertex>',
+			'	#include <skinning_vertex>',
+			'	#include <displacementmap_vertex>',
+			'	#include <project_vertex>',
+			'	vec3 outlineNormal = - objectNormal;', // the outline material is always rendered with BackSide
+			'	gl_Position = calculateOutline( gl_Position, outlineNormal, vec4( transformed, 1.0 ) );',
+			'	#include <logdepthbuf_vertex>',
+			'	#include <clipping_planes_vertex>',
+			'	#include <fog_vertex>',
+			'}',
+		].join( '\n' );
+		const fragmentShader = [
+			'#include <common>',
+			'#include <fog_pars_fragment>',
+			'#include <logdepthbuf_pars_fragment>',
+			'#include <clipping_planes_pars_fragment>',
+			'uniform vec3 outlineColor;',
+			'uniform float outlineAlpha;',
+			'void main() {',
+			'	#include <clipping_planes_fragment>',
+			'	#include <logdepthbuf_fragment>',
+			'	gl_FragColor = vec4( outlineColor, outlineAlpha );',
+			'	#include <tonemapping_fragment>',
+			'	#include <colorspace_fragment>',
+			'	#include <fog_fragment>',
+			'	#include <premultiplied_alpha_fragment>',
+			'}'
+		].join( '\n' );
+		function createMaterial() {
+			return new ShaderMaterial( {
+				type: 'OutlineEffect',
+				uniforms: UniformsUtils.merge( [
+					UniformsLib[ 'fog' ],
+					UniformsLib[ 'displacementmap' ],
+					uniformsOutline
+				] ),
+				vertexShader: vertexShader,
+				fragmentShader: fragmentShader,
+				side: BackSide
+			} );
+		}
+		function getOutlineMaterialFromCache( originalMaterial ) {
+			let data = cache[ originalMaterial.uuid ];
+			if ( data === undefined ) {
+				data = {
+					material: createMaterial(),
+					used: true,
+					keepAlive: defaultKeepAlive,
+					count: 0
+				};
+				cache[ originalMaterial.uuid ] = data;
+			}
+			data.used = true;
+			return data.material;
+		}
+		function getOutlineMaterial( originalMaterial ) {
+			const outlineMaterial = getOutlineMaterialFromCache( originalMaterial );
+			originalMaterials[ outlineMaterial.uuid ] = originalMaterial;
+			updateOutlineMaterial( outlineMaterial, originalMaterial );
+			return outlineMaterial;
+		}
+		function isCompatible( object ) {
+			const geometry = object.geometry;
+			const hasNormals = ( geometry !== undefined ) && ( geometry.attributes.normal !== undefined );
+			return ( object.isMesh === true && object.material !== undefined && hasNormals === true );
+		}
+		function setOutlineMaterial( object ) {
+			if ( isCompatible( object ) === false ) return;
+			if ( Array.isArray( object.material ) ) {
+				for ( let i = 0, il = object.material.length; i < il; i ++ ) {
+					object.material[ i ] = getOutlineMaterial( object.material[ i ] );
+				}
+			} else {
+				object.material = getOutlineMaterial( object.material );
+			}
+			originalOnBeforeRenders[ object.uuid ] = object.onBeforeRender;
+			object.onBeforeRender = onBeforeRender;
+		}
+		function restoreOriginalMaterial( object ) {
+			if ( isCompatible( object ) === false ) return;
+			if ( Array.isArray( object.material ) ) {
+				for ( let i = 0, il = object.material.length; i < il; i ++ ) {
+					object.material[ i ] = originalMaterials[ object.material[ i ].uuid ];
+				}
+			} else {
+				object.material = originalMaterials[ object.material.uuid ];
+			}
+			object.onBeforeRender = originalOnBeforeRenders[ object.uuid ];
+		}
+		function onBeforeRender( renderer, scene, camera, geometry, material ) {
+			const originalMaterial = originalMaterials[ material.uuid ];
+			// just in case
+			if ( originalMaterial === undefined ) return;
+			updateUniforms( material, originalMaterial );
+		}
+		function updateUniforms( material, originalMaterial ) {
+			const outlineParameters = originalMaterial.userData.outlineParameters;
+			material.uniforms.outlineAlpha.value = originalMaterial.opacity;
+			if ( outlineParameters !== undefined ) {
+				if ( outlineParameters.thickness !== undefined ) material.uniforms.outlineThickness.value = outlineParameters.thickness;
+				if ( outlineParameters.color !== undefined ) material.uniforms.outlineColor.value.fromArray( outlineParameters.color );
+				if ( outlineParameters.alpha !== undefined ) material.uniforms.outlineAlpha.value = outlineParameters.alpha;
+			}
+			if ( originalMaterial.displacementMap ) {
+				material.uniforms.displacementMap.value = originalMaterial.displacementMap;
+				material.uniforms.displacementScale.value = originalMaterial.displacementScale;
+				material.uniforms.displacementBias.value = originalMaterial.displacementBias;
+			}
+		}
+		function updateOutlineMaterial( material, originalMaterial ) {
+			if ( material.name === 'invisible' ) return;
+			const outlineParameters = originalMaterial.userData.outlineParameters;
+			material.fog = originalMaterial.fog;
+			material.toneMapped = originalMaterial.toneMapped;
+			material.premultipliedAlpha = originalMaterial.premultipliedAlpha;
+			material.displacementMap = originalMaterial.displacementMap;
+			if ( outlineParameters !== undefined ) {
+				if ( originalMaterial.visible === false ) {
+					material.visible = false;
+				} else {
+					material.visible = ( outlineParameters.visible !== undefined ) ? outlineParameters.visible : true;
+				}
+				material.transparent = ( outlineParameters.alpha !== undefined && outlineParameters.alpha < 1.0 ) ? true : originalMaterial.transparent;
+				if ( outlineParameters.keepAlive !== undefined ) cache[ originalMaterial.uuid ].keepAlive = outlineParameters.keepAlive;
+			} else {
+				material.transparent = originalMaterial.transparent;
+				material.visible = originalMaterial.visible;
+			}
+			if ( originalMaterial.wireframe === true || originalMaterial.depthTest === false ) material.visible = false;
+			if ( originalMaterial.clippingPlanes ) {
+				material.clipping = true;
+				material.clippingPlanes = originalMaterial.clippingPlanes;
+				material.clipIntersection = originalMaterial.clipIntersection;
+				material.clipShadows = originalMaterial.clipShadows;
+			}
+			material.version = originalMaterial.version; // update outline material if necessary
+		}
+		function cleanupCache() {
+			let keys;
+			// clear originalMaterials
+			keys = Object.keys( originalMaterials );
+			for ( let i = 0, il = keys.length; i < il; i ++ ) {
+				originalMaterials[ keys[ i ] ] = undefined;
+			}
+			// clear originalOnBeforeRenders
+			keys = Object.keys( originalOnBeforeRenders );
+			for ( let i = 0, il = keys.length; i < il; i ++ ) {
+				originalOnBeforeRenders[ keys[ i ] ] = undefined;
+			}
+			// remove unused outlineMaterial from cache
+			keys = Object.keys( cache );
+			for ( let i = 0, il = keys.length; i < il; i ++ ) {
+				const key = keys[ i ];
+				if ( cache[ key ].used === false ) {
+					cache[ key ].count ++;
+					if ( cache[ key ].keepAlive === false && cache[ key ].count > removeThresholdCount ) {
+						delete cache[ key ];
+					}
+				} else {
+					cache[ key ].used = false;
+					cache[ key ].count = 0;
+				}
+			}
+		}
+		this.render = function ( scene, camera ) {
+			if ( this.enabled === false ) {
+				renderer.render( scene, camera );
+				return;
+			}
+			const currentAutoClear = renderer.autoClear;
+			renderer.autoClear = this.autoClear;
+			renderer.render( scene, camera );
+			renderer.autoClear = currentAutoClear;
+			this.renderOutline( scene, camera );
+		};
+		this.renderOutline = function ( scene, camera ) {
+			const currentAutoClear = renderer.autoClear;
+			const currentSceneAutoUpdate = scene.matrixWorldAutoUpdate;
+			const currentSceneBackground = scene.background;
+			const currentShadowMapEnabled = renderer.shadowMap.enabled;
+			scene.matrixWorldAutoUpdate = false;
+			scene.background = null;
+			renderer.autoClear = false;
+			renderer.shadowMap.enabled = false;
+			scene.traverse( setOutlineMaterial );
+			renderer.render( scene, camera );
+			scene.traverse( restoreOriginalMaterial );
+			cleanupCache();
+			scene.matrixWorldAutoUpdate = currentSceneAutoUpdate;
+			scene.background = currentSceneBackground;
+			renderer.autoClear = currentAutoClear;
+			renderer.shadowMap.enabled = currentShadowMapEnabled;
+		};
+		/*
+		 * See #9918
+		 *
+		 * The following property copies and wrapper methods enable
+		 * OutlineEffect to be called from other *Effect, like
+		 *
+		 * effect = new StereoEffect( new OutlineEffect( renderer ) );
+		 *
+		 * function render () {
+		 *
+	 	 * 	effect.render( scene, camera );
+		 *
+		 * }
+		 */
+		this.autoClear = renderer.autoClear;
+		this.domElement = renderer.domElement;
+		this.shadowMap = renderer.shadowMap;
+		this.clear = function ( color, depth, stencil ) {
+			renderer.clear( color, depth, stencil );
+		};
+		this.getPixelRatio = function () {
+			return renderer.getPixelRatio();
+		};
+		this.setPixelRatio = function ( value ) {
+			renderer.setPixelRatio( value );
+		};
+		this.getSize = function ( target ) {
+			return renderer.getSize( target );
+		};
+		this.setSize = function ( width, height, updateStyle ) {
+			renderer.setSize( width, height, updateStyle );
+		};
+		this.setViewport = function ( x, y, width, height ) {
+			renderer.setViewport( x, y, width, height );
+		};
+		this.setScissor = function ( x, y, width, height ) {
+			renderer.setScissor( x, y, width, height );
+		};
+		this.setScissorTest = function ( boolean ) {
+			renderer.setScissorTest( boolean );
+		};
+		this.setRenderTarget = function ( renderTarget ) {
+			renderer.setRenderTarget( renderTarget );
+		};
+	}
+}
+export { OutlineEffect };

libs/three.js/0.172.0/jsm/effects/ParallaxBarrierEffect.js ADDED Viewed

	@@ -0,0 +1,125 @@

+import {
+	LinearFilter,
+	NearestFilter,
+	RGBAFormat,
+	ShaderMaterial,
+	StereoCamera,
+	WebGLRenderTarget
+} from 'three';
+import { FullScreenQuad } from '../postprocessing/Pass.js';
+class ParallaxBarrierEffect {
+	constructor( renderer ) {
+		const _stereo = new StereoCamera();
+		const _params = { minFilter: LinearFilter, magFilter: NearestFilter, format: RGBAFormat };
+		const _renderTargetL = new WebGLRenderTarget( 512, 512, _params );
+		const _renderTargetR = new WebGLRenderTarget( 512, 512, _params );
+		const _material = new ShaderMaterial( {
+			uniforms: {
+				'mapLeft': { value: _renderTargetL.texture },
+				'mapRight': { value: _renderTargetR.texture }
+			},
+			vertexShader: [
+				'varying vec2 vUv;',
+				'void main() {',
+				'	vUv = vec2( uv.x, uv.y );',
+				'	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+				'}'
+			].join( '\n' ),
+			fragmentShader: [
+				'uniform sampler2D mapLeft;',
+				'uniform sampler2D mapRight;',
+				'varying vec2 vUv;',
+				'void main() {',
+				'	vec2 uv = vUv;',
+				'	if ( ( mod( gl_FragCoord.y, 2.0 ) ) > 1.00 ) {',
+				'		gl_FragColor = texture2D( mapLeft, uv );',
+				'	} else {',
+				'		gl_FragColor = texture2D( mapRight, uv );',
+				'	}',
+				'	#include <tonemapping_fragment>',
+				'	#include <colorspace_fragment>',
+				'}'
+			].join( '\n' )
+		} );
+		const _quad = new FullScreenQuad( _material );
+		this.setSize = function ( width, height ) {
+			renderer.setSize( width, height );
+			const pixelRatio = renderer.getPixelRatio();
+			_renderTargetL.setSize( width * pixelRatio, height * pixelRatio );
+			_renderTargetR.setSize( width * pixelRatio, height * pixelRatio );
+		};
+		this.render = function ( scene, camera ) {
+			const currentRenderTarget = renderer.getRenderTarget();
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+			_stereo.update( camera );
+			renderer.setRenderTarget( _renderTargetL );
+			renderer.clear();
+			renderer.render( scene, _stereo.cameraL );
+			renderer.setRenderTarget( _renderTargetR );
+			renderer.clear();
+			renderer.render( scene, _stereo.cameraR );
+			renderer.setRenderTarget( null );
+			_quad.render( renderer );
+			renderer.setRenderTarget( currentRenderTarget );
+		};
+		this.dispose = function () {
+			_renderTargetL.dispose();
+			_renderTargetR.dispose();
+			_material.dispose();
+			_quad.dispose();
+		};
+	}
+}
+export { ParallaxBarrierEffect };

libs/three.js/0.172.0/jsm/effects/PeppersGhostEffect.js ADDED Viewed

	@@ -0,0 +1,153 @@

+import {
+	PerspectiveCamera,
+	Quaternion,
+	Vector3
+} from 'three';
+/**
+ * peppers ghost effect based on http://www.instructables.com/id/Reflective-Prism/?ALLSTEPS
+ */
+class PeppersGhostEffect {
+	constructor( renderer ) {
+		const scope = this;
+		scope.cameraDistance = 15;
+		scope.reflectFromAbove = false;
+		// Internals
+		let _halfWidth, _width, _height;
+		const _cameraF = new PerspectiveCamera(); //front
+		const _cameraB = new PerspectiveCamera(); //back
+		const _cameraL = new PerspectiveCamera(); //left
+		const _cameraR = new PerspectiveCamera(); //right
+		const _position = new Vector3();
+		const _quaternion = new Quaternion();
+		const _scale = new Vector3();
+		// Initialization
+		renderer.autoClear = false;
+		this.setSize = function ( width, height ) {
+			_halfWidth = width / 2;
+			if ( width < height ) {
+				_width = width / 3;
+				_height = width / 3;
+			} else {
+				_width = height / 3;
+				_height = height / 3;
+			}
+			renderer.setSize( width, height );
+		};
+		this.render = function ( scene, camera ) {
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+			camera.matrixWorld.decompose( _position, _quaternion, _scale );
+			// front
+			_cameraF.position.copy( _position );
+			_cameraF.quaternion.copy( _quaternion );
+			_cameraF.translateZ( scope.cameraDistance );
+			_cameraF.lookAt( scene.position );
+			// back
+			_cameraB.position.copy( _position );
+			_cameraB.quaternion.copy( _quaternion );
+			_cameraB.translateZ( - ( scope.cameraDistance ) );
+			_cameraB.lookAt( scene.position );
+			_cameraB.rotation.z += 180 * ( Math.PI / 180 );
+			// left
+			_cameraL.position.copy( _position );
+			_cameraL.quaternion.copy( _quaternion );
+			_cameraL.translateX( - ( scope.cameraDistance ) );
+			_cameraL.lookAt( scene.position );
+			_cameraL.rotation.x += 90 * ( Math.PI / 180 );
+			// right
+			_cameraR.position.copy( _position );
+			_cameraR.quaternion.copy( _quaternion );
+			_cameraR.translateX( scope.cameraDistance );
+			_cameraR.lookAt( scene.position );
+			_cameraR.rotation.x += 90 * ( Math.PI / 180 );
+			renderer.clear();
+			renderer.setScissorTest( true );
+			renderer.setScissor( _halfWidth - ( _width / 2 ), ( _height * 2 ), _width, _height );
+			renderer.setViewport( _halfWidth - ( _width / 2 ), ( _height * 2 ), _width, _height );
+			if ( scope.reflectFromAbove ) {
+				renderer.render( scene, _cameraB );
+			} else {
+				renderer.render( scene, _cameraF );
+			}
+			renderer.setScissor( _halfWidth - ( _width / 2 ), 0, _width, _height );
+			renderer.setViewport( _halfWidth - ( _width / 2 ), 0, _width, _height );
+			if ( scope.reflectFromAbove ) {
+				renderer.render( scene, _cameraF );
+			} else {
+				renderer.render( scene, _cameraB );
+			}
+			renderer.setScissor( _halfWidth - ( _width / 2 ) - _width, _height, _width, _height );
+			renderer.setViewport( _halfWidth - ( _width / 2 ) - _width, _height, _width, _height );
+			if ( scope.reflectFromAbove ) {
+				renderer.render( scene, _cameraR );
+			} else {
+				renderer.render( scene, _cameraL );
+			}
+			renderer.setScissor( _halfWidth + ( _width / 2 ), _height, _width, _height );
+			renderer.setViewport( _halfWidth + ( _width / 2 ), _height, _width, _height );
+			if ( scope.reflectFromAbove ) {
+				renderer.render( scene, _cameraL );
+			} else {
+				renderer.render( scene, _cameraR );
+			}
+			renderer.setScissorTest( false );
+		};
+	}
+}
+export { PeppersGhostEffect };

libs/three.js/0.172.0/jsm/effects/StereoEffect.js ADDED Viewed

	@@ -0,0 +1,60 @@

+import {
+	StereoCamera,
+	Vector2
+} from 'three';
+class StereoEffect {
+	constructor( renderer ) {
+		const _stereo = new StereoCamera();
+		_stereo.aspect = 0.5;
+		const size = new Vector2();
+		this.setEyeSeparation = function ( eyeSep ) {
+			_stereo.eyeSep = eyeSep;
+		};
+		this.setSize = function ( width, height ) {
+			renderer.setSize( width, height );
+		};
+		this.render = function ( scene, camera ) {
+			if ( scene.matrixWorldAutoUpdate === true ) scene.updateMatrixWorld();
+			if ( camera.parent === null && camera.matrixWorldAutoUpdate === true ) camera.updateMatrixWorld();
+			_stereo.update( camera );
+			const currentAutoClear = renderer.autoClear;
+			renderer.getSize( size );
+			renderer.autoClear = false;
+			renderer.clear();
+			renderer.setScissorTest( true );
+			renderer.setScissor( 0, 0, size.width / 2, size.height );
+			renderer.setViewport( 0, 0, size.width / 2, size.height );
+			renderer.render( scene, _stereo.cameraL );
+			renderer.setScissor( size.width / 2, 0, size.width / 2, size.height );
+			renderer.setViewport( size.width / 2, 0, size.width / 2, size.height );
+			renderer.render( scene, _stereo.cameraR );
+			renderer.setScissorTest( false );
+			renderer.autoClear = currentAutoClear;
+		};
+	}
+}
+export { StereoEffect };

libs/three.js/0.172.0/jsm/environments/DebugEnvironment.js ADDED Viewed

	@@ -0,0 +1,52 @@

+import {
+	BackSide,
+	BoxGeometry,
+	Mesh,
+	MeshLambertMaterial,
+	MeshStandardMaterial,
+	PointLight,
+	Scene,
+} from 'three';
+class DebugEnvironment extends Scene {
+	constructor() {
+		super();
+		const geometry = new BoxGeometry();
+		geometry.deleteAttribute( 'uv' );
+		const roomMaterial = new MeshStandardMaterial( { metalness: 0, side: BackSide } );
+		const room = new Mesh( geometry, roomMaterial );
+		room.scale.setScalar( 10 );
+		this.add( room );
+		const mainLight = new PointLight( 0xffffff, 50, 0, 2 );
+		this.add( mainLight );
+		const material1 = new MeshLambertMaterial( { color: 0xff0000, emissive: 0xffffff, emissiveIntensity: 10 } );
+		const light1 = new Mesh( geometry, material1 );
+		light1.position.set( - 5, 2, 0 );
+		light1.scale.set( 0.1, 1, 1 );
+		this.add( light1 );
+		const material2 = new MeshLambertMaterial( { color: 0x00ff00, emissive: 0xffffff, emissiveIntensity: 10 } );
+		const light2 = new Mesh( geometry, material2 );
+		light2.position.set( 0, 5, 0 );
+		light2.scale.set( 1, 0.1, 1 );
+		this.add( light2 );
+		const material3 = new MeshLambertMaterial( { color: 0x0000ff, emissive: 0xffffff, emissiveIntensity: 10 } );
+		const light3 = new Mesh( geometry, material3 );
+		light3.position.set( 2, 1, 5 );
+		light3.scale.set( 1.5, 2, 0.1 );
+		this.add( light3 );
+	}
+}
+export { DebugEnvironment };

libs/three.js/0.172.0/jsm/environments/RoomEnvironment.js ADDED Viewed

	@@ -0,0 +1,144 @@

+/**
+ * https://github.com/google/model-viewer/blob/master/packages/model-viewer/src/three-components/EnvironmentScene.ts
+ */
+import {
+ 	BackSide,
+ 	BoxGeometry,
+ 	Mesh,
+	MeshBasicMaterial,
+ 	MeshStandardMaterial,
+ 	PointLight,
+ 	Scene,
+} from 'three';
+class RoomEnvironment extends Scene {
+	constructor() {
+		super();
+		const geometry = new BoxGeometry();
+		geometry.deleteAttribute( 'uv' );
+		const roomMaterial = new MeshStandardMaterial( { side: BackSide } );
+		const boxMaterial = new MeshStandardMaterial();
+		const mainLight = new PointLight( 0xffffff, 900, 28, 2 );
+		mainLight.position.set( 0.418, 16.199, 0.300 );
+		this.add( mainLight );
+		const room = new Mesh( geometry, roomMaterial );
+		room.position.set( - 0.757, 13.219, 0.717 );
+		room.scale.set( 31.713, 28.305, 28.591 );
+		this.add( room );
+		const box1 = new Mesh( geometry, boxMaterial );
+		box1.position.set( - 10.906, 2.009, 1.846 );
+		box1.rotation.set( 0, - 0.195, 0 );
+		box1.scale.set( 2.328, 7.905, 4.651 );
+		this.add( box1 );
+		const box2 = new Mesh( geometry, boxMaterial );
+		box2.position.set( - 5.607, - 0.754, - 0.758 );
+		box2.rotation.set( 0, 0.994, 0 );
+		box2.scale.set( 1.970, 1.534, 3.955 );
+		this.add( box2 );
+		const box3 = new Mesh( geometry, boxMaterial );
+		box3.position.set( 6.167, 0.857, 7.803 );
+		box3.rotation.set( 0, 0.561, 0 );
+		box3.scale.set( 3.927, 6.285, 3.687 );
+		this.add( box3 );
+		const box4 = new Mesh( geometry, boxMaterial );
+		box4.position.set( - 2.017, 0.018, 6.124 );
+		box4.rotation.set( 0, 0.333, 0 );
+		box4.scale.set( 2.002, 4.566, 2.064 );
+		this.add( box4 );
+		const box5 = new Mesh( geometry, boxMaterial );
+		box5.position.set( 2.291, - 0.756, - 2.621 );
+		box5.rotation.set( 0, - 0.286, 0 );
+		box5.scale.set( 1.546, 1.552, 1.496 );
+		this.add( box5 );
+		const box6 = new Mesh( geometry, boxMaterial );
+		box6.position.set( - 2.193, - 0.369, - 5.547 );
+		box6.rotation.set( 0, 0.516, 0 );
+		box6.scale.set( 3.875, 3.487, 2.986 );
+		this.add( box6 );
+		// -x right
+		const light1 = new Mesh( geometry, createAreaLightMaterial( 50 ) );
+		light1.position.set( - 16.116, 14.37, 8.208 );
+		light1.scale.set( 0.1, 2.428, 2.739 );
+		this.add( light1 );
+		// -x left
+		const light2 = new Mesh( geometry, createAreaLightMaterial( 50 ) );
+		light2.position.set( - 16.109, 18.021, - 8.207 );
+		light2.scale.set( 0.1, 2.425, 2.751 );
+		this.add( light2 );
+		// +x
+		const light3 = new Mesh( geometry, createAreaLightMaterial( 17 ) );
+		light3.position.set( 14.904, 12.198, - 1.832 );
+		light3.scale.set( 0.15, 4.265, 6.331 );
+		this.add( light3 );
+		// +z
+		const light4 = new Mesh( geometry, createAreaLightMaterial( 43 ) );
+		light4.position.set( - 0.462, 8.89, 14.520 );
+		light4.scale.set( 4.38, 5.441, 0.088 );
+		this.add( light4 );
+		// -z
+		const light5 = new Mesh( geometry, createAreaLightMaterial( 20 ) );
+		light5.position.set( 3.235, 11.486, - 12.541 );
+		light5.scale.set( 2.5, 2.0, 0.1 );
+		this.add( light5 );
+		// +y
+		const light6 = new Mesh( geometry, createAreaLightMaterial( 100 ) );
+		light6.position.set( 0.0, 20.0, 0.0 );
+		light6.scale.set( 1.0, 0.1, 1.0 );
+		this.add( light6 );
+	}
+	dispose() {
+		const resources = new Set();
+		this.traverse( ( object ) => {
+			if ( object.isMesh ) {
+				resources.add( object.geometry );
+				resources.add( object.material );
+			}
+		} );
+		for ( const resource of resources ) {
+			resource.dispose();
+		}
+	}
+}
+function createAreaLightMaterial( intensity ) {
+	const material = new MeshBasicMaterial();
+	material.color.setScalar( intensity );
+	return material;
+}
+export { RoomEnvironment };

libs/three.js/0.172.0/jsm/exporters/DRACOExporter.js ADDED Viewed

	@@ -0,0 +1,269 @@

+import { Color, ColorManagement, SRGBColorSpace } from 'three';
+/**
+ * Export draco compressed files from threejs geometry objects.
+ *
+ * Draco files are compressed and usually are smaller than conventional 3D file formats.
+ *
+ * The exporter receives a options object containing
+ *  - decodeSpeed, indicates how to tune the encoder regarding decode speed (0 gives better speed but worst quality)
+ *  - encodeSpeed, indicates how to tune the encoder parameters (0 gives better speed but worst quality)
+ *  - encoderMethod
+ *  - quantization, indicates the presision of each type of data stored in the draco file in the order (POSITION, NORMAL, COLOR, TEX_COORD, GENERIC)
+ *  - exportUvs
+ *  - exportNormals
+ *  - exportColor
+ */
+/* global DracoEncoderModule */
+class DRACOExporter {
+	parse( object, options = {} ) {
+		options = Object.assign( {
+			decodeSpeed: 5,
+			encodeSpeed: 5,
+			encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
+			quantization: [ 16, 8, 8, 8, 8 ],
+			exportUvs: true,
+			exportNormals: true,
+			exportColor: false,
+		}, options );
+		if ( DracoEncoderModule === undefined ) {
+			throw new Error( 'THREE.DRACOExporter: required the draco_encoder to work.' );
+		}
+		const geometry = object.geometry;
+		const dracoEncoder = DracoEncoderModule();
+		const encoder = new dracoEncoder.Encoder();
+		let builder;
+		let dracoObject;
+		if ( object.isMesh === true ) {
+			builder = new dracoEncoder.MeshBuilder();
+			dracoObject = new dracoEncoder.Mesh();
+			const vertices = geometry.getAttribute( 'position' );
+			builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array );
+			const faces = geometry.getIndex();
+			if ( faces !== null ) {
+				builder.AddFacesToMesh( dracoObject, faces.count / 3, faces.array );
+			} else {
+				const faces = new ( vertices.count > 65535 ? Uint32Array : Uint16Array )( vertices.count );
+				for ( let i = 0; i < faces.length; i ++ ) {
+					faces[ i ] = i;
+				}
+				builder.AddFacesToMesh( dracoObject, vertices.count, faces );
+			}
+			if ( options.exportNormals === true ) {
+				const normals = geometry.getAttribute( 'normal' );
+				if ( normals !== undefined ) {
+					builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.NORMAL, normals.count, normals.itemSize, normals.array );
+				}
+			}
+			if ( options.exportUvs === true ) {
+				const uvs = geometry.getAttribute( 'uv' );
+				if ( uvs !== undefined ) {
+					builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array );
+				}
+			}
+			if ( options.exportColor === true ) {
+				const colors = geometry.getAttribute( 'color' );
+				if ( colors !== undefined ) {
+					const array = createVertexColorSRGBArray( colors );
+					builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, array );
+				}
+			}
+		} else if ( object.isPoints === true ) {
+			builder = new dracoEncoder.PointCloudBuilder();
+			dracoObject = new dracoEncoder.PointCloud();
+			const vertices = geometry.getAttribute( 'position' );
+			builder.AddFloatAttribute( dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array );
+			if ( options.exportColor === true ) {
+				const colors = geometry.getAttribute( 'color' );
+				if ( colors !== undefined ) {
+					const array = createVertexColorSRGBArray( colors );
+					builder.AddFloatAttribute( dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, array );
+				}
+			}
+		} else {
+			throw new Error( 'DRACOExporter: Unsupported object type.' );
+		}
+		//Compress using draco encoder
+		const encodedData = new dracoEncoder.DracoInt8Array();
+		//Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
+		const encodeSpeed = ( options.encodeSpeed !== undefined ) ? options.encodeSpeed : 5;
+		const decodeSpeed = ( options.decodeSpeed !== undefined ) ? options.decodeSpeed : 5;
+		encoder.SetSpeedOptions( encodeSpeed, decodeSpeed );
+		// Sets the desired encoding method for a given geometry.
+		if ( options.encoderMethod !== undefined ) {
+			encoder.SetEncodingMethod( options.encoderMethod );
+		}
+		// Sets the quantization (number of bits used to represent) compression options for a named attribute.
+		// The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
+		if ( options.quantization !== undefined ) {
+			for ( let i = 0; i < 5; i ++ ) {
+				if ( options.quantization[ i ] !== undefined ) {
+					encoder.SetAttributeQuantization( i, options.quantization[ i ] );
+				}
+			}
+		}
+		let length;
+		if ( object.isMesh === true ) {
+			length = encoder.EncodeMeshToDracoBuffer( dracoObject, encodedData );
+		} else {
+			length = encoder.EncodePointCloudToDracoBuffer( dracoObject, true, encodedData );
+		}
+		dracoEncoder.destroy( dracoObject );
+		if ( length === 0 ) {
+			throw new Error( 'THREE.DRACOExporter: Draco encoding failed.' );
+		}
+		//Copy encoded data to buffer.
+		const outputData = new Int8Array( new ArrayBuffer( length ) );
+		for ( let i = 0; i < length; i ++ ) {
+			outputData[ i ] = encodedData.GetValue( i );
+		}
+		dracoEncoder.destroy( encodedData );
+		dracoEncoder.destroy( encoder );
+		dracoEncoder.destroy( builder );
+		return outputData;
+	}
+}
+function createVertexColorSRGBArray( attribute ) {
+	// While .drc files do not specify colorspace, the only 'official' tooling
+	// is PLY and OBJ converters, which use sRGB. We'll assume sRGB is expected
+	// for .drc files, but note that Draco buffers embedded in glTF files will
+	// be Linear-sRGB instead.
+	const _color = new Color();
+	const count = attribute.count;
+	const itemSize = attribute.itemSize;
+	const array = new Float32Array( count * itemSize );
+	for ( let i = 0, il = count; i < il; i ++ ) {
+		_color.fromBufferAttribute( attribute, i );
+		ColorManagement.fromWorkingColorSpace( _color, SRGBColorSpace );
+		array[ i * itemSize ] = _color.r;
+		array[ i * itemSize + 1 ] = _color.g;
+		array[ i * itemSize + 2 ] = _color.b;
+		if ( itemSize === 4 ) {
+			array[ i * itemSize + 3 ] = attribute.getW( i );
+		}
+	}
+	return array;
+}
+// Encoder methods
+DRACOExporter.MESH_EDGEBREAKER_ENCODING = 1;
+DRACOExporter.MESH_SEQUENTIAL_ENCODING = 0;
+// Geometry type
+DRACOExporter.POINT_CLOUD = 0;
+DRACOExporter.TRIANGULAR_MESH = 1;
+// Attribute type
+DRACOExporter.INVALID = - 1;
+DRACOExporter.POSITION = 0;
+DRACOExporter.NORMAL = 1;
+DRACOExporter.COLOR = 2;
+DRACOExporter.TEX_COORD = 3;
+DRACOExporter.GENERIC = 4;
+export { DRACOExporter };

libs/three.js/0.172.0/jsm/exporters/EXRExporter.js ADDED Viewed

	@@ -0,0 +1,587 @@

+/**
+ * @author sciecode / https://github.com/sciecode
+ *
+ * EXR format references:
+ * 	https://www.openexr.com/documentation/openexrfilelayout.pdf
+ */
+import {
+	FloatType,
+	HalfFloatType,
+	RGBAFormat,
+	DataUtils,
+} from 'three';
+import * as fflate from '../libs/fflate.module.js';
+const textEncoder = new TextEncoder();
+const NO_COMPRESSION = 0;
+const ZIPS_COMPRESSION = 2;
+const ZIP_COMPRESSION = 3;
+class EXRExporter {
+	async parse( arg1, arg2, arg3 ) {
+		if ( ! arg1 || ! ( arg1.isWebGLRenderer || arg1.isWebGPURenderer || arg1.isDataTexture ) ) {
+			throw Error( 'EXRExporter.parse: Unsupported first parameter, expected instance of WebGLRenderer or DataTexture.' );
+		} else if ( arg1.isWebGLRenderer || arg1.isWebGPURenderer ) {
+			const renderer = arg1, renderTarget = arg2, options = arg3;
+			supportedRTT( renderTarget );
+			const info = buildInfoRTT( renderTarget, options ),
+				dataBuffer = await getPixelData( renderer, renderTarget, info ),
+				rawContentBuffer = reorganizeDataBuffer( dataBuffer, info ),
+				chunks = compressData( rawContentBuffer, info );
+			return fillData( chunks, info );
+		} else if ( arg1.isDataTexture ) {
+			const texture = arg1, options = arg2;
+			supportedDT( texture );
+			const info = buildInfoDT( texture, options ),
+				dataBuffer = texture.image.data,
+				rawContentBuffer = reorganizeDataBuffer( dataBuffer, info ),
+				chunks = compressData( rawContentBuffer, info );
+			return fillData( chunks, info );
+		}
+	}
+}
+function supportedRTT( renderTarget ) {
+	if ( ! renderTarget || ! renderTarget.isRenderTarget ) {
+		throw Error( 'EXRExporter.parse: Unsupported second parameter, expected instance of WebGLRenderTarget.' );
+	}
+	if ( renderTarget.isWebGLCubeRenderTarget || renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget ) {
+		throw Error( 'EXRExporter.parse: Unsupported render target type, expected instance of WebGLRenderTarget.' );
+	}
+	if ( renderTarget.texture.type !== FloatType && renderTarget.texture.type !== HalfFloatType ) {
+		throw Error( 'EXRExporter.parse: Unsupported WebGLRenderTarget texture type.' );
+	}
+	if ( renderTarget.texture.format !== RGBAFormat ) {
+		throw Error( 'EXRExporter.parse: Unsupported WebGLRenderTarget texture format, expected RGBAFormat.' );
+	}
+}
+function supportedDT( texture ) {
+	if ( texture.type !== FloatType && texture.type !== HalfFloatType ) {
+		throw Error( 'EXRExporter.parse: Unsupported DataTexture texture type.' );
+	}
+	if ( texture.format !== RGBAFormat ) {
+		throw Error( 'EXRExporter.parse: Unsupported DataTexture texture format, expected RGBAFormat.' );
+	}
+	if ( ! texture.image.data ) {
+		throw Error( 'EXRExporter.parse: Invalid DataTexture image data.' );
+	}
+	if ( texture.type === FloatType && texture.image.data.constructor.name !== 'Float32Array' ) {
+		throw Error( 'EXRExporter.parse: DataTexture image data doesn\'t match type, expected \'Float32Array\'.' );
+	}
+	if ( texture.type === HalfFloatType && texture.image.data.constructor.name !== 'Uint16Array' ) {
+		throw Error( 'EXRExporter.parse: DataTexture image data doesn\'t match type, expected \'Uint16Array\'.' );
+	}
+}
+function buildInfoRTT( renderTarget, options = {} ) {
+	const compressionSizes = {
+		0: 1,
+		2: 1,
+		3: 16
+	};
+	const WIDTH = renderTarget.width,
+		HEIGHT = renderTarget.height,
+		TYPE = renderTarget.texture.type,
+		FORMAT = renderTarget.texture.format,
+		COMPRESSION = ( options.compression !== undefined ) ? options.compression : ZIP_COMPRESSION,
+		EXPORTER_TYPE = ( options.type !== undefined ) ? options.type : HalfFloatType,
+		OUT_TYPE = ( EXPORTER_TYPE === FloatType ) ? 2 : 1,
+		COMPRESSION_SIZE = compressionSizes[ COMPRESSION ],
+		NUM_CHANNELS = 4;
+	return {
+		width: WIDTH,
+		height: HEIGHT,
+		type: TYPE,
+		format: FORMAT,
+		compression: COMPRESSION,
+		blockLines: COMPRESSION_SIZE,
+		dataType: OUT_TYPE,
+		dataSize: 2 * OUT_TYPE,
+		numBlocks: Math.ceil( HEIGHT / COMPRESSION_SIZE ),
+		numInputChannels: 4,
+		numOutputChannels: NUM_CHANNELS,
+	};
+}
+function buildInfoDT( texture, options = {} ) {
+	const compressionSizes = {
+		0: 1,
+		2: 1,
+		3: 16
+	};
+	const WIDTH = texture.image.width,
+		HEIGHT = texture.image.height,
+		TYPE = texture.type,
+		FORMAT = texture.format,
+		COMPRESSION = ( options.compression !== undefined ) ? options.compression : ZIP_COMPRESSION,
+		EXPORTER_TYPE = ( options.type !== undefined ) ? options.type : HalfFloatType,
+		OUT_TYPE = ( EXPORTER_TYPE === FloatType ) ? 2 : 1,
+		COMPRESSION_SIZE = compressionSizes[ COMPRESSION ],
+		NUM_CHANNELS = 4;
+	return {
+		width: WIDTH,
+		height: HEIGHT,
+		type: TYPE,
+		format: FORMAT,
+		compression: COMPRESSION,
+		blockLines: COMPRESSION_SIZE,
+		dataType: OUT_TYPE,
+		dataSize: 2 * OUT_TYPE,
+		numBlocks: Math.ceil( HEIGHT / COMPRESSION_SIZE ),
+		numInputChannels: 4,
+		numOutputChannels: NUM_CHANNELS,
+	};
+}
+async function getPixelData( renderer, rtt, info ) {
+	let dataBuffer;
+	if ( renderer.isWebGLRenderer ) {
+		if ( info.type === FloatType ) {
+			dataBuffer = new Float32Array( info.width * info.height * info.numInputChannels );
+		} else {
+			dataBuffer = new Uint16Array( info.width * info.height * info.numInputChannels );
+		}
+		await renderer.readRenderTargetPixelsAsync( rtt, 0, 0, info.width, info.height, dataBuffer );
+	} else {
+		dataBuffer = await renderer.readRenderTargetPixelsAsync( rtt, 0, 0, info.width, info.height );
+	}
+	return dataBuffer;
+}
+function reorganizeDataBuffer( inBuffer, info ) {
+	const w = info.width,
+		h = info.height,
+		dec = { r: 0, g: 0, b: 0, a: 0 },
+		offset = { value: 0 },
+		cOffset = ( info.numOutputChannels == 4 ) ? 1 : 0,
+		getValue = ( info.type == FloatType ) ? getFloat32 : getFloat16,
+		setValue = ( info.dataType == 1 ) ? setFloat16 : setFloat32,
+		outBuffer = new Uint8Array( info.width * info.height * info.numOutputChannels * info.dataSize ),
+		dv = new DataView( outBuffer.buffer );
+	for ( let y = 0; y < h; ++ y ) {
+		for ( let x = 0; x < w; ++ x ) {
+			const i = y * w * 4 + x * 4;
+			const r = getValue( inBuffer, i );
+			const g = getValue( inBuffer, i + 1 );
+			const b = getValue( inBuffer, i + 2 );
+			const a = getValue( inBuffer, i + 3 );
+			const line = ( h - y - 1 ) * w * ( 3 + cOffset ) * info.dataSize;
+			decodeLinear( dec, r, g, b, a );
+			offset.value = line + x * info.dataSize;
+			setValue( dv, dec.a, offset );
+			offset.value = line + ( cOffset ) * w * info.dataSize + x * info.dataSize;
+			setValue( dv, dec.b, offset );
+			offset.value = line + ( 1 + cOffset ) * w * info.dataSize + x * info.dataSize;
+			setValue( dv, dec.g, offset );
+			offset.value = line + ( 2 + cOffset ) * w * info.dataSize + x * info.dataSize;
+			setValue( dv, dec.r, offset );
+		}
+	}
+	return outBuffer;
+}
+function compressData( inBuffer, info ) {
+	let compress,
+		tmpBuffer,
+		sum = 0;
+	const chunks = { data: new Array(), totalSize: 0 },
+		size = info.width * info.numOutputChannels * info.blockLines * info.dataSize;
+	switch ( info.compression ) {
+		case 0:
+			compress = compressNONE;
+			break;
+		case 2:
+		case 3:
+			compress = compressZIP;
+			break;
+	}
+	if ( info.compression !== 0 ) {
+		tmpBuffer = new Uint8Array( size );
+	}
+	for ( let i = 0; i < info.numBlocks; ++ i ) {
+		const arr = inBuffer.subarray( size * i, size * ( i + 1 ) );
+		const block = compress( arr, tmpBuffer );
+		sum += block.length;
+		chunks.data.push( { dataChunk: block, size: block.length } );
+	}
+	chunks.totalSize = sum;
+	return chunks;
+}
+function compressNONE( data ) {
+	return data;
+}
+function compressZIP( data, tmpBuffer ) {
+	//
+	// Reorder the pixel data.
+	//
+	let t1 = 0,
+		t2 = Math.floor( ( data.length + 1 ) / 2 ),
+		s = 0;
+	const stop = data.length - 1;
+	while ( true ) {
+		if ( s > stop ) break;
+		tmpBuffer[ t1 ++ ] = data[ s ++ ];
+		if ( s > stop ) break;
+		tmpBuffer[ t2 ++ ] = data[ s ++ ];
+	}
+	//
+	// Predictor.
+	//
+	let p = tmpBuffer[ 0 ];
+	for ( let t = 1; t < tmpBuffer.length; t ++ ) {
+		const d = tmpBuffer[ t ] - p + ( 128 + 256 );
+		p = tmpBuffer[ t ];
+		tmpBuffer[ t ] = d;
+	}
+	const deflate = fflate.zlibSync( tmpBuffer );
+	return deflate;
+}
+function fillHeader( outBuffer, chunks, info ) {
+	const offset = { value: 0 };
+	const dv = new DataView( outBuffer.buffer );
+	setUint32( dv, 20000630, offset ); // magic
+	setUint32( dv, 2, offset ); // mask
+	// = HEADER =
+	setString( dv, 'compression', offset );
+	setString( dv, 'compression', offset );
+	setUint32( dv, 1, offset );
+	setUint8( dv, info.compression, offset );
+	setString( dv, 'screenWindowCenter', offset );
+	setString( dv, 'v2f', offset );
+	setUint32( dv, 8, offset );
+	setUint32( dv, 0, offset );
+	setUint32( dv, 0, offset );
+	setString( dv, 'screenWindowWidth', offset );
+	setString( dv, 'float', offset );
+	setUint32( dv, 4, offset );
+	setFloat32( dv, 1.0, offset );
+	setString( dv, 'pixelAspectRatio', offset );
+	setString( dv, 'float', offset );
+	setUint32( dv, 4, offset );
+	setFloat32( dv, 1.0, offset );
+	setString( dv, 'lineOrder', offset );
+	setString( dv, 'lineOrder', offset );
+	setUint32( dv, 1, offset );
+	setUint8( dv, 0, offset );
+	setString( dv, 'dataWindow', offset );
+	setString( dv, 'box2i', offset );
+	setUint32( dv, 16, offset );
+	setUint32( dv, 0, offset );
+	setUint32( dv, 0, offset );
+	setUint32( dv, info.width - 1, offset );
+	setUint32( dv, info.height - 1, offset );
+	setString( dv, 'displayWindow', offset );
+	setString( dv, 'box2i', offset );
+	setUint32( dv, 16, offset );
+	setUint32( dv, 0, offset );
+	setUint32( dv, 0, offset );
+	setUint32( dv, info.width - 1, offset );
+	setUint32( dv, info.height - 1, offset );
+	setString( dv, 'channels', offset );
+	setString( dv, 'chlist', offset );
+	setUint32( dv, info.numOutputChannels * 18 + 1, offset );
+	setString( dv, 'A', offset );
+	setUint32( dv, info.dataType, offset );
+	offset.value += 4;
+	setUint32( dv, 1, offset );
+	setUint32( dv, 1, offset );
+	setString( dv, 'B', offset );
+	setUint32( dv, info.dataType, offset );
+	offset.value += 4;
+	setUint32( dv, 1, offset );
+	setUint32( dv, 1, offset );
+	setString( dv, 'G', offset );
+	setUint32( dv, info.dataType, offset );
+	offset.value += 4;
+	setUint32( dv, 1, offset );
+	setUint32( dv, 1, offset );
+	setString( dv, 'R', offset );
+	setUint32( dv, info.dataType, offset );
+	offset.value += 4;
+	setUint32( dv, 1, offset );
+	setUint32( dv, 1, offset );
+	setUint8( dv, 0, offset );
+	// null-byte
+	setUint8( dv, 0, offset );
+	// = OFFSET TABLE =
+	let sum = offset.value + info.numBlocks * 8;
+	for ( let i = 0; i < chunks.data.length; ++ i ) {
+		setUint64( dv, sum, offset );
+		sum += chunks.data[ i ].size + 8;
+	}
+}
+function fillData( chunks, info ) {
+	const TableSize = info.numBlocks * 8,
+		HeaderSize = 259 + ( 18 * info.numOutputChannels ), // 259 + 18 * chlist
+		offset = { value: HeaderSize + TableSize },
+		outBuffer = new Uint8Array( HeaderSize + TableSize + chunks.totalSize + info.numBlocks * 8 ),
+		dv = new DataView( outBuffer.buffer );
+	fillHeader( outBuffer, chunks, info );
+	for ( let i = 0; i < chunks.data.length; ++ i ) {
+		const data = chunks.data[ i ].dataChunk;
+		const size = chunks.data[ i ].size;
+		setUint32( dv, i * info.blockLines, offset );
+		setUint32( dv, size, offset );
+		outBuffer.set( data, offset.value );
+		offset.value += size;
+	}
+	return outBuffer;
+}
+function decodeLinear( dec, r, g, b, a ) {
+	dec.r = r;
+	dec.g = g;
+	dec.b = b;
+	dec.a = a;
+}
+// function decodeSRGB( dec, r, g, b, a ) {
+// 	dec.r = r > 0.04045 ? Math.pow( r * 0.9478672986 + 0.0521327014, 2.4 ) : r * 0.0773993808;
+// 	dec.g = g > 0.04045 ? Math.pow( g * 0.9478672986 + 0.0521327014, 2.4 ) : g * 0.0773993808;
+// 	dec.b = b > 0.04045 ? Math.pow( b * 0.9478672986 + 0.0521327014, 2.4 ) : b * 0.0773993808;
+// 	dec.a = a;
+// }
+function setUint8( dv, value, offset ) {
+	dv.setUint8( offset.value, value );
+	offset.value += 1;
+}
+function setUint32( dv, value, offset ) {
+	dv.setUint32( offset.value, value, true );
+	offset.value += 4;
+}
+function setFloat16( dv, value, offset ) {
+	dv.setUint16( offset.value, DataUtils.toHalfFloat( value ), true );
+	offset.value += 2;
+}
+function setFloat32( dv, value, offset ) {
+	dv.setFloat32( offset.value, value, true );
+	offset.value += 4;
+}
+function setUint64( dv, value, offset ) {
+	dv.setBigUint64( offset.value, BigInt( value ), true );
+	offset.value += 8;
+}
+function setString( dv, string, offset ) {
+	const tmp = textEncoder.encode( string + '\0' );
+	for ( let i = 0; i < tmp.length; ++ i ) {
+		setUint8( dv, tmp[ i ], offset );
+	}
+}
+function decodeFloat16( binary ) {
+	const exponent = ( binary & 0x7C00 ) >> 10,
+		fraction = binary & 0x03FF;
+	return ( binary >> 15 ? - 1 : 1 ) * (
+		exponent ?
+			(
+				exponent === 0x1F ?
+					fraction ? NaN : Infinity :
+					Math.pow( 2, exponent - 15 ) * ( 1 + fraction / 0x400 )
+			) :
+			6.103515625e-5 * ( fraction / 0x400 )
+	);
+}
+function getFloat16( arr, i ) {
+	return decodeFloat16( arr[ i ] );
+}
+function getFloat32( arr, i ) {
+	return arr[ i ];
+}
+export { EXRExporter, NO_COMPRESSION, ZIP_COMPRESSION, ZIPS_COMPRESSION };

libs/three.js/0.172.0/jsm/exporters/GLTFExporter.js ADDED Viewed

	@@ -0,0 +1,3460 @@

+import {
+	BufferAttribute,
+	ClampToEdgeWrapping,
+	Color,
+	DoubleSide,
+	InterpolateDiscrete,
+	InterpolateLinear,
+	NoColorSpace,
+	LinearFilter,
+	LinearMipmapLinearFilter,
+	LinearMipmapNearestFilter,
+	MathUtils,
+	Matrix4,
+	MirroredRepeatWrapping,
+	NearestFilter,
+	NearestMipmapLinearFilter,
+	NearestMipmapNearestFilter,
+	PropertyBinding,
+	RGBAFormat,
+	RepeatWrapping,
+	Scene,
+	Source,
+	SRGBColorSpace,
+	CompressedTexture,
+	Vector3,
+	Quaternion,
+	REVISION
+} from 'three';
+/**
+ * The KHR_mesh_quantization extension allows these extra attribute component types
+ *
+ * @see https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md#extending-mesh-attributes
+ */
+const KHR_mesh_quantization_ExtraAttrTypes = {
+	POSITION: [
+		'byte',
+		'byte normalized',
+		'unsigned byte',
+		'unsigned byte normalized',
+		'short',
+		'short normalized',
+		'unsigned short',
+		'unsigned short normalized',
+	],
+	NORMAL: [
+		'byte normalized',
+		'short normalized',
+	],
+	TANGENT: [
+		'byte normalized',
+		'short normalized',
+	],
+	TEXCOORD: [
+		'byte',
+		'byte normalized',
+		'unsigned byte',
+		'short',
+		'short normalized',
+		'unsigned short',
+	],
+};
+class GLTFExporter {
+	constructor() {
+		this.textureUtils = null;
+		this.pluginCallbacks = [];
+		this.register( function ( writer ) {
+			return new GLTFLightExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsUnlitExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsTransmissionExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsVolumeExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsIorExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsSpecularExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsClearcoatExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsDispersionExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsIridescenceExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsSheenExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsAnisotropyExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsEmissiveStrengthExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMaterialsBumpExtension( writer );
+		} );
+		this.register( function ( writer ) {
+			return new GLTFMeshGpuInstancing( writer );
+		} );
+	}
+	register( callback ) {
+		if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {
+			this.pluginCallbacks.push( callback );
+		}
+		return this;
+	}
+	unregister( callback ) {
+		if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {
+			this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );
+		}
+		return this;
+	}
+	setTextureUtils( utils ) {
+		this.textureUtils = utils;
+		return this;
+	}
+	/**
+	 * Parse scenes and generate GLTF output
+	 *
+	 * @param  {Scene|THREE.Scenes} input   Scene or Array of THREE.Scenes
+	 * @param  {Function} onDone  Callback on completed
+	 * @param  {Function} onError  Callback on errors
+	 * @param  {Object} options options
+	 */
+	parse( input, onDone, onError, options ) {
+		const writer = new GLTFWriter();
+		const plugins = [];
+		for ( let i = 0, il = this.pluginCallbacks.length; i < il; i ++ ) {
+			plugins.push( this.pluginCallbacks[ i ]( writer ) );
+		}
+		writer.setPlugins( plugins );
+		writer.setTextureUtils( this.textureUtils );
+		writer.writeAsync( input, onDone, options ).catch( onError );
+	}
+	parseAsync( input, options ) {
+		const scope = this;
+		return new Promise( function ( resolve, reject ) {
+			scope.parse( input, resolve, reject, options );
+		} );
+	}
+}
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+const WEBGL_CONSTANTS = {
+	POINTS: 0x0000,
+	LINES: 0x0001,
+	LINE_LOOP: 0x0002,
+	LINE_STRIP: 0x0003,
+	TRIANGLES: 0x0004,
+	TRIANGLE_STRIP: 0x0005,
+	TRIANGLE_FAN: 0x0006,
+	BYTE: 0x1400,
+	UNSIGNED_BYTE: 0x1401,
+	SHORT: 0x1402,
+	UNSIGNED_SHORT: 0x1403,
+	INT: 0x1404,
+	UNSIGNED_INT: 0x1405,
+	FLOAT: 0x1406,
+	ARRAY_BUFFER: 0x8892,
+	ELEMENT_ARRAY_BUFFER: 0x8893,
+	NEAREST: 0x2600,
+	LINEAR: 0x2601,
+	NEAREST_MIPMAP_NEAREST: 0x2700,
+	LINEAR_MIPMAP_NEAREST: 0x2701,
+	NEAREST_MIPMAP_LINEAR: 0x2702,
+	LINEAR_MIPMAP_LINEAR: 0x2703,
+	CLAMP_TO_EDGE: 33071,
+	MIRRORED_REPEAT: 33648,
+	REPEAT: 10497
+};
+const KHR_MESH_QUANTIZATION = 'KHR_mesh_quantization';
+const THREE_TO_WEBGL = {};
+THREE_TO_WEBGL[ NearestFilter ] = WEBGL_CONSTANTS.NEAREST;
+THREE_TO_WEBGL[ NearestMipmapNearestFilter ] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+THREE_TO_WEBGL[ NearestMipmapLinearFilter ] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+THREE_TO_WEBGL[ LinearFilter ] = WEBGL_CONSTANTS.LINEAR;
+THREE_TO_WEBGL[ LinearMipmapNearestFilter ] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+THREE_TO_WEBGL[ LinearMipmapLinearFilter ] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+THREE_TO_WEBGL[ ClampToEdgeWrapping ] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+THREE_TO_WEBGL[ RepeatWrapping ] = WEBGL_CONSTANTS.REPEAT;
+THREE_TO_WEBGL[ MirroredRepeatWrapping ] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+const PATH_PROPERTIES = {
+	scale: 'scale',
+	position: 'translation',
+	quaternion: 'rotation',
+	morphTargetInfluences: 'weights'
+};
+const DEFAULT_SPECULAR_COLOR = new Color();
+// GLB constants
+// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
+const GLB_HEADER_BYTES = 12;
+const GLB_HEADER_MAGIC = 0x46546C67;
+const GLB_VERSION = 2;
+const GLB_CHUNK_PREFIX_BYTES = 8;
+const GLB_CHUNK_TYPE_JSON = 0x4E4F534A;
+const GLB_CHUNK_TYPE_BIN = 0x004E4942;
+//------------------------------------------------------------------------------
+// Utility functions
+//------------------------------------------------------------------------------
+/**
+ * Compare two arrays
+ * @param  {Array} array1 Array 1 to compare
+ * @param  {Array} array2 Array 2 to compare
+ * @return {Boolean}        Returns true if both arrays are equal
+ */
+function equalArray( array1, array2 ) {
+	return ( array1.length === array2.length ) && array1.every( function ( element, index ) {
+		return element === array2[ index ];
+	} );
+}
+/**
+ * Converts a string to an ArrayBuffer.
+ * @param  {string} text
+ * @return {ArrayBuffer}
+ */
+function stringToArrayBuffer( text ) {
+	return new TextEncoder().encode( text ).buffer;
+}
+/**
+ * Is identity matrix
+ *
+ * @param {Matrix4} matrix
+ * @returns {Boolean} Returns true, if parameter is identity matrix
+ */
+function isIdentityMatrix( matrix ) {
+	return equalArray( matrix.elements, [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ] );
+}
+/**
+ * Get the min and max vectors from the given attribute
+ * @param  {BufferAttribute} attribute Attribute to find the min/max in range from start to start + count
+ * @param  {Integer} start
+ * @param  {Integer} count
+ * @return {Object} Object containing the `min` and `max` values (As an array of attribute.itemSize components)
+ */
+function getMinMax( attribute, start, count ) {
+	const output = {
+		min: new Array( attribute.itemSize ).fill( Number.POSITIVE_INFINITY ),
+		max: new Array( attribute.itemSize ).fill( Number.NEGATIVE_INFINITY )
+	};
+	for ( let i = start; i < start + count; i ++ ) {
+		for ( let a = 0; a < attribute.itemSize; a ++ ) {
+			let value;
+			if ( attribute.itemSize > 4 ) {
+				 // no support for interleaved data for itemSize > 4
+				value = attribute.array[ i * attribute.itemSize + a ];
+			} else {
+				if ( a === 0 ) value = attribute.getX( i );
+				else if ( a === 1 ) value = attribute.getY( i );
+				else if ( a === 2 ) value = attribute.getZ( i );
+				else if ( a === 3 ) value = attribute.getW( i );
+				if ( attribute.normalized === true ) {
+					value = MathUtils.normalize( value, attribute.array );
+				}
+			}
+			output.min[ a ] = Math.min( output.min[ a ], value );
+			output.max[ a ] = Math.max( output.max[ a ], value );
+		}
+	}
+	return output;
+}
+/**
+ * Get the required size + padding for a buffer, rounded to the next 4-byte boundary.
+ * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
+ *
+ * @param {Integer} bufferSize The size the original buffer.
+ * @returns {Integer} new buffer size with required padding.
+ *
+ */
+function getPaddedBufferSize( bufferSize ) {
+	return Math.ceil( bufferSize / 4 ) * 4;
+}
+/**
+ * Returns a buffer aligned to 4-byte boundary.
+ *
+ * @param {ArrayBuffer} arrayBuffer Buffer to pad
+ * @param {Integer} paddingByte (Optional)
+ * @returns {ArrayBuffer} The same buffer if it's already aligned to 4-byte boundary or a new buffer
+ */
+function getPaddedArrayBuffer( arrayBuffer, paddingByte = 0 ) {
+	const paddedLength = getPaddedBufferSize( arrayBuffer.byteLength );
+	if ( paddedLength !== arrayBuffer.byteLength ) {
+		const array = new Uint8Array( paddedLength );
+		array.set( new Uint8Array( arrayBuffer ) );
+		if ( paddingByte !== 0 ) {
+			for ( let i = arrayBuffer.byteLength; i < paddedLength; i ++ ) {
+				array[ i ] = paddingByte;
+			}
+		}
+		return array.buffer;
+	}
+	return arrayBuffer;
+}
+function getCanvas() {
+	if ( typeof document === 'undefined' && typeof OffscreenCanvas !== 'undefined' ) {
+		return new OffscreenCanvas( 1, 1 );
+	}
+	return document.createElement( 'canvas' );
+}
+function getToBlobPromise( canvas, mimeType ) {
+	if ( canvas.toBlob !== undefined ) {
+		return new Promise( ( resolve ) => canvas.toBlob( resolve, mimeType ) );
+	}
+	let quality;
+	// Blink's implementation of convertToBlob seems to default to a quality level of 100%
+	// Use the Blink default quality levels of toBlob instead so that file sizes are comparable.
+	if ( mimeType === 'image/jpeg' ) {
+		quality = 0.92;
+	} else if ( mimeType === 'image/webp' ) {
+		quality = 0.8;
+	}
+	return canvas.convertToBlob( {
+		type: mimeType,
+		quality: quality
+	} );
+}
+/**
+ * Writer
+ */
+class GLTFWriter {
+	constructor() {
+		this.plugins = [];
+		this.options = {};
+		this.pending = [];
+		this.buffers = [];
+		this.byteOffset = 0;
+		this.buffers = [];
+		this.nodeMap = new Map();
+		this.skins = [];
+		this.extensionsUsed = {};
+		this.extensionsRequired = {};
+		this.uids = new Map();
+		this.uid = 0;
+		this.json = {
+			asset: {
+				version: '2.0',
+				generator: 'THREE.GLTFExporter r' + REVISION
+			}
+		};
+		this.cache = {
+			meshes: new Map(),
+			attributes: new Map(),
+			attributesNormalized: new Map(),
+			materials: new Map(),
+			textures: new Map(),
+			images: new Map()
+		};
+		this.textureUtils = null;
+	}
+	setPlugins( plugins ) {
+		this.plugins = plugins;
+	}
+	setTextureUtils( utils ) {
+		this.textureUtils = utils;
+	}
+	/**
+	 * Parse scenes and generate GLTF output
+	 *
+	 * @param {Scene|THREE.Scenes} input   Scene or Array of THREE.Scenes
+	 * @param {Function} onDone  Callback on completed
+	 * @param {Object} options options
+	 */
+	async writeAsync( input, onDone, options = {} ) {
+		this.options = Object.assign( {
+			// default options
+			binary: false,
+			trs: false,
+			onlyVisible: true,
+			maxTextureSize: Infinity,
+			animations: [],
+			includeCustomExtensions: false
+		}, options );
+		if ( this.options.animations.length > 0 ) {
+			// Only TRS properties, and not matrices, may be targeted by animation.
+			this.options.trs = true;
+		}
+		await this.processInputAsync( input );
+		await Promise.all( this.pending );
+		const writer = this;
+		const buffers = writer.buffers;
+		const json = writer.json;
+		options = writer.options;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionsRequired = writer.extensionsRequired;
+		// Merge buffers.
+		const blob = new Blob( buffers, { type: 'application/octet-stream' } );
+		// Declare extensions.
+		const extensionsUsedList = Object.keys( extensionsUsed );
+		const extensionsRequiredList = Object.keys( extensionsRequired );
+		if ( extensionsUsedList.length > 0 ) json.extensionsUsed = extensionsUsedList;
+		if ( extensionsRequiredList.length > 0 ) json.extensionsRequired = extensionsRequiredList;
+		// Update bytelength of the single buffer.
+		if ( json.buffers && json.buffers.length > 0 ) json.buffers[ 0 ].byteLength = blob.size;
+		if ( options.binary === true ) {
+			// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#glb-file-format-specification
+			const reader = new FileReader();
+			reader.readAsArrayBuffer( blob );
+			reader.onloadend = function () {
+				// Binary chunk.
+				const binaryChunk = getPaddedArrayBuffer( reader.result );
+				const binaryChunkPrefix = new DataView( new ArrayBuffer( GLB_CHUNK_PREFIX_BYTES ) );
+				binaryChunkPrefix.setUint32( 0, binaryChunk.byteLength, true );
+				binaryChunkPrefix.setUint32( 4, GLB_CHUNK_TYPE_BIN, true );
+				// JSON chunk.
+				const jsonChunk = getPaddedArrayBuffer( stringToArrayBuffer( JSON.stringify( json ) ), 0x20 );
+				const jsonChunkPrefix = new DataView( new ArrayBuffer( GLB_CHUNK_PREFIX_BYTES ) );
+				jsonChunkPrefix.setUint32( 0, jsonChunk.byteLength, true );
+				jsonChunkPrefix.setUint32( 4, GLB_CHUNK_TYPE_JSON, true );
+				// GLB header.
+				const header = new ArrayBuffer( GLB_HEADER_BYTES );
+				const headerView = new DataView( header );
+				headerView.setUint32( 0, GLB_HEADER_MAGIC, true );
+				headerView.setUint32( 4, GLB_VERSION, true );
+				const totalByteLength = GLB_HEADER_BYTES
+					+ jsonChunkPrefix.byteLength + jsonChunk.byteLength
+					+ binaryChunkPrefix.byteLength + binaryChunk.byteLength;
+				headerView.setUint32( 8, totalByteLength, true );
+				const glbBlob = new Blob( [
+					header,
+					jsonChunkPrefix,
+					jsonChunk,
+					binaryChunkPrefix,
+					binaryChunk
+				], { type: 'application/octet-stream' } );
+				const glbReader = new FileReader();
+				glbReader.readAsArrayBuffer( glbBlob );
+				glbReader.onloadend = function () {
+					onDone( glbReader.result );
+				};
+			};
+		} else {
+			if ( json.buffers && json.buffers.length > 0 ) {
+				const reader = new FileReader();
+				reader.readAsDataURL( blob );
+				reader.onloadend = function () {
+					const base64data = reader.result;
+					json.buffers[ 0 ].uri = base64data;
+					onDone( json );
+				};
+			} else {
+				onDone( json );
+			}
+		}
+	}
+	/**
+	 * Serializes a userData.
+	 *
+	 * @param {THREE.Object3D|THREE.Material} object
+	 * @param {Object} objectDef
+	 */
+	serializeUserData( object, objectDef ) {
+		if ( Object.keys( object.userData ).length === 0 ) return;
+		const options = this.options;
+		const extensionsUsed = this.extensionsUsed;
+		try {
+			const json = JSON.parse( JSON.stringify( object.userData ) );
+			if ( options.includeCustomExtensions && json.gltfExtensions ) {
+				if ( objectDef.extensions === undefined ) objectDef.extensions = {};
+				for ( const extensionName in json.gltfExtensions ) {
+					objectDef.extensions[ extensionName ] = json.gltfExtensions[ extensionName ];
+					extensionsUsed[ extensionName ] = true;
+				}
+				delete json.gltfExtensions;
+			}
+			if ( Object.keys( json ).length > 0 ) objectDef.extras = json;
+		} catch ( error ) {
+			console.warn( 'THREE.GLTFExporter: userData of \'' + object.name + '\' ' +
+				'won\'t be serialized because of JSON.stringify error - ' + error.message );
+		}
+	}
+	/**
+	 * Returns ids for buffer attributes.
+	 *
+	 * @param  {Object} attribute
+	 * @param {boolean} [isRelativeCopy=false]
+	 * @return {Integer}
+	 */
+	getUID( attribute, isRelativeCopy = false ) {
+		if ( this.uids.has( attribute ) === false ) {
+			const uids = new Map();
+			uids.set( true, this.uid ++ );
+			uids.set( false, this.uid ++ );
+			this.uids.set( attribute, uids );
+		}
+		const uids = this.uids.get( attribute );
+		return uids.get( isRelativeCopy );
+	}
+	/**
+	 * Checks if normal attribute values are normalized.
+	 *
+	 * @param {BufferAttribute} normal
+	 * @returns {Boolean}
+	 */
+	isNormalizedNormalAttribute( normal ) {
+		const cache = this.cache;
+		if ( cache.attributesNormalized.has( normal ) ) return false;
+		const v = new Vector3();
+		for ( let i = 0, il = normal.count; i < il; i ++ ) {
+			// 0.0005 is from glTF-validator
+			if ( Math.abs( v.fromBufferAttribute( normal, i ).length() - 1.0 ) > 0.0005 ) return false;
+		}
+		return true;
+	}
+	/**
+	 * Creates normalized normal buffer attribute.
+	 *
+	 * @param {BufferAttribute} normal
+	 * @returns {BufferAttribute}
+	 *
+	 */
+	createNormalizedNormalAttribute( normal ) {
+		const cache = this.cache;
+		if ( cache.attributesNormalized.has( normal ) )	return cache.attributesNormalized.get( normal );
+		const attribute = normal.clone();
+		const v = new Vector3();
+		for ( let i = 0, il = attribute.count; i < il; i ++ ) {
+			v.fromBufferAttribute( attribute, i );
+			if ( v.x === 0 && v.y === 0 && v.z === 0 ) {
+				// if values can't be normalized set (1, 0, 0)
+				v.setX( 1.0 );
+			} else {
+				v.normalize();
+			}
+			attribute.setXYZ( i, v.x, v.y, v.z );
+		}
+		cache.attributesNormalized.set( normal, attribute );
+		return attribute;
+	}
+	/**
+	 * Applies a texture transform, if present, to the map definition. Requires
+	 * the KHR_texture_transform extension.
+	 *
+	 * @param {Object} mapDef
+	 * @param {THREE.Texture} texture
+	 */
+	applyTextureTransform( mapDef, texture ) {
+		let didTransform = false;
+		const transformDef = {};
+		if ( texture.offset.x !== 0 || texture.offset.y !== 0 ) {
+			transformDef.offset = texture.offset.toArray();
+			didTransform = true;
+		}
+		if ( texture.rotation !== 0 ) {
+			transformDef.rotation = texture.rotation;
+			didTransform = true;
+		}
+		if ( texture.repeat.x !== 1 || texture.repeat.y !== 1 ) {
+			transformDef.scale = texture.repeat.toArray();
+			didTransform = true;
+		}
+		if ( didTransform ) {
+			mapDef.extensions = mapDef.extensions || {};
+			mapDef.extensions[ 'KHR_texture_transform' ] = transformDef;
+			this.extensionsUsed[ 'KHR_texture_transform' ] = true;
+		}
+	}
+	async buildMetalRoughTextureAsync( metalnessMap, roughnessMap ) {
+		if ( metalnessMap === roughnessMap ) return metalnessMap;
+		function getEncodingConversion( map ) {
+			if ( map.colorSpace === SRGBColorSpace ) {
+				return function SRGBToLinear( c ) {
+					return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );
+				};
+			}
+			return function LinearToLinear( c ) {
+				return c;
+			};
+		}
+		if ( metalnessMap instanceof CompressedTexture ) {
+			metalnessMap = await this.decompressTextureAsync( metalnessMap );
+		}
+		if ( roughnessMap instanceof CompressedTexture ) {
+			roughnessMap = await this.decompressTextureAsync( roughnessMap );
+		}
+		const metalness = metalnessMap ? metalnessMap.image : null;
+		const roughness = roughnessMap ? roughnessMap.image : null;
+		const width = Math.max( metalness ? metalness.width : 0, roughness ? roughness.width : 0 );
+		const height = Math.max( metalness ? metalness.height : 0, roughness ? roughness.height : 0 );
+		const canvas = getCanvas();
+		canvas.width = width;
+		canvas.height = height;
+		const context = canvas.getContext( '2d', {
+			willReadFrequently: true,
+		} );
+		context.fillStyle = '#00ffff';
+		context.fillRect( 0, 0, width, height );
+		const composite = context.getImageData( 0, 0, width, height );
+		if ( metalness ) {
+			context.drawImage( metalness, 0, 0, width, height );
+			const convert = getEncodingConversion( metalnessMap );
+			const data = context.getImageData( 0, 0, width, height ).data;
+			for ( let i = 2; i < data.length; i += 4 ) {
+				composite.data[ i ] = convert( data[ i ] / 256 ) * 256;
+			}
+		}
+		if ( roughness ) {
+			context.drawImage( roughness, 0, 0, width, height );
+			const convert = getEncodingConversion( roughnessMap );
+			const data = context.getImageData( 0, 0, width, height ).data;
+			for ( let i = 1; i < data.length; i += 4 ) {
+				composite.data[ i ] = convert( data[ i ] / 256 ) * 256;
+			}
+		}
+		context.putImageData( composite, 0, 0 );
+		//
+		const reference = metalnessMap || roughnessMap;
+		const texture = reference.clone();
+		texture.source = new Source( canvas );
+		texture.colorSpace = NoColorSpace;
+		texture.channel = ( metalnessMap || roughnessMap ).channel;
+		if ( metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel ) {
+			console.warn( 'THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.' );
+		}
+		console.warn( 'THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.' );
+		return texture;
+	}
+	async decompressTextureAsync( texture, maxTextureSize = Infinity ) {
+		if ( this.textureUtils === null ) {
+			throw new Error( 'THREE.GLTFExporter: setTextureUtils() must be called to process compressed textures.' );
+		}
+		return await this.textureUtils.decompress( texture, maxTextureSize );
+	}
+	/**
+	 * Process a buffer to append to the default one.
+	 * @param  {ArrayBuffer} buffer
+	 * @return {Integer}
+	 */
+	processBuffer( buffer ) {
+		const json = this.json;
+		const buffers = this.buffers;
+		if ( ! json.buffers ) json.buffers = [ { byteLength: 0 } ];
+		// All buffers are merged before export.
+		buffers.push( buffer );
+		return 0;
+	}
+	/**
+	 * Process and generate a BufferView
+	 * @param  {BufferAttribute} attribute
+	 * @param  {number} componentType
+	 * @param  {number} start
+	 * @param  {number} count
+	 * @param  {number} target (Optional) Target usage of the BufferView
+	 * @return {Object}
+	 */
+	processBufferView( attribute, componentType, start, count, target ) {
+		const json = this.json;
+		if ( ! json.bufferViews ) json.bufferViews = [];
+		// Create a new dataview and dump the attribute's array into it
+		let componentSize;
+		switch ( componentType ) {
+			case WEBGL_CONSTANTS.BYTE:
+			case WEBGL_CONSTANTS.UNSIGNED_BYTE:
+				componentSize = 1;
+				break;
+			case WEBGL_CONSTANTS.SHORT:
+			case WEBGL_CONSTANTS.UNSIGNED_SHORT:
+				componentSize = 2;
+				break;
+			default:
+				componentSize = 4;
+		}
+		let byteStride = attribute.itemSize * componentSize;
+		if ( target === WEBGL_CONSTANTS.ARRAY_BUFFER ) {
+			// Each element of a vertex attribute MUST be aligned to 4-byte boundaries
+			// inside a bufferView
+			byteStride = Math.ceil( byteStride / 4 ) * 4;
+		}
+		const byteLength = getPaddedBufferSize( count * byteStride );
+		const dataView = new DataView( new ArrayBuffer( byteLength ) );
+		let offset = 0;
+		for ( let i = start; i < start + count; i ++ ) {
+			for ( let a = 0; a < attribute.itemSize; a ++ ) {
+				let value;
+				if ( attribute.itemSize > 4 ) {
+					 // no support for interleaved data for itemSize > 4
+					value = attribute.array[ i * attribute.itemSize + a ];
+				} else {
+					if ( a === 0 ) value = attribute.getX( i );
+					else if ( a === 1 ) value = attribute.getY( i );
+					else if ( a === 2 ) value = attribute.getZ( i );
+					else if ( a === 3 ) value = attribute.getW( i );
+					if ( attribute.normalized === true ) {
+						value = MathUtils.normalize( value, attribute.array );
+					}
+				}
+				if ( componentType === WEBGL_CONSTANTS.FLOAT ) {
+					dataView.setFloat32( offset, value, true );
+				} else if ( componentType === WEBGL_CONSTANTS.INT ) {
+					dataView.setInt32( offset, value, true );
+				} else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_INT ) {
+					dataView.setUint32( offset, value, true );
+				} else if ( componentType === WEBGL_CONSTANTS.SHORT ) {
+					dataView.setInt16( offset, value, true );
+				} else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT ) {
+					dataView.setUint16( offset, value, true );
+				} else if ( componentType === WEBGL_CONSTANTS.BYTE ) {
+					dataView.setInt8( offset, value );
+				} else if ( componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE ) {
+					dataView.setUint8( offset, value );
+				}
+				offset += componentSize;
+			}
+			if ( ( offset % byteStride ) !== 0 ) {
+				offset += byteStride - ( offset % byteStride );
+			}
+		}
+		const bufferViewDef = {
+			buffer: this.processBuffer( dataView.buffer ),
+			byteOffset: this.byteOffset,
+			byteLength: byteLength
+		};
+		if ( target !== undefined ) bufferViewDef.target = target;
+		if ( target === WEBGL_CONSTANTS.ARRAY_BUFFER ) {
+			// Only define byteStride for vertex attributes.
+			bufferViewDef.byteStride = byteStride;
+		}
+		this.byteOffset += byteLength;
+		json.bufferViews.push( bufferViewDef );
+		// @TODO Merge bufferViews where possible.
+		const output = {
+			id: json.bufferViews.length - 1,
+			byteLength: 0
+		};
+		return output;
+	}
+	/**
+	 * Process and generate a BufferView from an image Blob.
+	 * @param {Blob} blob
+	 * @return {Promise<Integer>}
+	 */
+	processBufferViewImage( blob ) {
+		const writer = this;
+		const json = writer.json;
+		if ( ! json.bufferViews ) json.bufferViews = [];
+		return new Promise( function ( resolve ) {
+			const reader = new FileReader();
+			reader.readAsArrayBuffer( blob );
+			reader.onloadend = function () {
+				const buffer = getPaddedArrayBuffer( reader.result );
+				const bufferViewDef = {
+					buffer: writer.processBuffer( buffer ),
+					byteOffset: writer.byteOffset,
+					byteLength: buffer.byteLength
+				};
+				writer.byteOffset += buffer.byteLength;
+				resolve( json.bufferViews.push( bufferViewDef ) - 1 );
+			};
+		} );
+	}
+	/**
+	 * Process attribute to generate an accessor
+	 * @param  {BufferAttribute} attribute Attribute to process
+	 * @param  {THREE.BufferGeometry} geometry (Optional) Geometry used for truncated draw range
+	 * @param  {Integer} start (Optional)
+	 * @param  {Integer} count (Optional)
+	 * @return {Integer|null} Index of the processed accessor on the "accessors" array
+	 */
+	processAccessor( attribute, geometry, start, count ) {
+		const json = this.json;
+		const types = {
+			1: 'SCALAR',
+			2: 'VEC2',
+			3: 'VEC3',
+			4: 'VEC4',
+			9: 'MAT3',
+			16: 'MAT4'
+		};
+		let componentType;
+		// Detect the component type of the attribute array
+		if ( attribute.array.constructor === Float32Array ) {
+			componentType = WEBGL_CONSTANTS.FLOAT;
+		} else if ( attribute.array.constructor === Int32Array ) {
+			componentType = WEBGL_CONSTANTS.INT;
+		} else if ( attribute.array.constructor === Uint32Array ) {
+			componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
+		} else if ( attribute.array.constructor === Int16Array ) {
+			componentType = WEBGL_CONSTANTS.SHORT;
+		} else if ( attribute.array.constructor === Uint16Array ) {
+			componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
+		} else if ( attribute.array.constructor === Int8Array ) {
+			componentType = WEBGL_CONSTANTS.BYTE;
+		} else if ( attribute.array.constructor === Uint8Array ) {
+			componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
+		} else {
+			throw new Error( 'THREE.GLTFExporter: Unsupported bufferAttribute component type: ' + attribute.array.constructor.name );
+		}
+		if ( start === undefined ) start = 0;
+		if ( count === undefined || count === Infinity ) count = attribute.count;
+		// Skip creating an accessor if the attribute doesn't have data to export
+		if ( count === 0 ) return null;
+		const minMax = getMinMax( attribute, start, count );
+		let bufferViewTarget;
+		// If geometry isn't provided, don't infer the target usage of the bufferView. For
+		// animation samplers, target must not be set.
+		if ( geometry !== undefined ) {
+			bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
+		}
+		const bufferView = this.processBufferView( attribute, componentType, start, count, bufferViewTarget );
+		const accessorDef = {
+			bufferView: bufferView.id,
+			byteOffset: bufferView.byteOffset,
+			componentType: componentType,
+			count: count,
+			max: minMax.max,
+			min: minMax.min,
+			type: types[ attribute.itemSize ]
+		};
+		if ( attribute.normalized === true ) accessorDef.normalized = true;
+		if ( ! json.accessors ) json.accessors = [];
+		return json.accessors.push( accessorDef ) - 1;
+	}
+	/**
+	 * Process image
+	 * @param  {Image} image to process
+	 * @param  {Integer} format of the image (RGBAFormat)
+	 * @param  {Boolean} flipY before writing out the image
+	 * @param  {String} mimeType export format
+	 * @return {Integer}     Index of the processed texture in the "images" array
+	 */
+	processImage( image, format, flipY, mimeType = 'image/png' ) {
+		if ( image !== null ) {
+			const writer = this;
+			const cache = writer.cache;
+			const json = writer.json;
+			const options = writer.options;
+			const pending = writer.pending;
+			if ( ! cache.images.has( image ) ) cache.images.set( image, {} );
+			const cachedImages = cache.images.get( image );
+			const key = mimeType + ':flipY/' + flipY.toString();
+			if ( cachedImages[ key ] !== undefined ) return cachedImages[ key ];
+			if ( ! json.images ) json.images = [];
+			const imageDef = { mimeType: mimeType };
+			const canvas = getCanvas();
+			canvas.width = Math.min( image.width, options.maxTextureSize );
+			canvas.height = Math.min( image.height, options.maxTextureSize );
+			const ctx = canvas.getContext( '2d', {
+				willReadFrequently: true,
+			} );
+			if ( flipY === true ) {
+				ctx.translate( 0, canvas.height );
+				ctx.scale( 1, - 1 );
+			}
+			if ( image.data !== undefined ) { // THREE.DataTexture
+				if ( format !== RGBAFormat ) {
+					console.error( 'GLTFExporter: Only RGBAFormat is supported.', format );
+				}
+				if ( image.width > options.maxTextureSize || image.height > options.maxTextureSize ) {
+					console.warn( 'GLTFExporter: Image size is bigger than maxTextureSize', image );
+				}
+				const data = new Uint8ClampedArray( image.height * image.width * 4 );
+				for ( let i = 0; i < data.length; i += 4 ) {
+					data[ i + 0 ] = image.data[ i + 0 ];
+					data[ i + 1 ] = image.data[ i + 1 ];
+					data[ i + 2 ] = image.data[ i + 2 ];
+					data[ i + 3 ] = image.data[ i + 3 ];
+				}
+				ctx.putImageData( new ImageData( data, image.width, image.height ), 0, 0 );
+			} else {
+				if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
+					( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
+					( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ||
+					( typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas ) ) {
+					ctx.drawImage( image, 0, 0, canvas.width, canvas.height );
+				} else {
+					throw new Error( 'THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.' );
+				}
+			}
+			if ( options.binary === true ) {
+				pending.push(
+					getToBlobPromise( canvas, mimeType )
+						.then( blob => writer.processBufferViewImage( blob ) )
+						.then( bufferViewIndex => {
+							imageDef.bufferView = bufferViewIndex;
+						} )
+				);
+			} else {
+				if ( canvas.toDataURL !== undefined ) {
+					imageDef.uri = canvas.toDataURL( mimeType );
+				} else {
+					pending.push(
+						getToBlobPromise( canvas, mimeType )
+							.then( blob => new FileReader().readAsDataURL( blob ) )
+							.then( dataURL => {
+								imageDef.uri = dataURL;
+							} )
+					);
+				}
+			}
+			const index = json.images.push( imageDef ) - 1;
+			cachedImages[ key ] = index;
+			return index;
+		} else {
+			throw new Error( 'THREE.GLTFExporter: No valid image data found. Unable to process texture.' );
+		}
+	}
+	/**
+	 * Process sampler
+	 * @param  {Texture} map Texture to process
+	 * @return {Integer}     Index of the processed texture in the "samplers" array
+	 */
+	processSampler( map ) {
+		const json = this.json;
+		if ( ! json.samplers ) json.samplers = [];
+		const samplerDef = {
+			magFilter: THREE_TO_WEBGL[ map.magFilter ],
+			minFilter: THREE_TO_WEBGL[ map.minFilter ],
+			wrapS: THREE_TO_WEBGL[ map.wrapS ],
+			wrapT: THREE_TO_WEBGL[ map.wrapT ]
+		};
+		return json.samplers.push( samplerDef ) - 1;
+	}
+	/**
+	 * Process texture
+	 * @param  {Texture} map Map to process
+	 * @return {Integer} Index of the processed texture in the "textures" array
+	 */
+	async processTextureAsync( map ) {
+		const writer = this;
+		const options = writer.options;
+		const cache = this.cache;
+		const json = this.json;
+		if ( cache.textures.has( map ) ) return cache.textures.get( map );
+		if ( ! json.textures ) json.textures = [];
+		// make non-readable textures (e.g. CompressedTexture) readable by blitting them into a new texture
+		if ( map instanceof CompressedTexture ) {
+			map = await this.decompressTextureAsync( map, options.maxTextureSize );
+		}
+		let mimeType = map.userData.mimeType;
+		if ( mimeType === 'image/webp' ) mimeType = 'image/png';
+		const textureDef = {
+			sampler: this.processSampler( map ),
+			source: this.processImage( map.image, map.format, map.flipY, mimeType )
+		};
+		if ( map.name ) textureDef.name = map.name;
+		await this._invokeAllAsync( async function ( ext ) {
+			ext.writeTexture && await ext.writeTexture( map, textureDef );
+		} );
+		const index = json.textures.push( textureDef ) - 1;
+		cache.textures.set( map, index );
+		return index;
+	}
+	/**
+	 * Process material
+	 * @param  {THREE.Material} material Material to process
+	 * @return {Integer|null} Index of the processed material in the "materials" array
+	 */
+	async processMaterialAsync( material ) {
+		const cache = this.cache;
+		const json = this.json;
+		if ( cache.materials.has( material ) ) return cache.materials.get( material );
+		if ( material.isShaderMaterial ) {
+			console.warn( 'GLTFExporter: THREE.ShaderMaterial not supported.' );
+			return null;
+		}
+		if ( ! json.materials ) json.materials = [];
+		// @QUESTION Should we avoid including any attribute that has the default value?
+		const materialDef = {	pbrMetallicRoughness: {} };
+		if ( material.isMeshStandardMaterial !== true && material.isMeshBasicMaterial !== true ) {
+			console.warn( 'GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.' );
+		}
+		// pbrMetallicRoughness.baseColorFactor
+		const color = material.color.toArray().concat( [ material.opacity ] );
+		if ( ! equalArray( color, [ 1, 1, 1, 1 ] ) ) {
+			materialDef.pbrMetallicRoughness.baseColorFactor = color;
+		}
+		if ( material.isMeshStandardMaterial ) {
+			materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
+			materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
+		} else {
+			materialDef.pbrMetallicRoughness.metallicFactor = 0;
+			materialDef.pbrMetallicRoughness.roughnessFactor = 1;
+		}
+		// pbrMetallicRoughness.metallicRoughnessTexture
+		if ( material.metalnessMap || material.roughnessMap ) {
+			const metalRoughTexture = await this.buildMetalRoughTextureAsync( material.metalnessMap, material.roughnessMap );
+			const metalRoughMapDef = {
+				index: await this.processTextureAsync( metalRoughTexture ),
+				texCoord: metalRoughTexture.channel
+			};
+			this.applyTextureTransform( metalRoughMapDef, metalRoughTexture );
+			materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
+		}
+		// pbrMetallicRoughness.baseColorTexture
+		if ( material.map ) {
+			const baseColorMapDef = {
+				index: await this.processTextureAsync( material.map ),
+				texCoord: material.map.channel
+			};
+			this.applyTextureTransform( baseColorMapDef, material.map );
+			materialDef.pbrMetallicRoughness.baseColorTexture = baseColorMapDef;
+		}
+		if ( material.emissive ) {
+			const emissive = material.emissive;
+			const maxEmissiveComponent = Math.max( emissive.r, emissive.g, emissive.b );
+			if ( maxEmissiveComponent > 0 ) {
+				materialDef.emissiveFactor = material.emissive.toArray();
+			}
+			// emissiveTexture
+			if ( material.emissiveMap ) {
+				const emissiveMapDef = {
+					index: await this.processTextureAsync( material.emissiveMap ),
+					texCoord: material.emissiveMap.channel
+				};
+				this.applyTextureTransform( emissiveMapDef, material.emissiveMap );
+				materialDef.emissiveTexture = emissiveMapDef;
+			}
+		}
+		// normalTexture
+		if ( material.normalMap ) {
+			const normalMapDef = {
+				index: await this.processTextureAsync( material.normalMap ),
+				texCoord: material.normalMap.channel
+			};
+			if ( material.normalScale && material.normalScale.x !== 1 ) {
+				// glTF normal scale is univariate. Ignore `y`, which may be flipped.
+				// Context: https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
+				normalMapDef.scale = material.normalScale.x;
+			}
+			this.applyTextureTransform( normalMapDef, material.normalMap );
+			materialDef.normalTexture = normalMapDef;
+		}
+		// occlusionTexture
+		if ( material.aoMap ) {
+			const occlusionMapDef = {
+				index: await this.processTextureAsync( material.aoMap ),
+				texCoord: material.aoMap.channel
+			};
+			if ( material.aoMapIntensity !== 1.0 ) {
+				occlusionMapDef.strength = material.aoMapIntensity;
+			}
+			this.applyTextureTransform( occlusionMapDef, material.aoMap );
+			materialDef.occlusionTexture = occlusionMapDef;
+		}
+		// alphaMode
+		if ( material.transparent ) {
+			materialDef.alphaMode = 'BLEND';
+		} else {
+			if ( material.alphaTest > 0.0 ) {
+				materialDef.alphaMode = 'MASK';
+				materialDef.alphaCutoff = material.alphaTest;
+			}
+		}
+		// doubleSided
+		if ( material.side === DoubleSide ) materialDef.doubleSided = true;
+		if ( material.name !== '' ) materialDef.name = material.name;
+		this.serializeUserData( material, materialDef );
+		await this._invokeAllAsync( async function ( ext ) {
+			ext.writeMaterialAsync && await ext.writeMaterialAsync( material, materialDef );
+		} );
+		const index = json.materials.push( materialDef ) - 1;
+		cache.materials.set( material, index );
+		return index;
+	}
+	/**
+	 * Process mesh
+	 * @param  {THREE.Mesh} mesh Mesh to process
+	 * @return {Integer|null} Index of the processed mesh in the "meshes" array
+	 */
+	async processMeshAsync( mesh ) {
+		const cache = this.cache;
+		const json = this.json;
+		const meshCacheKeyParts = [ mesh.geometry.uuid ];
+		if ( Array.isArray( mesh.material ) ) {
+			for ( let i = 0, l = mesh.material.length; i < l; i ++ ) {
+				meshCacheKeyParts.push( mesh.material[ i ].uuid	);
+			}
+		} else {
+			meshCacheKeyParts.push( mesh.material.uuid );
+		}
+		const meshCacheKey = meshCacheKeyParts.join( ':' );
+		if ( cache.meshes.has( meshCacheKey ) ) return cache.meshes.get( meshCacheKey );
+		const geometry = mesh.geometry;
+		let mode;
+		// Use the correct mode
+		if ( mesh.isLineSegments ) {
+			mode = WEBGL_CONSTANTS.LINES;
+		} else if ( mesh.isLineLoop ) {
+			mode = WEBGL_CONSTANTS.LINE_LOOP;
+		} else if ( mesh.isLine ) {
+			mode = WEBGL_CONSTANTS.LINE_STRIP;
+		} else if ( mesh.isPoints ) {
+			mode = WEBGL_CONSTANTS.POINTS;
+		} else {
+			mode = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
+		}
+		const meshDef = {};
+		const attributes = {};
+		const primitives = [];
+		const targets = [];
+		// Conversion between attributes names in threejs and gltf spec
+		const nameConversion = {
+			uv: 'TEXCOORD_0',
+			uv1: 'TEXCOORD_1',
+			uv2: 'TEXCOORD_2',
+			uv3: 'TEXCOORD_3',
+			color: 'COLOR_0',
+			skinWeight: 'WEIGHTS_0',
+			skinIndex: 'JOINTS_0'
+		};
+		const originalNormal = geometry.getAttribute( 'normal' );
+		if ( originalNormal !== undefined && ! this.isNormalizedNormalAttribute( originalNormal ) ) {
+			console.warn( 'THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.' );
+			geometry.setAttribute( 'normal', this.createNormalizedNormalAttribute( originalNormal ) );
+		}
+		// @QUESTION Detect if .vertexColors = true?
+		// For every attribute create an accessor
+		let modifiedAttribute = null;
+		for ( let attributeName in geometry.attributes ) {
+			// Ignore morph target attributes, which are exported later.
+			if ( attributeName.slice( 0, 5 ) === 'morph' ) continue;
+			const attribute = geometry.attributes[ attributeName ];
+			attributeName = nameConversion[ attributeName ] || attributeName.toUpperCase();
+			// Prefix all geometry attributes except the ones specifically
+			// listed in the spec; non-spec attributes are considered custom.
+			const validVertexAttributes =
+					/^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/;
+			if ( ! validVertexAttributes.test( attributeName ) ) attributeName = '_' + attributeName;
+			if ( cache.attributes.has( this.getUID( attribute ) ) ) {
+				attributes[ attributeName ] = cache.attributes.get( this.getUID( attribute ) );
+				continue;
+			}
+			// Enforce glTF vertex attribute requirements:
+			// - JOINTS_0 must be UNSIGNED_BYTE or UNSIGNED_SHORT
+			// - Only custom attributes may be INT or UNSIGNED_INT
+			modifiedAttribute = null;
+			const array = attribute.array;
+			if ( attributeName === 'JOINTS_0' &&
+				! ( array instanceof Uint16Array ) &&
+				! ( array instanceof Uint8Array ) ) {
+				console.warn( 'GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.' );
+				modifiedAttribute = new BufferAttribute( new Uint16Array( array ), attribute.itemSize, attribute.normalized );
+			} else if ( ( array instanceof Uint32Array || array instanceof Int32Array ) && ! attributeName.startsWith( '_' ) ) {
+				console.warn( `GLTFExporter: Attribute "${ attributeName }" converted to type FLOAT.` );
+				modifiedAttribute = GLTFExporter.Utils.toFloat32BufferAttribute( attribute );
+			}
+			const accessor = this.processAccessor( modifiedAttribute || attribute, geometry );
+			if ( accessor !== null ) {
+				if ( ! attributeName.startsWith( '_' ) ) {
+					this.detectMeshQuantization( attributeName, attribute );
+				}
+				attributes[ attributeName ] = accessor;
+				cache.attributes.set( this.getUID( attribute ), accessor );
+			}
+		}
+		if ( originalNormal !== undefined ) geometry.setAttribute( 'normal', originalNormal );
+		// Skip if no exportable attributes found
+		if ( Object.keys( attributes ).length === 0 ) return null;
+		// Morph targets
+		if ( mesh.morphTargetInfluences !== undefined && mesh.morphTargetInfluences.length > 0 ) {
+			const weights = [];
+			const targetNames = [];
+			const reverseDictionary = {};
+			if ( mesh.morphTargetDictionary !== undefined ) {
+				for ( const key in mesh.morphTargetDictionary ) {
+					reverseDictionary[ mesh.morphTargetDictionary[ key ] ] = key;
+				}
+			}
+			for ( let i = 0; i < mesh.morphTargetInfluences.length; ++ i ) {
+				const target = {};
+				let warned = false;
+				for ( const attributeName in geometry.morphAttributes ) {
+					// glTF 2.0 morph supports only POSITION/NORMAL/TANGENT.
+					// Three.js doesn't support TANGENT yet.
+					if ( attributeName !== 'position' && attributeName !== 'normal' ) {
+						if ( ! warned ) {
+							console.warn( 'GLTFExporter: Only POSITION and NORMAL morph are supported.' );
+							warned = true;
+						}
+						continue;
+					}
+					const attribute = geometry.morphAttributes[ attributeName ][ i ];
+					const gltfAttributeName = attributeName.toUpperCase();
+					// Three.js morph attribute has absolute values while the one of glTF has relative values.
+					//
+					// glTF 2.0 Specification:
+					// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#morph-targets
+					const baseAttribute = geometry.attributes[ attributeName ];
+					if ( cache.attributes.has( this.getUID( attribute, true ) ) ) {
+						target[ gltfAttributeName ] = cache.attributes.get( this.getUID( attribute, true ) );
+						continue;
+					}
+					// Clones attribute not to override
+					const relativeAttribute = attribute.clone();
+					if ( ! geometry.morphTargetsRelative ) {
+						for ( let j = 0, jl = attribute.count; j < jl; j ++ ) {
+							for ( let a = 0; a < attribute.itemSize; a ++ ) {
+								if ( a === 0 ) relativeAttribute.setX( j, attribute.getX( j ) - baseAttribute.getX( j ) );
+								if ( a === 1 ) relativeAttribute.setY( j, attribute.getY( j ) - baseAttribute.getY( j ) );
+								if ( a === 2 ) relativeAttribute.setZ( j, attribute.getZ( j ) - baseAttribute.getZ( j ) );
+								if ( a === 3 ) relativeAttribute.setW( j, attribute.getW( j ) - baseAttribute.getW( j ) );
+							}
+						}
+					}
+					target[ gltfAttributeName ] = this.processAccessor( relativeAttribute, geometry );
+					cache.attributes.set( this.getUID( baseAttribute, true ), target[ gltfAttributeName ] );
+				}
+				targets.push( target );
+				weights.push( mesh.morphTargetInfluences[ i ] );
+				if ( mesh.morphTargetDictionary !== undefined ) targetNames.push( reverseDictionary[ i ] );
+			}
+			meshDef.weights = weights;
+			if ( targetNames.length > 0 ) {
+				meshDef.extras = {};
+				meshDef.extras.targetNames = targetNames;
+			}
+		}
+		const isMultiMaterial = Array.isArray( mesh.material );
+		if ( isMultiMaterial && geometry.groups.length === 0 ) return null;
+		let didForceIndices = false;
+		if ( isMultiMaterial && geometry.index === null ) {
+			const indices = [];
+			for ( let i = 0, il = geometry.attributes.position.count; i < il; i ++ ) {
+				indices[ i ] = i;
+			}
+			geometry.setIndex( indices );
+			didForceIndices = true;
+		}
+		const materials = isMultiMaterial ? mesh.material : [ mesh.material ];
+		const groups = isMultiMaterial ? geometry.groups : [ { materialIndex: 0, start: undefined, count: undefined } ];
+		for ( let i = 0, il = groups.length; i < il; i ++ ) {
+			const primitive = {
+				mode: mode,
+				attributes: attributes,
+			};
+			this.serializeUserData( geometry, primitive );
+			if ( targets.length > 0 ) primitive.targets = targets;
+			if ( geometry.index !== null ) {
+				let cacheKey = this.getUID( geometry.index );
+				if ( groups[ i ].start !== undefined || groups[ i ].count !== undefined ) {
+					cacheKey += ':' + groups[ i ].start + ':' + groups[ i ].count;
+				}
+				if ( cache.attributes.has( cacheKey ) ) {
+					primitive.indices = cache.attributes.get( cacheKey );
+				} else {
+					primitive.indices = this.processAccessor( geometry.index, geometry, groups[ i ].start, groups[ i ].count );
+					cache.attributes.set( cacheKey, primitive.indices );
+				}
+				if ( primitive.indices === null ) delete primitive.indices;
+			}
+			const material = await this.processMaterialAsync( materials[ groups[ i ].materialIndex ] );
+			if ( material !== null ) primitive.material = material;
+			primitives.push( primitive );
+		}
+		if ( didForceIndices === true ) {
+			geometry.setIndex( null );
+		}
+		meshDef.primitives = primitives;
+		if ( ! json.meshes ) json.meshes = [];
+		await this._invokeAllAsync( function ( ext ) {
+			ext.writeMesh && ext.writeMesh( mesh, meshDef );
+		} );
+		const index = json.meshes.push( meshDef ) - 1;
+		cache.meshes.set( meshCacheKey, index );
+		return index;
+	}
+	/**
+	 * If a vertex attribute with a
+	 * [non-standard data type](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview)
+	 * is used, it is checked whether it is a valid data type according to the
+	 * [KHR_mesh_quantization](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)
+	 * extension.
+	 * In this case the extension is automatically added to the list of used extensions.
+	 *
+	 * @param {string} attributeName
+	 * @param {THREE.BufferAttribute} attribute
+	 */
+	detectMeshQuantization( attributeName, attribute ) {
+		if ( this.extensionsUsed[ KHR_MESH_QUANTIZATION ] ) return;
+		let attrType = undefined;
+		switch ( attribute.array.constructor ) {
+			case Int8Array:
+				attrType = 'byte';
+				break;
+			case Uint8Array:
+				attrType = 'unsigned byte';
+				break;
+			case Int16Array:
+				attrType = 'short';
+				break;
+			case Uint16Array:
+				attrType = 'unsigned short';
+				break;
+			default:
+				return;
+		}
+		if ( attribute.normalized ) attrType += ' normalized';
+		const attrNamePrefix = attributeName.split( '_', 1 )[ 0 ];
+		if ( KHR_mesh_quantization_ExtraAttrTypes[ attrNamePrefix ] && KHR_mesh_quantization_ExtraAttrTypes[ attrNamePrefix ].includes( attrType ) ) {
+			this.extensionsUsed[ KHR_MESH_QUANTIZATION ] = true;
+			this.extensionsRequired[ KHR_MESH_QUANTIZATION ] = true;
+		}
+	}
+	/**
+	 * Process camera
+	 * @param  {THREE.Camera} camera Camera to process
+	 * @return {Integer}      Index of the processed mesh in the "camera" array
+	 */
+	processCamera( camera ) {
+		const json = this.json;
+		if ( ! json.cameras ) json.cameras = [];
+		const isOrtho = camera.isOrthographicCamera;
+		const cameraDef = {
+			type: isOrtho ? 'orthographic' : 'perspective'
+		};
+		if ( isOrtho ) {
+			cameraDef.orthographic = {
+				xmag: camera.right * 2,
+				ymag: camera.top * 2,
+				zfar: camera.far <= 0 ? 0.001 : camera.far,
+				znear: camera.near < 0 ? 0 : camera.near
+			};
+		} else {
+			cameraDef.perspective = {
+				aspectRatio: camera.aspect,
+				yfov: MathUtils.degToRad( camera.fov ),
+				zfar: camera.far <= 0 ? 0.001 : camera.far,
+				znear: camera.near < 0 ? 0 : camera.near
+			};
+		}
+		// Question: Is saving "type" as name intentional?
+		if ( camera.name !== '' ) cameraDef.name = camera.type;
+		return json.cameras.push( cameraDef ) - 1;
+	}
+	/**
+	 * Creates glTF animation entry from AnimationClip object.
+	 *
+	 * Status:
+	 * - Only properties listed in PATH_PROPERTIES may be animated.
+	 *
+	 * @param {THREE.AnimationClip} clip
+	 * @param {THREE.Object3D} root
+	 * @return {number|null}
+	 */
+	processAnimation( clip, root ) {
+		const json = this.json;
+		const nodeMap = this.nodeMap;
+		if ( ! json.animations ) json.animations = [];
+		clip = GLTFExporter.Utils.mergeMorphTargetTracks( clip.clone(), root );
+		const tracks = clip.tracks;
+		const channels = [];
+		const samplers = [];
+		for ( let i = 0; i < tracks.length; ++ i ) {
+			const track = tracks[ i ];
+			const trackBinding = PropertyBinding.parseTrackName( track.name );
+			let trackNode = PropertyBinding.findNode( root, trackBinding.nodeName );
+			const trackProperty = PATH_PROPERTIES[ trackBinding.propertyName ];
+			if ( trackBinding.objectName === 'bones' ) {
+				if ( trackNode.isSkinnedMesh === true ) {
+					trackNode = trackNode.skeleton.getBoneByName( trackBinding.objectIndex );
+				} else {
+					trackNode = undefined;
+				}
+			}
+			if ( ! trackNode || ! trackProperty ) {
+				console.warn( 'THREE.GLTFExporter: Could not export animation track "%s".', track.name );
+				continue;
+			}
+			const inputItemSize = 1;
+			let outputItemSize = track.values.length / track.times.length;
+			if ( trackProperty === PATH_PROPERTIES.morphTargetInfluences ) {
+				outputItemSize /= trackNode.morphTargetInfluences.length;
+			}
+			let interpolation;
+			// @TODO export CubicInterpolant(InterpolateSmooth) as CUBICSPLINE
+			// Detecting glTF cubic spline interpolant by checking factory method's special property
+			// GLTFCubicSplineInterpolant is a custom interpolant and track doesn't return
+			// valid value from .getInterpolation().
+			if ( track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true ) {
+				interpolation = 'CUBICSPLINE';
+				// itemSize of CUBICSPLINE keyframe is 9
+				// (VEC3 * 3: inTangent, splineVertex, and outTangent)
+				// but needs to be stored as VEC3 so dividing by 3 here.
+				outputItemSize /= 3;
+			} else if ( track.getInterpolation() === InterpolateDiscrete ) {
+				interpolation = 'STEP';
+			} else {
+				interpolation = 'LINEAR';
+			}
+			samplers.push( {
+				input: this.processAccessor( new BufferAttribute( track.times, inputItemSize ) ),
+				output: this.processAccessor( new BufferAttribute( track.values, outputItemSize ) ),
+				interpolation: interpolation
+			} );
+			channels.push( {
+				sampler: samplers.length - 1,
+				target: {
+					node: nodeMap.get( trackNode ),
+					path: trackProperty
+				}
+			} );
+		}
+		json.animations.push( {
+			name: clip.name || 'clip_' + json.animations.length,
+			samplers: samplers,
+			channels: channels
+		} );
+		return json.animations.length - 1;
+	}
+	/**
+	 * @param {THREE.Object3D} object
+	 * @return {number|null}
+	 */
+	 processSkin( object ) {
+		const json = this.json;
+		const nodeMap = this.nodeMap;
+		const node = json.nodes[ nodeMap.get( object ) ];
+		const skeleton = object.skeleton;
+		if ( skeleton === undefined ) return null;
+		const rootJoint = object.skeleton.bones[ 0 ];
+		if ( rootJoint === undefined ) return null;
+		const joints = [];
+		const inverseBindMatrices = new Float32Array( skeleton.bones.length * 16 );
+		const temporaryBoneInverse = new Matrix4();
+		for ( let i = 0; i < skeleton.bones.length; ++ i ) {
+			joints.push( nodeMap.get( skeleton.bones[ i ] ) );
+			temporaryBoneInverse.copy( skeleton.boneInverses[ i ] );
+			temporaryBoneInverse.multiply( object.bindMatrix ).toArray( inverseBindMatrices, i * 16 );
+		}
+		if ( json.skins === undefined ) json.skins = [];
+		json.skins.push( {
+			inverseBindMatrices: this.processAccessor( new BufferAttribute( inverseBindMatrices, 16 ) ),
+			joints: joints,
+			skeleton: nodeMap.get( rootJoint )
+		} );
+		const skinIndex = node.skin = json.skins.length - 1;
+		return skinIndex;
+	}
+	/**
+	 * Process Object3D node
+	 * @param  {THREE.Object3D} object Object3D to processNodeAsync
+	 * @return {Integer} Index of the node in the nodes list
+	 */
+	async processNodeAsync( object ) {
+		const json = this.json;
+		const options = this.options;
+		const nodeMap = this.nodeMap;
+		if ( ! json.nodes ) json.nodes = [];
+		const nodeDef = {};
+		if ( options.trs ) {
+			const rotation = object.quaternion.toArray();
+			const position = object.position.toArray();
+			const scale = object.scale.toArray();
+			if ( ! equalArray( rotation, [ 0, 0, 0, 1 ] ) ) {
+				nodeDef.rotation = rotation;
+			}
+			if ( ! equalArray( position, [ 0, 0, 0 ] ) ) {
+				nodeDef.translation = position;
+			}
+			if ( ! equalArray( scale, [ 1, 1, 1 ] ) ) {
+				nodeDef.scale = scale;
+			}
+		} else {
+			if ( object.matrixAutoUpdate ) {
+				object.updateMatrix();
+			}
+			if ( isIdentityMatrix( object.matrix ) === false ) {
+				nodeDef.matrix = object.matrix.elements;
+			}
+		}
+		// We don't export empty strings name because it represents no-name in Three.js.
+		if ( object.name !== '' ) nodeDef.name = String( object.name );
+		this.serializeUserData( object, nodeDef );
+		if ( object.isMesh || object.isLine || object.isPoints ) {
+			const meshIndex = await this.processMeshAsync( object );
+			if ( meshIndex !== null ) nodeDef.mesh = meshIndex;
+		} else if ( object.isCamera ) {
+			nodeDef.camera = this.processCamera( object );
+		}
+		if ( object.isSkinnedMesh ) this.skins.push( object );
+		if ( object.children.length > 0 ) {
+			const children = [];
+			for ( let i = 0, l = object.children.length; i < l; i ++ ) {
+				const child = object.children[ i ];
+				if ( child.visible || options.onlyVisible === false ) {
+					const nodeIndex = await this.processNodeAsync( child );
+					if ( nodeIndex !== null ) children.push( nodeIndex );
+				}
+			}
+			if ( children.length > 0 ) nodeDef.children = children;
+		}
+		await this._invokeAllAsync( function ( ext ) {
+			ext.writeNode && ext.writeNode( object, nodeDef );
+		} );
+		const nodeIndex = json.nodes.push( nodeDef ) - 1;
+		nodeMap.set( object, nodeIndex );
+		return nodeIndex;
+	}
+	/**
+	 * Process Scene
+	 * @param  {Scene} scene Scene to process
+	 */
+	async processSceneAsync( scene ) {
+		const json = this.json;
+		const options = this.options;
+		if ( ! json.scenes ) {
+			json.scenes = [];
+			json.scene = 0;
+		}
+		const sceneDef = {};
+		if ( scene.name !== '' ) sceneDef.name = scene.name;
+		json.scenes.push( sceneDef );
+		const nodes = [];
+		for ( let i = 0, l = scene.children.length; i < l; i ++ ) {
+			const child = scene.children[ i ];
+			if ( child.visible || options.onlyVisible === false ) {
+				const nodeIndex = await this.processNodeAsync( child );
+				if ( nodeIndex !== null ) nodes.push( nodeIndex );
+			}
+		}
+		if ( nodes.length > 0 ) sceneDef.nodes = nodes;
+		this.serializeUserData( scene, sceneDef );
+	}
+	/**
+	 * Creates a Scene to hold a list of objects and parse it
+	 * @param  {Array} objects List of objects to process
+	 */
+	async processObjectsAsync( objects ) {
+		const scene = new Scene();
+		scene.name = 'AuxScene';
+		for ( let i = 0; i < objects.length; i ++ ) {
+			// We push directly to children instead of calling `add` to prevent
+			// modify the .parent and break its original scene and hierarchy
+			scene.children.push( objects[ i ] );
+		}
+		await this.processSceneAsync( scene );
+	}
+	/**
+	 * @param {THREE.Object3D|Array<THREE.Object3D>} input
+	 */
+	async processInputAsync( input ) {
+		const options = this.options;
+		input = input instanceof Array ? input : [ input ];
+		await this._invokeAllAsync( function ( ext ) {
+			ext.beforeParse && ext.beforeParse( input );
+		} );
+		const objectsWithoutScene = [];
+		for ( let i = 0; i < input.length; i ++ ) {
+			if ( input[ i ] instanceof Scene ) {
+				await this.processSceneAsync( input[ i ] );
+			} else {
+				objectsWithoutScene.push( input[ i ] );
+			}
+		}
+		if ( objectsWithoutScene.length > 0 ) {
+			await this.processObjectsAsync( objectsWithoutScene );
+		}
+		for ( let i = 0; i < this.skins.length; ++ i ) {
+			this.processSkin( this.skins[ i ] );
+		}
+		for ( let i = 0; i < options.animations.length; ++ i ) {
+			this.processAnimation( options.animations[ i ], input[ 0 ] );
+		}
+		await this._invokeAllAsync( function ( ext ) {
+			ext.afterParse && ext.afterParse( input );
+		} );
+	}
+	async _invokeAllAsync( func ) {
+		for ( let i = 0, il = this.plugins.length; i < il; i ++ ) {
+			await func( this.plugins[ i ] );
+		}
+	}
+}
+/**
+ * Punctual Lights Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+ */
+class GLTFLightExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_lights_punctual';
+	}
+	writeNode( light, nodeDef ) {
+		if ( ! light.isLight ) return;
+		if ( ! light.isDirectionalLight && ! light.isPointLight && ! light.isSpotLight ) {
+			console.warn( 'THREE.GLTFExporter: Only directional, point, and spot lights are supported.', light );
+			return;
+		}
+		const writer = this.writer;
+		const json = writer.json;
+		const extensionsUsed = writer.extensionsUsed;
+		const lightDef = {};
+		if ( light.name ) lightDef.name = light.name;
+		lightDef.color = light.color.toArray();
+		lightDef.intensity = light.intensity;
+		if ( light.isDirectionalLight ) {
+			lightDef.type = 'directional';
+		} else if ( light.isPointLight ) {
+			lightDef.type = 'point';
+			if ( light.distance > 0 ) lightDef.range = light.distance;
+		} else if ( light.isSpotLight ) {
+			lightDef.type = 'spot';
+			if ( light.distance > 0 ) lightDef.range = light.distance;
+			lightDef.spot = {};
+			lightDef.spot.innerConeAngle = ( 1.0 - light.penumbra ) * light.angle;
+			lightDef.spot.outerConeAngle = light.angle;
+		}
+		if ( light.decay !== undefined && light.decay !== 2 ) {
+			console.warn( 'THREE.GLTFExporter: Light decay may be lost. glTF is physically-based, '
+				+ 'and expects light.decay=2.' );
+		}
+		if ( light.target
+				&& ( light.target.parent !== light
+				|| light.target.position.x !== 0
+				|| light.target.position.y !== 0
+				|| light.target.position.z !== - 1 ) ) {
+			console.warn( 'THREE.GLTFExporter: Light direction may be lost. For best results, '
+				+ 'make light.target a child of the light with position 0,0,-1.' );
+		}
+		if ( ! extensionsUsed[ this.name ] ) {
+			json.extensions = json.extensions || {};
+			json.extensions[ this.name ] = { lights: [] };
+			extensionsUsed[ this.name ] = true;
+		}
+		const lights = json.extensions[ this.name ].lights;
+		lights.push( lightDef );
+		nodeDef.extensions = nodeDef.extensions || {};
+		nodeDef.extensions[ this.name ] = { light: lights.length - 1 };
+	}
+}
+/**
+ * Unlit Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
+ */
+class GLTFMaterialsUnlitExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_unlit';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshBasicMaterial ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = {};
+		extensionsUsed[ this.name ] = true;
+		materialDef.pbrMetallicRoughness.metallicFactor = 0.0;
+		materialDef.pbrMetallicRoughness.roughnessFactor = 0.9;
+	}
+}
+/**
+ * Clearcoat Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
+ */
+class GLTFMaterialsClearcoatExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_clearcoat';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.clearcoat === 0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.clearcoatFactor = material.clearcoat;
+		if ( material.clearcoatMap ) {
+			const clearcoatMapDef = {
+				index: await writer.processTextureAsync( material.clearcoatMap ),
+				texCoord: material.clearcoatMap.channel
+			};
+			writer.applyTextureTransform( clearcoatMapDef, material.clearcoatMap );
+			extensionDef.clearcoatTexture = clearcoatMapDef;
+		}
+		extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
+		if ( material.clearcoatRoughnessMap ) {
+			const clearcoatRoughnessMapDef = {
+				index: await writer.processTextureAsync( material.clearcoatRoughnessMap ),
+				texCoord: material.clearcoatRoughnessMap.channel
+			};
+			writer.applyTextureTransform( clearcoatRoughnessMapDef, material.clearcoatRoughnessMap );
+			extensionDef.clearcoatRoughnessTexture = clearcoatRoughnessMapDef;
+		}
+		if ( material.clearcoatNormalMap ) {
+			const clearcoatNormalMapDef = {
+				index: await writer.processTextureAsync( material.clearcoatNormalMap ),
+				texCoord: material.clearcoatNormalMap.channel
+			};
+			if ( material.clearcoatNormalScale.x !== 1 ) clearcoatNormalMapDef.scale = material.clearcoatNormalScale.x;
+			writer.applyTextureTransform( clearcoatNormalMapDef, material.clearcoatNormalMap );
+			extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
+		}
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Materials dispersion Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_dispersion
+ */
+class GLTFMaterialsDispersionExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_dispersion';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.dispersion === 0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.dispersion = material.dispersion;
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Iridescence Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence
+ */
+class GLTFMaterialsIridescenceExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_iridescence';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.iridescence === 0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.iridescenceFactor = material.iridescence;
+		if ( material.iridescenceMap ) {
+			const iridescenceMapDef = {
+				index: await writer.processTextureAsync( material.iridescenceMap ),
+				texCoord: material.iridescenceMap.channel
+			};
+			writer.applyTextureTransform( iridescenceMapDef, material.iridescenceMap );
+			extensionDef.iridescenceTexture = iridescenceMapDef;
+		}
+		extensionDef.iridescenceIor = material.iridescenceIOR;
+		extensionDef.iridescenceThicknessMinimum = material.iridescenceThicknessRange[ 0 ];
+		extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[ 1 ];
+		if ( material.iridescenceThicknessMap ) {
+			const iridescenceThicknessMapDef = {
+				index: await writer.processTextureAsync( material.iridescenceThicknessMap ),
+				texCoord: material.iridescenceThicknessMap.channel
+			};
+			writer.applyTextureTransform( iridescenceThicknessMapDef, material.iridescenceThicknessMap );
+			extensionDef.iridescenceThicknessTexture = iridescenceThicknessMapDef;
+		}
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Transmission Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
+ */
+class GLTFMaterialsTransmissionExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_transmission';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.transmission === 0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.transmissionFactor = material.transmission;
+		if ( material.transmissionMap ) {
+			const transmissionMapDef = {
+				index: await writer.processTextureAsync( material.transmissionMap ),
+				texCoord: material.transmissionMap.channel
+			};
+			writer.applyTextureTransform( transmissionMapDef, material.transmissionMap );
+			extensionDef.transmissionTexture = transmissionMapDef;
+		}
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Materials Volume Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume
+ */
+class GLTFMaterialsVolumeExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_volume';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.transmission === 0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.thicknessFactor = material.thickness;
+		if ( material.thicknessMap ) {
+			const thicknessMapDef = {
+				index: await writer.processTextureAsync( material.thicknessMap ),
+				texCoord: material.thicknessMap.channel
+			};
+			writer.applyTextureTransform( thicknessMapDef, material.thicknessMap );
+			extensionDef.thicknessTexture = thicknessMapDef;
+		}
+		if ( material.attenuationDistance !== Infinity ) {
+			extensionDef.attenuationDistance = material.attenuationDistance;
+		}
+		extensionDef.attenuationColor = material.attenuationColor.toArray();
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Materials ior Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior
+ */
+class GLTFMaterialsIorExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_ior';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.ior === 1.5 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.ior = material.ior;
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Materials specular Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular
+ */
+class GLTFMaterialsSpecularExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_specular';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || ( material.specularIntensity === 1.0 &&
+		       material.specularColor.equals( DEFAULT_SPECULAR_COLOR ) &&
+		     ! material.specularIntensityMap && ! material.specularColorMap ) ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		if ( material.specularIntensityMap ) {
+			const specularIntensityMapDef = {
+				index: await writer.processTextureAsync( material.specularIntensityMap ),
+				texCoord: material.specularIntensityMap.channel
+			};
+			writer.applyTextureTransform( specularIntensityMapDef, material.specularIntensityMap );
+			extensionDef.specularTexture = specularIntensityMapDef;
+		}
+		if ( material.specularColorMap ) {
+			const specularColorMapDef = {
+				index: await writer.processTextureAsync( material.specularColorMap ),
+				texCoord: material.specularColorMap.channel
+			};
+			writer.applyTextureTransform( specularColorMapDef, material.specularColorMap );
+			extensionDef.specularColorTexture = specularColorMapDef;
+		}
+		extensionDef.specularFactor = material.specularIntensity;
+		extensionDef.specularColorFactor = material.specularColor.toArray();
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Sheen Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
+ */
+class GLTFMaterialsSheenExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_sheen';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.sheen == 0.0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		if ( material.sheenRoughnessMap ) {
+			const sheenRoughnessMapDef = {
+				index: await writer.processTextureAsync( material.sheenRoughnessMap ),
+				texCoord: material.sheenRoughnessMap.channel
+			};
+			writer.applyTextureTransform( sheenRoughnessMapDef, material.sheenRoughnessMap );
+			extensionDef.sheenRoughnessTexture = sheenRoughnessMapDef;
+		}
+		if ( material.sheenColorMap ) {
+			const sheenColorMapDef = {
+				index: await writer.processTextureAsync( material.sheenColorMap ),
+				texCoord: material.sheenColorMap.channel
+			};
+			writer.applyTextureTransform( sheenColorMapDef, material.sheenColorMap );
+			extensionDef.sheenColorTexture = sheenColorMapDef;
+		}
+		extensionDef.sheenRoughnessFactor = material.sheenRoughness;
+		extensionDef.sheenColorFactor = material.sheenColor.toArray();
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Anisotropy Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_anisotropy
+ */
+class GLTFMaterialsAnisotropyExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_anisotropy';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshPhysicalMaterial || material.anisotropy == 0.0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		if ( material.anisotropyMap ) {
+			const anisotropyMapDef = { index: await writer.processTextureAsync( material.anisotropyMap ) };
+			writer.applyTextureTransform( anisotropyMapDef, material.anisotropyMap );
+			extensionDef.anisotropyTexture = anisotropyMapDef;
+		}
+		extensionDef.anisotropyStrength = material.anisotropy;
+		extensionDef.anisotropyRotation = material.anisotropyRotation;
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Materials Emissive Strength Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md
+ */
+class GLTFMaterialsEmissiveStrengthExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'KHR_materials_emissive_strength';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshStandardMaterial || material.emissiveIntensity === 1.0 ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		extensionDef.emissiveStrength = material.emissiveIntensity;
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * Materials bump Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump
+ */
+class GLTFMaterialsBumpExtension {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'EXT_materials_bump';
+	}
+	async writeMaterialAsync( material, materialDef ) {
+		if ( ! material.isMeshStandardMaterial || (
+		       material.bumpScale === 1 &&
+		     ! material.bumpMap ) ) return;
+		const writer = this.writer;
+		const extensionsUsed = writer.extensionsUsed;
+		const extensionDef = {};
+		if ( material.bumpMap ) {
+			const bumpMapDef = {
+				index: await writer.processTextureAsync( material.bumpMap ),
+				texCoord: material.bumpMap.channel
+			};
+			writer.applyTextureTransform( bumpMapDef, material.bumpMap );
+			extensionDef.bumpTexture = bumpMapDef;
+		}
+		extensionDef.bumpFactor = material.bumpScale;
+		materialDef.extensions = materialDef.extensions || {};
+		materialDef.extensions[ this.name ] = extensionDef;
+		extensionsUsed[ this.name ] = true;
+	}
+}
+/**
+ * GPU Instancing Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing
+ */
+class GLTFMeshGpuInstancing {
+	constructor( writer ) {
+		this.writer = writer;
+		this.name = 'EXT_mesh_gpu_instancing';
+	}
+	writeNode( object, nodeDef ) {
+		if ( ! object.isInstancedMesh ) return;
+		const writer = this.writer;
+		const mesh = object;
+		const translationAttr = new Float32Array( mesh.count * 3 );
+		const rotationAttr = new Float32Array( mesh.count * 4 );
+		const scaleAttr = new Float32Array( mesh.count * 3 );
+		const matrix = new Matrix4();
+		const position = new Vector3();
+		const quaternion = new Quaternion();
+		const scale = new Vector3();
+		for ( let i = 0; i < mesh.count; i ++ ) {
+			mesh.getMatrixAt( i, matrix );
+			matrix.decompose( position, quaternion, scale );
+			position.toArray( translationAttr, i * 3 );
+			quaternion.toArray( rotationAttr, i * 4 );
+			scale.toArray( scaleAttr, i * 3 );
+		}
+		const attributes = {
+			TRANSLATION: writer.processAccessor( new BufferAttribute( translationAttr, 3 ) ),
+			ROTATION: writer.processAccessor( new BufferAttribute( rotationAttr, 4 ) ),
+			SCALE: writer.processAccessor( new BufferAttribute( scaleAttr, 3 ) ),
+		};
+		if ( mesh.instanceColor )
+			attributes._COLOR_0 = writer.processAccessor( mesh.instanceColor );
+		nodeDef.extensions = nodeDef.extensions || {};
+		nodeDef.extensions[ this.name ] = { attributes };
+		writer.extensionsUsed[ this.name ] = true;
+		writer.extensionsRequired[ this.name ] = true;
+	}
+}
+/**
+ * Static utility functions
+ */
+GLTFExporter.Utils = {
+	insertKeyframe: function ( track, time ) {
+		const tolerance = 0.001; // 1ms
+		const valueSize = track.getValueSize();
+		const times = new track.TimeBufferType( track.times.length + 1 );
+		const values = new track.ValueBufferType( track.values.length + valueSize );
+		const interpolant = track.createInterpolant( new track.ValueBufferType( valueSize ) );
+		let index;
+		if ( track.times.length === 0 ) {
+			times[ 0 ] = time;
+			for ( let i = 0; i < valueSize; i ++ ) {
+				values[ i ] = 0;
+			}
+			index = 0;
+		} else if ( time < track.times[ 0 ] ) {
+			if ( Math.abs( track.times[ 0 ] - time ) < tolerance ) return 0;
+			times[ 0 ] = time;
+			times.set( track.times, 1 );
+			values.set( interpolant.evaluate( time ), 0 );
+			values.set( track.values, valueSize );
+			index = 0;
+		} else if ( time > track.times[ track.times.length - 1 ] ) {
+			if ( Math.abs( track.times[ track.times.length - 1 ] - time ) < tolerance ) {
+				return track.times.length - 1;
+			}
+			times[ times.length - 1 ] = time;
+			times.set( track.times, 0 );
+			values.set( track.values, 0 );
+			values.set( interpolant.evaluate( time ), track.values.length );
+			index = times.length - 1;
+		} else {
+			for ( let i = 0; i < track.times.length; i ++ ) {
+				if ( Math.abs( track.times[ i ] - time ) < tolerance ) return i;
+				if ( track.times[ i ] < time && track.times[ i + 1 ] > time ) {
+					times.set( track.times.slice( 0, i + 1 ), 0 );
+					times[ i + 1 ] = time;
+					times.set( track.times.slice( i + 1 ), i + 2 );
+					values.set( track.values.slice( 0, ( i + 1 ) * valueSize ), 0 );
+					values.set( interpolant.evaluate( time ), ( i + 1 ) * valueSize );
+					values.set( track.values.slice( ( i + 1 ) * valueSize ), ( i + 2 ) * valueSize );
+					index = i + 1;
+					break;
+				}
+			}
+		}
+		track.times = times;
+		track.values = values;
+		return index;
+	},
+	mergeMorphTargetTracks: function ( clip, root ) {
+		const tracks = [];
+		const mergedTracks = {};
+		const sourceTracks = clip.tracks;
+		for ( let i = 0; i < sourceTracks.length; ++ i ) {
+			let sourceTrack = sourceTracks[ i ];
+			const sourceTrackBinding = PropertyBinding.parseTrackName( sourceTrack.name );
+			const sourceTrackNode = PropertyBinding.findNode( root, sourceTrackBinding.nodeName );
+			if ( sourceTrackBinding.propertyName !== 'morphTargetInfluences' || sourceTrackBinding.propertyIndex === undefined ) {
+				// Tracks that don't affect morph targets, or that affect all morph targets together, can be left as-is.
+				tracks.push( sourceTrack );
+				continue;
+			}
+			if ( sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete
+				&& sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear ) {
+				if ( sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {
+					// This should never happen, because glTF morph target animations
+					// affect all targets already.
+					throw new Error( 'THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.' );
+				}
+				console.warn( 'THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.' );
+				sourceTrack = sourceTrack.clone();
+				sourceTrack.setInterpolation( InterpolateLinear );
+			}
+			const targetCount = sourceTrackNode.morphTargetInfluences.length;
+			const targetIndex = sourceTrackNode.morphTargetDictionary[ sourceTrackBinding.propertyIndex ];
+			if ( targetIndex === undefined ) {
+				throw new Error( 'THREE.GLTFExporter: Morph target name not found: ' + sourceTrackBinding.propertyIndex );
+			}
+			let mergedTrack;
+			// If this is the first time we've seen this object, create a new
+			// track to store merged keyframe data for each morph target.
+			if ( mergedTracks[ sourceTrackNode.uuid ] === undefined ) {
+				mergedTrack = sourceTrack.clone();
+				const values = new mergedTrack.ValueBufferType( targetCount * mergedTrack.times.length );
+				for ( let j = 0; j < mergedTrack.times.length; j ++ ) {
+					values[ j * targetCount + targetIndex ] = mergedTrack.values[ j ];
+				}
+				// We need to take into consideration the intended target node
+				// of our original un-merged morphTarget animation.
+				mergedTrack.name = ( sourceTrackBinding.nodeName || '' ) + '.morphTargetInfluences';
+				mergedTrack.values = values;
+				mergedTracks[ sourceTrackNode.uuid ] = mergedTrack;
+				tracks.push( mergedTrack );
+				continue;
+			}
+			const sourceInterpolant = sourceTrack.createInterpolant( new sourceTrack.ValueBufferType( 1 ) );
+			mergedTrack = mergedTracks[ sourceTrackNode.uuid ];
+			// For every existing keyframe of the merged track, write a (possibly
+			// interpolated) value from the source track.
+			for ( let j = 0; j < mergedTrack.times.length; j ++ ) {
+				mergedTrack.values[ j * targetCount + targetIndex ] = sourceInterpolant.evaluate( mergedTrack.times[ j ] );
+			}
+			// For every existing keyframe of the source track, write a (possibly
+			// new) keyframe to the merged track. Values from the previous loop may
+			// be written again, but keyframes are de-duplicated.
+			for ( let j = 0; j < sourceTrack.times.length; j ++ ) {
+				const keyframeIndex = this.insertKeyframe( mergedTrack, sourceTrack.times[ j ] );
+				mergedTrack.values[ keyframeIndex * targetCount + targetIndex ] = sourceTrack.values[ j ];
+			}
+		}
+		clip.tracks = tracks;
+		return clip;
+	},
+	toFloat32BufferAttribute: function ( srcAttribute ) {
+		const dstAttribute = new BufferAttribute( new Float32Array( srcAttribute.count * srcAttribute.itemSize ), srcAttribute.itemSize, false );
+		if ( ! srcAttribute.normalized && ! srcAttribute.isInterleavedBufferAttribute ) {
+			dstAttribute.array.set( srcAttribute.array );
+			return dstAttribute;
+		}
+		for ( let i = 0, il = srcAttribute.count; i < il; i ++ ) {
+			for ( let j = 0; j < srcAttribute.itemSize; j ++ ) {
+				dstAttribute.setComponent( i, j, srcAttribute.getComponent( i, j ) );
+			}
+		}
+		return dstAttribute;
+	}
+};
+export { GLTFExporter };

libs/three.js/0.172.0/jsm/exporters/KTX2Exporter.js ADDED Viewed

	@@ -0,0 +1,323 @@

+import {
+	ColorManagement,
+	FloatType,
+	HalfFloatType,
+	UnsignedByteType,
+	RGBAFormat,
+	RGFormat,
+	RGIntegerFormat,
+	RedFormat,
+	RedIntegerFormat,
+	NoColorSpace,
+	LinearSRGBColorSpace,
+	SRGBColorSpace,
+	SRGBTransfer,
+	DataTexture,
+	REVISION,
+} from 'three';
+import {
+	write,
+	KTX2Container,
+	KHR_DF_CHANNEL_RGBSDA_ALPHA,
+	KHR_DF_CHANNEL_RGBSDA_BLUE,
+	KHR_DF_CHANNEL_RGBSDA_GREEN,
+	KHR_DF_CHANNEL_RGBSDA_RED,
+	KHR_DF_MODEL_RGBSDA,
+	KHR_DF_PRIMARIES_BT709,
+	KHR_DF_PRIMARIES_UNSPECIFIED,
+	KHR_DF_SAMPLE_DATATYPE_FLOAT,
+	KHR_DF_SAMPLE_DATATYPE_LINEAR,
+	KHR_DF_SAMPLE_DATATYPE_SIGNED,
+	KHR_DF_TRANSFER_LINEAR,
+	KHR_DF_TRANSFER_SRGB,
+	VK_FORMAT_R16_SFLOAT,
+	VK_FORMAT_R16G16_SFLOAT,
+	VK_FORMAT_R16G16B16A16_SFLOAT,
+	VK_FORMAT_R32_SFLOAT,
+	VK_FORMAT_R32G32_SFLOAT,
+	VK_FORMAT_R32G32B32A32_SFLOAT,
+	VK_FORMAT_R8_SRGB,
+	VK_FORMAT_R8_UNORM,
+	VK_FORMAT_R8G8_SRGB,
+	VK_FORMAT_R8G8_UNORM,
+	VK_FORMAT_R8G8B8A8_SRGB,
+	VK_FORMAT_R8G8B8A8_UNORM,
+} from '../libs/ktx-parse.module.js';
+/**
+ * References:
+ * - https://github.khronos.org/KTX-Specification/ktxspec.v2.html
+ * - https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html
+ * - https://github.com/donmccurdy/KTX-Parse
+ */
+const VK_FORMAT_MAP = {
+	[ RGBAFormat ]: {
+		[ FloatType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R32G32B32A32_SFLOAT,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R32G32B32A32_SFLOAT,
+		},
+		[ HalfFloatType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R16G16B16A16_SFLOAT,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R16G16B16A16_SFLOAT,
+		},
+		[ UnsignedByteType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R8G8B8A8_UNORM,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R8G8B8A8_UNORM,
+			[ SRGBColorSpace ]: VK_FORMAT_R8G8B8A8_SRGB,
+		},
+	},
+	[ RGFormat ]: {
+		[ FloatType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R32G32_SFLOAT,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R32G32_SFLOAT,
+		},
+		[ HalfFloatType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R16G16_SFLOAT,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R16G16_SFLOAT,
+		},
+		[ UnsignedByteType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R8G8_UNORM,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R8G8_UNORM,
+			[ SRGBColorSpace ]: VK_FORMAT_R8G8_SRGB,
+		},
+	},
+	[ RedFormat ]: {
+		[ FloatType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R32_SFLOAT,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R32_SFLOAT,
+		},
+		[ HalfFloatType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R16_SFLOAT,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R16_SFLOAT,
+		},
+		[ UnsignedByteType ]: {
+			[ NoColorSpace ]: VK_FORMAT_R8_UNORM,
+			[ LinearSRGBColorSpace ]: VK_FORMAT_R8_UNORM,
+			[ SRGBColorSpace ]: VK_FORMAT_R8_SRGB,
+		},
+	},
+};
+const KHR_DF_CHANNEL_MAP = [
+	KHR_DF_CHANNEL_RGBSDA_RED,
+	KHR_DF_CHANNEL_RGBSDA_GREEN,
+	KHR_DF_CHANNEL_RGBSDA_BLUE,
+	KHR_DF_CHANNEL_RGBSDA_ALPHA,
+];
+// TODO: sampleLower and sampleUpper may change based on color space.
+const KHR_DF_CHANNEL_SAMPLE_LOWER_UPPER = {
+	[ FloatType ]: [ 0xbf800000, 0x3f800000 ],
+	[ HalfFloatType ]: [ 0xbf800000, 0x3f800000 ],
+	[ UnsignedByteType ]: [ 0, 255 ],
+};
+const ERROR_INPUT = 'THREE.KTX2Exporter: Supported inputs are DataTexture, Data3DTexture, or WebGLRenderer and WebGLRenderTarget.';
+const ERROR_FORMAT = 'THREE.KTX2Exporter: Supported formats are RGBAFormat, RGFormat, or RedFormat.';
+const ERROR_TYPE = 'THREE.KTX2Exporter: Supported types are FloatType, HalfFloatType, or UnsignedByteType."';
+const ERROR_COLOR_SPACE = 'THREE.KTX2Exporter: Supported color spaces are SRGBColorSpace (UnsignedByteType only), LinearSRGBColorSpace, or NoColorSpace.';
+export class KTX2Exporter {
+	async parse( arg1, arg2 ) {
+		let texture;
+		if ( arg1.isDataTexture || arg1.isData3DTexture ) {
+			texture = arg1;
+		} else if ( ( arg1.isWebGLRenderer || arg1.isWebGPURenderer ) && arg2.isRenderTarget ) {
+			texture = await toDataTexture( arg1, arg2 );
+		} else {
+			throw new Error( ERROR_INPUT );
+		}
+		if ( VK_FORMAT_MAP[ texture.format ] === undefined ) {
+			throw new Error( ERROR_FORMAT );
+		}
+		if ( VK_FORMAT_MAP[ texture.format ][ texture.type ] === undefined ) {
+			throw new Error( ERROR_TYPE );
+		}
+		if ( VK_FORMAT_MAP[ texture.format ][ texture.type ][ texture.colorSpace ] === undefined ) {
+			throw new Error( ERROR_COLOR_SPACE );
+		}
+		//
+		const array = texture.image.data;
+		const channelCount = getChannelCount( texture );
+		const container = new KTX2Container();
+		container.vkFormat = VK_FORMAT_MAP[ texture.format ][ texture.type ][ texture.colorSpace ];
+		container.typeSize = array.BYTES_PER_ELEMENT;
+		container.pixelWidth = texture.image.width;
+		container.pixelHeight = texture.image.height;
+		if ( texture.isData3DTexture ) {
+			container.pixelDepth = texture.image.depth;
+		}
+		//
+		const basicDesc = container.dataFormatDescriptor[ 0 ];
+		basicDesc.colorModel = KHR_DF_MODEL_RGBSDA;
+		basicDesc.colorPrimaries = texture.colorSpace === NoColorSpace
+			? KHR_DF_PRIMARIES_UNSPECIFIED
+			: KHR_DF_PRIMARIES_BT709;
+		basicDesc.transferFunction = ColorManagement.getTransfer( texture.colorSpace ) === SRGBTransfer
+			? KHR_DF_TRANSFER_SRGB
+			: KHR_DF_TRANSFER_LINEAR;
+		basicDesc.texelBlockDimension = [ 0, 0, 0, 0 ];
+		basicDesc.bytesPlane = [
+			container.typeSize * channelCount, 0, 0, 0, 0, 0, 0, 0,
+		];
+		for ( let i = 0; i < channelCount; ++ i ) {
+			let channelType = KHR_DF_CHANNEL_MAP[ i ];
+			// Assign KHR_DF_SAMPLE_DATATYPE_LINEAR if the channel is linear _and_ differs from the transfer function.
+			if ( channelType === KHR_DF_CHANNEL_RGBSDA_ALPHA && basicDesc.transferFunction !== KHR_DF_TRANSFER_LINEAR ) {
+				channelType |= KHR_DF_SAMPLE_DATATYPE_LINEAR;
+			}
+			if ( texture.type === FloatType || texture.type === HalfFloatType ) {
+				channelType |= KHR_DF_SAMPLE_DATATYPE_FLOAT;
+				channelType |= KHR_DF_SAMPLE_DATATYPE_SIGNED;
+			}
+			basicDesc.samples.push( {
+				channelType: channelType,
+				bitOffset: i * array.BYTES_PER_ELEMENT * 8,
+				bitLength: array.BYTES_PER_ELEMENT * 8 - 1,
+				samplePosition: [ 0, 0, 0, 0 ],
+				sampleLower: KHR_DF_CHANNEL_SAMPLE_LOWER_UPPER[ texture.type ][ 0 ],
+				sampleUpper: KHR_DF_CHANNEL_SAMPLE_LOWER_UPPER[ texture.type ][ 1 ],
+			} );
+		}
+		//
+		container.levels = [ {
+			levelData: new Uint8Array( array.buffer, array.byteOffset, array.byteLength ),
+			uncompressedByteLength: array.byteLength,
+		} ];
+		//
+		container.keyValue[ 'KTXwriter' ] = `three.js ${ REVISION }`;
+		//
+		return write( container, { keepWriter: true } );
+	}
+}
+async function toDataTexture( renderer, rtt ) {
+	const channelCount = getChannelCount( rtt.texture );
+	let view;
+	if ( renderer.isWebGLRenderer ) {
+		if ( rtt.texture.type === FloatType ) {
+			view = new Float32Array( rtt.width * rtt.height * channelCount );
+		} else if ( rtt.texture.type === HalfFloatType ) {
+			view = new Uint16Array( rtt.width * rtt.height * channelCount );
+		} else if ( rtt.texture.type === UnsignedByteType ) {
+			view = new Uint8Array( rtt.width * rtt.height * channelCount );
+		} else {
+			throw new Error( ERROR_TYPE );
+		}
+		await renderer.readRenderTargetPixelsAsync( rtt, 0, 0, rtt.width, rtt.height, view );
+	} else {
+		view = await renderer.readRenderTargetPixelsAsync( rtt, 0, 0, rtt.width, rtt.height );
+	}
+	const texture = new DataTexture( view, rtt.width, rtt.height, rtt.texture.format, rtt.texture.type );
+	texture.colorSpace = rtt.texture.colorSpace;
+	return texture;
+}
+function getChannelCount( texture ) {
+	switch ( texture.format ) {
+		case RGBAFormat:
+			return 4;
+		case RGFormat:
+		case RGIntegerFormat:
+			return 2;
+		case RedFormat:
+		case RedIntegerFormat:
+			return 1;
+		default:
+			throw new Error( ERROR_FORMAT );
+	}
+}

libs/three.js/0.172.0/jsm/exporters/OBJExporter.js ADDED Viewed

	@@ -0,0 +1,288 @@

+import {
+	Color,
+	ColorManagement,
+	Matrix3,
+	SRGBColorSpace,
+	Vector2,
+	Vector3
+} from 'three';
+class OBJExporter {
+	parse( object ) {
+		let output = '';
+		let indexVertex = 0;
+		let indexVertexUvs = 0;
+		let indexNormals = 0;
+		const vertex = new Vector3();
+		const color = new Color();
+		const normal = new Vector3();
+		const uv = new Vector2();
+		const face = [];
+		function parseMesh( mesh ) {
+			let nbVertex = 0;
+			let nbNormals = 0;
+			let nbVertexUvs = 0;
+			const geometry = mesh.geometry;
+			const normalMatrixWorld = new Matrix3();
+			// shortcuts
+			const vertices = geometry.getAttribute( 'position' );
+			const normals = geometry.getAttribute( 'normal' );
+			const uvs = geometry.getAttribute( 'uv' );
+			const indices = geometry.getIndex();
+			// name of the mesh object
+			output += 'o ' + mesh.name + '\n';
+			// name of the mesh material
+			if ( mesh.material && mesh.material.name ) {
+				output += 'usemtl ' + mesh.material.name + '\n';
+			}
+			// vertices
+			if ( vertices !== undefined ) {
+				for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
+					vertex.fromBufferAttribute( vertices, i );
+					// transform the vertex to world space
+					vertex.applyMatrix4( mesh.matrixWorld );
+					// transform the vertex to export format
+					output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+				}
+			}
+			// uvs
+			if ( uvs !== undefined ) {
+				for ( let i = 0, l = uvs.count; i < l; i ++, nbVertexUvs ++ ) {
+					uv.fromBufferAttribute( uvs, i );
+					// transform the uv to export format
+					output += 'vt ' + uv.x + ' ' + uv.y + '\n';
+				}
+			}
+			// normals
+			if ( normals !== undefined ) {
+				normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
+				for ( let i = 0, l = normals.count; i < l; i ++, nbNormals ++ ) {
+					normal.fromBufferAttribute( normals, i );
+					// transform the normal to world space
+					normal.applyMatrix3( normalMatrixWorld ).normalize();
+					// transform the normal to export format
+					output += 'vn ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
+				}
+			}
+			// faces
+			if ( indices !== null ) {
+				for ( let i = 0, l = indices.count; i < l; i += 3 ) {
+					for ( let m = 0; m < 3; m ++ ) {
+						const j = indices.getX( i + m ) + 1;
+						face[ m ] = ( indexVertex + j ) + ( normals || uvs ? '/' + ( uvs ? ( indexVertexUvs + j ) : '' ) + ( normals ? '/' + ( indexNormals + j ) : '' ) : '' );
+					}
+					// transform the face to export format
+					output += 'f ' + face.join( ' ' ) + '\n';
+				}
+			} else {
+				for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
+					for ( let m = 0; m < 3; m ++ ) {
+						const j = i + m + 1;
+						face[ m ] = ( indexVertex + j ) + ( normals || uvs ? '/' + ( uvs ? ( indexVertexUvs + j ) : '' ) + ( normals ? '/' + ( indexNormals + j ) : '' ) : '' );
+					}
+					// transform the face to export format
+					output += 'f ' + face.join( ' ' ) + '\n';
+				}
+			}
+			// update index
+			indexVertex += nbVertex;
+			indexVertexUvs += nbVertexUvs;
+			indexNormals += nbNormals;
+		}
+		function parseLine( line ) {
+			let nbVertex = 0;
+			const geometry = line.geometry;
+			const type = line.type;
+			// shortcuts
+			const vertices = geometry.getAttribute( 'position' );
+			// name of the line object
+			output += 'o ' + line.name + '\n';
+			if ( vertices !== undefined ) {
+				for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
+					vertex.fromBufferAttribute( vertices, i );
+					// transform the vertex to world space
+					vertex.applyMatrix4( line.matrixWorld );
+					// transform the vertex to export format
+					output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+				}
+			}
+			if ( type === 'Line' ) {
+				output += 'l ';
+				for ( let j = 1, l = vertices.count; j <= l; j ++ ) {
+					output += ( indexVertex + j ) + ' ';
+				}
+				output += '\n';
+			}
+			if ( type === 'LineSegments' ) {
+				for ( let j = 1, k = j + 1, l = vertices.count; j < l; j += 2, k = j + 1 ) {
+					output += 'l ' + ( indexVertex + j ) + ' ' + ( indexVertex + k ) + '\n';
+				}
+			}
+			// update index
+			indexVertex += nbVertex;
+		}
+		function parsePoints( points ) {
+			let nbVertex = 0;
+			const geometry = points.geometry;
+			const vertices = geometry.getAttribute( 'position' );
+			const colors = geometry.getAttribute( 'color' );
+			output += 'o ' + points.name + '\n';
+			if ( vertices !== undefined ) {
+				for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
+					vertex.fromBufferAttribute( vertices, i );
+					vertex.applyMatrix4( points.matrixWorld );
+					output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z;
+					if ( colors !== undefined ) {
+						color.fromBufferAttribute( colors, i );
+						ColorManagement.fromWorkingColorSpace( color, SRGBColorSpace );
+						output += ' ' + color.r + ' ' + color.g + ' ' + color.b;
+					}
+					output += '\n';
+				}
+				output += 'p ';
+				for ( let j = 1, l = vertices.count; j <= l; j ++ ) {
+					output += ( indexVertex + j ) + ' ';
+				}
+				output += '\n';
+			}
+			// update index
+			indexVertex += nbVertex;
+		}
+		object.traverse( function ( child ) {
+			if ( child.isMesh === true ) {
+				parseMesh( child );
+			}
+			if ( child.isLine === true ) {
+				parseLine( child );
+			}
+			if ( child.isPoints === true ) {
+				parsePoints( child );
+			}
+		} );
+		return output;
+	}
+}
+export { OBJExporter };

libs/three.js/0.172.0/jsm/exporters/PLYExporter.js ADDED Viewed

	@@ -0,0 +1,530 @@

+import {
+	Matrix3,
+	Vector3,
+	Color,
+	ColorManagement,
+	SRGBColorSpace
+} from 'three';
+/**
+ * https://github.com/gkjohnson/ply-exporter-js
+ *
+ * Usage:
+ *  const exporter = new PLYExporter();
+ *
+ *  // second argument is a list of options
+ *  exporter.parse(mesh, data => console.log(data), { binary: true, excludeAttributes: [ 'color' ], littleEndian: true });
+ *
+ * Format Definition:
+ * http://paulbourke.net/dataformats/ply/
+ */
+class PLYExporter {
+	parse( object, onDone, options = {} ) {
+		// Iterate over the valid meshes in the object
+		function traverseMeshes( cb ) {
+			object.traverse( function ( child ) {
+				if ( child.isMesh === true || child.isPoints ) {
+					const mesh = child;
+					const geometry = mesh.geometry;
+					if ( geometry.hasAttribute( 'position' ) === true ) {
+						cb( mesh, geometry );
+					}
+				}
+			} );
+		}
+		// Default options
+		const defaultOptions = {
+			binary: false,
+			excludeAttributes: [], // normal, uv, color, index
+			littleEndian: false
+		};
+		options = Object.assign( defaultOptions, options );
+		const excludeAttributes = options.excludeAttributes;
+		let includeIndices = true;
+		let includeNormals = false;
+		let includeColors = false;
+		let includeUVs = false;
+		// count the vertices, check which properties are used,
+		// and cache the BufferGeometry
+		let vertexCount = 0;
+		let faceCount = 0;
+		object.traverse( function ( child ) {
+			if ( child.isMesh === true ) {
+				const mesh = child;
+				const geometry = mesh.geometry;
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const uvs = geometry.getAttribute( 'uv' );
+				const colors = geometry.getAttribute( 'color' );
+				const indices = geometry.getIndex();
+				if ( vertices === undefined ) {
+					return;
+				}
+				vertexCount += vertices.count;
+				faceCount += indices ? indices.count / 3 : vertices.count / 3;
+				if ( normals !== undefined ) includeNormals = true;
+				if ( uvs !== undefined ) includeUVs = true;
+				if ( colors !== undefined ) includeColors = true;
+			} else if ( child.isPoints ) {
+				const mesh = child;
+				const geometry = mesh.geometry;
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const colors = geometry.getAttribute( 'color' );
+				vertexCount += vertices.count;
+				if ( normals !== undefined ) includeNormals = true;
+				if ( colors !== undefined ) includeColors = true;
+				includeIndices = false;
+			}
+		} );
+		const tempColor = new Color();
+		includeIndices = includeIndices && excludeAttributes.indexOf( 'index' ) === - 1;
+		includeNormals = includeNormals && excludeAttributes.indexOf( 'normal' ) === - 1;
+		includeColors = includeColors && excludeAttributes.indexOf( 'color' ) === - 1;
+		includeUVs = includeUVs && excludeAttributes.indexOf( 'uv' ) === - 1;
+		if ( includeIndices && faceCount !== Math.floor( faceCount ) ) {
+			// point cloud meshes will not have an index array and may not have a
+			// number of vertices that is divisible by 3 (and therefore representable
+			// as triangles)
+			console.error(
+				'PLYExporter: Failed to generate a valid PLY file with triangle indices because the ' +
+				'number of indices is not divisible by 3.'
+			);
+			return null;
+		}
+		const indexByteCount = 4;
+		let header =
+			'ply\n' +
+			`format ${ options.binary ? ( options.littleEndian ? 'binary_little_endian' : 'binary_big_endian' ) : 'ascii' } 1.0\n` +
+			`element vertex ${vertexCount}\n` +
+			// position
+			'property float x\n' +
+			'property float y\n' +
+			'property float z\n';
+		if ( includeNormals === true ) {
+			// normal
+			header +=
+				'property float nx\n' +
+				'property float ny\n' +
+				'property float nz\n';
+		}
+		if ( includeUVs === true ) {
+			// uvs
+			header +=
+				'property float s\n' +
+				'property float t\n';
+		}
+		if ( includeColors === true ) {
+			// colors
+			header +=
+				'property uchar red\n' +
+				'property uchar green\n' +
+				'property uchar blue\n';
+		}
+		if ( includeIndices === true ) {
+			// faces
+			header +=
+				`element face ${faceCount}\n` +
+				'property list uchar int vertex_index\n';
+		}
+		header += 'end_header\n';
+		// Generate attribute data
+		const vertex = new Vector3();
+		const normalMatrixWorld = new Matrix3();
+		let result = null;
+		if ( options.binary === true ) {
+			// Binary File Generation
+			const headerBin = new TextEncoder().encode( header );
+			// 3 position values at 4 bytes
+			// 3 normal values at 4 bytes
+			// 3 color channels with 1 byte
+			// 2 uv values at 4 bytes
+			const vertexListLength = vertexCount * ( 4 * 3 + ( includeNormals ? 4 * 3 : 0 ) + ( includeColors ? 3 : 0 ) + ( includeUVs ? 4 * 2 : 0 ) );
+			// 1 byte shape descriptor
+			// 3 vertex indices at ${indexByteCount} bytes
+			const faceListLength = includeIndices ? faceCount * ( indexByteCount * 3 + 1 ) : 0;
+			const output = new DataView( new ArrayBuffer( headerBin.length + vertexListLength + faceListLength ) );
+			new Uint8Array( output.buffer ).set( headerBin, 0 );
+			let vOffset = headerBin.length;
+			let fOffset = headerBin.length + vertexListLength;
+			let writtenVertices = 0;
+			traverseMeshes( function ( mesh, geometry ) {
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const uvs = geometry.getAttribute( 'uv' );
+				const colors = geometry.getAttribute( 'color' );
+				const indices = geometry.getIndex();
+				normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
+				for ( let i = 0, l = vertices.count; i < l; i ++ ) {
+					vertex.fromBufferAttribute( vertices, i );
+					vertex.applyMatrix4( mesh.matrixWorld );
+					// Position information
+					output.setFloat32( vOffset, vertex.x, options.littleEndian );
+					vOffset += 4;
+					output.setFloat32( vOffset, vertex.y, options.littleEndian );
+					vOffset += 4;
+					output.setFloat32( vOffset, vertex.z, options.littleEndian );
+					vOffset += 4;
+					// Normal information
+					if ( includeNormals === true ) {
+						if ( normals != null ) {
+							vertex.fromBufferAttribute( normals, i );
+							vertex.applyMatrix3( normalMatrixWorld ).normalize();
+							output.setFloat32( vOffset, vertex.x, options.littleEndian );
+							vOffset += 4;
+							output.setFloat32( vOffset, vertex.y, options.littleEndian );
+							vOffset += 4;
+							output.setFloat32( vOffset, vertex.z, options.littleEndian );
+							vOffset += 4;
+						} else {
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+						}
+					}
+					// UV information
+					if ( includeUVs === true ) {
+						if ( uvs != null ) {
+							output.setFloat32( vOffset, uvs.getX( i ), options.littleEndian );
+							vOffset += 4;
+							output.setFloat32( vOffset, uvs.getY( i ), options.littleEndian );
+							vOffset += 4;
+						} else {
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+						}
+					}
+					// Color information
+					if ( includeColors === true ) {
+						if ( colors != null ) {
+							tempColor.fromBufferAttribute( colors, i );
+							ColorManagement.fromWorkingColorSpace( tempColor, SRGBColorSpace );
+							output.setUint8( vOffset, Math.floor( tempColor.r * 255 ) );
+							vOffset += 1;
+							output.setUint8( vOffset, Math.floor( tempColor.g * 255 ) );
+							vOffset += 1;
+							output.setUint8( vOffset, Math.floor( tempColor.b * 255 ) );
+							vOffset += 1;
+						} else {
+							output.setUint8( vOffset, 255 );
+							vOffset += 1;
+							output.setUint8( vOffset, 255 );
+							vOffset += 1;
+							output.setUint8( vOffset, 255 );
+							vOffset += 1;
+						}
+					}
+				}
+				if ( includeIndices === true ) {
+					// Create the face list
+					if ( indices !== null ) {
+						for ( let i = 0, l = indices.count; i < l; i += 3 ) {
+							output.setUint8( fOffset, 3 );
+							fOffset += 1;
+							output.setUint32( fOffset, indices.getX( i + 0 ) + writtenVertices, options.littleEndian );
+							fOffset += indexByteCount;
+							output.setUint32( fOffset, indices.getX( i + 1 ) + writtenVertices, options.littleEndian );
+							fOffset += indexByteCount;
+							output.setUint32( fOffset, indices.getX( i + 2 ) + writtenVertices, options.littleEndian );
+							fOffset += indexByteCount;
+						}
+					} else {
+						for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
+							output.setUint8( fOffset, 3 );
+							fOffset += 1;
+							output.setUint32( fOffset, writtenVertices + i, options.littleEndian );
+							fOffset += indexByteCount;
+							output.setUint32( fOffset, writtenVertices + i + 1, options.littleEndian );
+							fOffset += indexByteCount;
+							output.setUint32( fOffset, writtenVertices + i + 2, options.littleEndian );
+							fOffset += indexByteCount;
+						}
+					}
+				}
+				// Save the amount of verts we've already written so we can offset
+				// the face index on the next mesh
+				writtenVertices += vertices.count;
+			} );
+			result = output.buffer;
+		} else {
+			// Ascii File Generation
+			// count the number of vertices
+			let writtenVertices = 0;
+			let vertexList = '';
+			let faceList = '';
+			traverseMeshes( function ( mesh, geometry ) {
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const uvs = geometry.getAttribute( 'uv' );
+				const colors = geometry.getAttribute( 'color' );
+				const indices = geometry.getIndex();
+				normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
+				// form each line
+				for ( let i = 0, l = vertices.count; i < l; i ++ ) {
+					vertex.fromBufferAttribute( vertices, i );
+					vertex.applyMatrix4( mesh.matrixWorld );
+					// Position information
+					let line =
+						vertex.x + ' ' +
+						vertex.y + ' ' +
+						vertex.z;
+					// Normal information
+					if ( includeNormals === true ) {
+						if ( normals != null ) {
+							vertex.fromBufferAttribute( normals, i );
+							vertex.applyMatrix3( normalMatrixWorld ).normalize();
+							line += ' ' +
+								vertex.x + ' ' +
+								vertex.y + ' ' +
+								vertex.z;
+						} else {
+							line += ' 0 0 0';
+						}
+					}
+					// UV information
+					if ( includeUVs === true ) {
+						if ( uvs != null ) {
+							line += ' ' +
+								uvs.getX( i ) + ' ' +
+								uvs.getY( i );
+						} else {
+							line += ' 0 0';
+						}
+					}
+					// Color information
+					if ( includeColors === true ) {
+						if ( colors != null ) {
+							tempColor.fromBufferAttribute( colors, i );
+							ColorManagement.fromWorkingColorSpace( tempColor, SRGBColorSpace );
+							line += ' ' +
+								Math.floor( tempColor.r * 255 ) + ' ' +
+								Math.floor( tempColor.g * 255 ) + ' ' +
+								Math.floor( tempColor.b * 255 );
+						} else {
+							line += ' 255 255 255';
+						}
+					}
+					vertexList += line + '\n';
+				}
+				// Create the face list
+				if ( includeIndices === true ) {
+					if ( indices !== null ) {
+						for ( let i = 0, l = indices.count; i < l; i += 3 ) {
+							faceList += `3 ${ indices.getX( i + 0 ) + writtenVertices }`;
+							faceList += ` ${ indices.getX( i + 1 ) + writtenVertices }`;
+							faceList += ` ${ indices.getX( i + 2 ) + writtenVertices }\n`;
+						}
+					} else {
+						for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
+							faceList += `3 ${ writtenVertices + i } ${ writtenVertices + i + 1 } ${ writtenVertices + i + 2 }\n`;
+						}
+					}
+					faceCount += indices ? indices.count / 3 : vertices.count / 3;
+				}
+				writtenVertices += vertices.count;
+			} );
+			result = `${ header }${vertexList}${ includeIndices ? `${faceList}\n` : '\n' }`;
+		}
+		if ( typeof onDone === 'function' ) requestAnimationFrame( () => onDone( result ) );
+		return result;
+	}
+}
+export { PLYExporter };

libs/three.js/0.172.0/jsm/exporters/STLExporter.js ADDED Viewed

	@@ -0,0 +1,199 @@

+import { Vector3 } from 'three';
+/**
+ * Usage:
+ *  const exporter = new STLExporter();
+ *
+ *  // second argument is a list of options
+ *  const data = exporter.parse( mesh, { binary: true } );
+ *
+ */
+class STLExporter {
+	parse( scene, options = {} ) {
+		options = Object.assign( {
+			binary: false
+		}, options );
+		const binary = options.binary;
+		//
+		const objects = [];
+		let triangles = 0;
+		scene.traverse( function ( object ) {
+			if ( object.isMesh ) {
+				const geometry = object.geometry;
+				const index = geometry.index;
+				const positionAttribute = geometry.getAttribute( 'position' );
+				triangles += ( index !== null ) ? ( index.count / 3 ) : ( positionAttribute.count / 3 );
+				objects.push( {
+					object3d: object,
+					geometry: geometry
+				} );
+			}
+		} );
+		let output;
+		let offset = 80; // skip header
+		if ( binary === true ) {
+			const bufferLength = triangles * 2 + triangles * 3 * 4 * 4 + 80 + 4;
+			const arrayBuffer = new ArrayBuffer( bufferLength );
+			output = new DataView( arrayBuffer );
+			output.setUint32( offset, triangles, true ); offset += 4;
+		} else {
+			output = '';
+			output += 'solid exported\n';
+		}
+		const vA = new Vector3();
+		const vB = new Vector3();
+		const vC = new Vector3();
+		const cb = new Vector3();
+		const ab = new Vector3();
+		const normal = new Vector3();
+		for ( let i = 0, il = objects.length; i < il; i ++ ) {
+			const object = objects[ i ].object3d;
+			const geometry = objects[ i ].geometry;
+			const index = geometry.index;
+			const positionAttribute = geometry.getAttribute( 'position' );
+			if ( index !== null ) {
+				// indexed geometry
+				for ( let j = 0; j < index.count; j += 3 ) {
+					const a = index.getX( j + 0 );
+					const b = index.getX( j + 1 );
+					const c = index.getX( j + 2 );
+					writeFace( a, b, c, positionAttribute, object );
+				}
+			} else {
+				// non-indexed geometry
+				for ( let j = 0; j < positionAttribute.count; j += 3 ) {
+					const a = j + 0;
+					const b = j + 1;
+					const c = j + 2;
+					writeFace( a, b, c, positionAttribute, object );
+				}
+			}
+		}
+		if ( binary === false ) {
+			output += 'endsolid exported\n';
+		}
+		return output;
+		function writeFace( a, b, c, positionAttribute, object ) {
+			vA.fromBufferAttribute( positionAttribute, a );
+			vB.fromBufferAttribute( positionAttribute, b );
+			vC.fromBufferAttribute( positionAttribute, c );
+			if ( object.isSkinnedMesh === true ) {
+				object.applyBoneTransform( a, vA );
+				object.applyBoneTransform( b, vB );
+				object.applyBoneTransform( c, vC );
+			}
+			vA.applyMatrix4( object.matrixWorld );
+			vB.applyMatrix4( object.matrixWorld );
+			vC.applyMatrix4( object.matrixWorld );
+			writeNormal( vA, vB, vC );
+			writeVertex( vA );
+			writeVertex( vB );
+			writeVertex( vC );
+			if ( binary === true ) {
+				output.setUint16( offset, 0, true ); offset += 2;
+			} else {
+				output += '\t\tendloop\n';
+				output += '\tendfacet\n';
+			}
+		}
+		function writeNormal( vA, vB, vC ) {
+			cb.subVectors( vC, vB );
+			ab.subVectors( vA, vB );
+			cb.cross( ab ).normalize();
+			normal.copy( cb ).normalize();
+			if ( binary === true ) {
+				output.setFloat32( offset, normal.x, true ); offset += 4;
+				output.setFloat32( offset, normal.y, true ); offset += 4;
+				output.setFloat32( offset, normal.z, true ); offset += 4;
+			} else {
+				output += '\tfacet normal ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
+				output += '\t\touter loop\n';
+			}
+		}
+		function writeVertex( vertex ) {
+			if ( binary === true ) {
+				output.setFloat32( offset, vertex.x, true ); offset += 4;
+				output.setFloat32( offset, vertex.y, true ); offset += 4;
+				output.setFloat32( offset, vertex.z, true ); offset += 4;
+			} else {
+				output += '\t\t\tvertex ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
+			}
+		}
+	}
+}
+export { STLExporter };

libs/three.js/0.172.0/jsm/exporters/USDZExporter.js ADDED Viewed

	@@ -0,0 +1,782 @@

+import {
+	NoColorSpace,
+	DoubleSide,
+	Color,
+} from 'three';
+import {
+	strToU8,
+	zipSync,
+} from '../libs/fflate.module.js';
+class USDZExporter {
+	constructor() {
+		this.textureUtils = null;
+	}
+	setTextureUtils( utils ) {
+		this.textureUtils = utils;
+	}
+	parse( scene, onDone, onError, options ) {
+		this.parseAsync( scene, options ).then( onDone ).catch( onError );
+	}
+	async parseAsync( scene, options = {} ) {
+		options = Object.assign( {
+			ar: {
+				anchoring: { type: 'plane' },
+				planeAnchoring: { alignment: 'horizontal' }
+			},
+			includeAnchoringProperties: true,
+			quickLookCompatible: false,
+			maxTextureSize: 1024,
+		}, options );
+		const files = {};
+		const modelFileName = 'model.usda';
+		// model file should be first in USDZ archive so we init it here
+		files[ modelFileName ] = null;
+		let output = buildHeader();
+		output += buildSceneStart( options );
+		const materials = {};
+		const textures = {};
+		scene.traverseVisible( ( object ) => {
+			if ( object.isMesh ) {
+				const geometry = object.geometry;
+				const material = object.material;
+				if ( material.isMeshStandardMaterial ) {
+					const geometryFileName = 'geometries/Geometry_' + geometry.id + '.usda';
+					if ( ! ( geometryFileName in files ) ) {
+						const meshObject = buildMeshObject( geometry );
+						files[ geometryFileName ] = buildUSDFileAsString( meshObject );
+					}
+					if ( ! ( material.uuid in materials ) ) {
+						materials[ material.uuid ] = material;
+					}
+					output += buildXform( object, geometry, material );
+				} else {
+					console.warn( 'THREE.USDZExporter: Unsupported material type (USDZ only supports MeshStandardMaterial)', object );
+				}
+			} else if ( object.isCamera ) {
+				output += buildCamera( object );
+			}
+		} );
+		output += buildSceneEnd();
+		output += buildMaterials( materials, textures, options.quickLookCompatible );
+		files[ modelFileName ] = strToU8( output );
+		output = null;
+		for ( const id in textures ) {
+			let texture = textures[ id ];
+			if ( texture.isCompressedTexture === true ) {
+				if ( this.textureUtils === null ) {
+					throw new Error( 'THREE.USDZExporter: setTextureUtils() must be called to process compressed textures.' );
+				} else {
+					texture = await this.textureUtils.decompress( texture );
+				}
+			}
+			const canvas = imageToCanvas( texture.image, texture.flipY, options.maxTextureSize );
+			const blob = await new Promise( resolve => canvas.toBlob( resolve, 'image/png', 1 ) );
+			files[ `textures/Texture_${ id }.png` ] = new Uint8Array( await blob.arrayBuffer() );
+		}
+		// 64 byte alignment
+		// https://github.com/101arrowz/fflate/issues/39#issuecomment-777263109
+		let offset = 0;
+		for ( const filename in files ) {
+			const file = files[ filename ];
+			const headerSize = 34 + filename.length;
+			offset += headerSize;
+			const offsetMod64 = offset & 63;
+			if ( offsetMod64 !== 4 ) {
+				const padLength = 64 - offsetMod64;
+				const padding = new Uint8Array( padLength );
+				files[ filename ] = [ file, { extra: { 12345: padding } } ];
+			}
+			offset = file.length;
+		}
+		return zipSync( files, { level: 0 } );
+	}
+}
+function imageToCanvas( image, flipY, maxTextureSize ) {
+	if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
+		( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
+		( typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas ) ||
+		( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
+		const scale = maxTextureSize / Math.max( image.width, image.height );
+		const canvas = document.createElement( 'canvas' );
+		canvas.width = image.width * Math.min( 1, scale );
+		canvas.height = image.height * Math.min( 1, scale );
+		const context = canvas.getContext( '2d' );
+		// TODO: We should be able to do this in the UsdTransform2d?
+		if ( flipY === true ) {
+			context.translate( 0, canvas.height );
+			context.scale( 1, - 1 );
+		}
+		context.drawImage( image, 0, 0, canvas.width, canvas.height );
+		return canvas;
+	} else {
+		throw new Error( 'THREE.USDZExporter: No valid image data found. Unable to process texture.' );
+	}
+}
+//
+const PRECISION = 7;
+function buildHeader() {
+	return `#usda 1.0
+(
+	customLayerData = {
+		string creator = "Three.js USDZExporter"
+	}
+	defaultPrim = "Root"
+	metersPerUnit = 1
+	upAxis = "Y"
+)
+`;
+}
+function buildSceneStart( options ) {
+	const alignment = options.includeAnchoringProperties === true ? `
+		token preliminary:anchoring:type = "${options.ar.anchoring.type}"
+		token preliminary:planeAnchoring:alignment = "${options.ar.planeAnchoring.alignment}"
+	` : '';
+	return `def Xform "Root"
+{
+	def Scope "Scenes" (
+		kind = "sceneLibrary"
+	)
+	{
+		def Xform "Scene" (
+			customData = {
+				bool preliminary_collidesWithEnvironment = 0
+				string sceneName = "Scene"
+			}
+			sceneName = "Scene"
+		)
+		{${alignment}
+`;
+}
+function buildSceneEnd() {
+	return `
+		}
+	}
+}
+`;
+}
+function buildUSDFileAsString( dataToInsert ) {
+	let output = buildHeader();
+	output += dataToInsert;
+	return strToU8( output );
+}
+// Xform
+function buildXform( object, geometry, material ) {
+	const name = 'Object_' + object.id;
+	const transform = buildMatrix( object.matrixWorld );
+	if ( object.matrixWorld.determinant() < 0 ) {
+		console.warn( 'THREE.USDZExporter: USDZ does not support negative scales', object );
+	}
+	return `def Xform "${ name }" (
+	prepend references = @./geometries/Geometry_${ geometry.id }.usda@</Geometry>
+	prepend apiSchemas = ["MaterialBindingAPI"]
+)
+{
+	matrix4d xformOp:transform = ${ transform }
+	uniform token[] xformOpOrder = ["xformOp:transform"]
+	rel material:binding = </Materials/Material_${ material.id }>
+}
+`;
+}
+function buildMatrix( matrix ) {
+	const array = matrix.elements;
+	return `( ${ buildMatrixRow( array, 0 ) }, ${ buildMatrixRow( array, 4 ) }, ${ buildMatrixRow( array, 8 ) }, ${ buildMatrixRow( array, 12 ) } )`;
+}
+function buildMatrixRow( array, offset ) {
+	return `(${ array[ offset + 0 ] }, ${ array[ offset + 1 ] }, ${ array[ offset + 2 ] }, ${ array[ offset + 3 ] })`;
+}
+// Mesh
+function buildMeshObject( geometry ) {
+	const mesh = buildMesh( geometry );
+	return `
+def "Geometry"
+{
+${mesh}
+}
+`;
+}
+function buildMesh( geometry ) {
+	const name = 'Geometry';
+	const attributes = geometry.attributes;
+	const count = attributes.position.count;
+	return `
+	def Mesh "${ name }"
+	{
+		int[] faceVertexCounts = [${ buildMeshVertexCount( geometry ) }]
+		int[] faceVertexIndices = [${ buildMeshVertexIndices( geometry ) }]
+		normal3f[] normals = [${ buildVector3Array( attributes.normal, count )}] (
+			interpolation = "vertex"
+		)
+		point3f[] points = [${ buildVector3Array( attributes.position, count )}]
+${ buildPrimvars( attributes ) }
+		uniform token subdivisionScheme = "none"
+	}
+`;
+}
+function buildMeshVertexCount( geometry ) {
+	const count = geometry.index !== null ? geometry.index.count : geometry.attributes.position.count;
+	return Array( count / 3 ).fill( 3 ).join( ', ' );
+}
+function buildMeshVertexIndices( geometry ) {
+	const index = geometry.index;
+	const array = [];
+	if ( index !== null ) {
+		for ( let i = 0; i < index.count; i ++ ) {
+			array.push( index.getX( i ) );
+		}
+	} else {
+		const length = geometry.attributes.position.count;
+		for ( let i = 0; i < length; i ++ ) {
+			array.push( i );
+		}
+	}
+	return array.join( ', ' );
+}
+function buildVector3Array( attribute, count ) {
+	if ( attribute === undefined ) {
+		console.warn( 'USDZExporter: Normals missing.' );
+		return Array( count ).fill( '(0, 0, 0)' ).join( ', ' );
+	}
+	const array = [];
+	for ( let i = 0; i < attribute.count; i ++ ) {
+		const x = attribute.getX( i );
+		const y = attribute.getY( i );
+		const z = attribute.getZ( i );
+		array.push( `(${ x.toPrecision( PRECISION ) }, ${ y.toPrecision( PRECISION ) }, ${ z.toPrecision( PRECISION ) })` );
+	}
+	return array.join( ', ' );
+}
+function buildVector2Array( attribute ) {
+	const array = [];
+	for ( let i = 0; i < attribute.count; i ++ ) {
+		const x = attribute.getX( i );
+		const y = attribute.getY( i );
+		array.push( `(${ x.toPrecision( PRECISION ) }, ${ 1 - y.toPrecision( PRECISION ) })` );
+	}
+	return array.join( ', ' );
+}
+function buildPrimvars( attributes ) {
+	let string = '';
+	for ( let i = 0; i < 4; i ++ ) {
+		const id = ( i > 0 ? i : '' );
+		const attribute = attributes[ 'uv' + id ];
+		if ( attribute !== undefined ) {
+			string += `
+		texCoord2f[] primvars:st${ id } = [${ buildVector2Array( attribute )}] (
+			interpolation = "vertex"
+		)`;
+		}
+	}
+	// vertex colors
+	const colorAttribute = attributes.color;
+	if ( colorAttribute !== undefined ) {
+		const count = colorAttribute.count;
+		string += `
+	color3f[] primvars:displayColor = [${buildVector3Array( colorAttribute, count )}] (
+		interpolation = "vertex"
+		)`;
+	}
+	return string;
+}
+// Materials
+function buildMaterials( materials, textures, quickLookCompatible = false ) {
+	const array = [];
+	for ( const uuid in materials ) {
+		const material = materials[ uuid ];
+		array.push( buildMaterial( material, textures, quickLookCompatible ) );
+	}
+	return `def "Materials"
+{
+${ array.join( '' ) }
+}
+`;
+}
+function buildMaterial( material, textures, quickLookCompatible = false ) {
+	// https://graphics.pixar.com/usd/docs/UsdPreviewSurface-Proposal.html
+	const pad = '			';
+	const inputs = [];
+	const samplers = [];
+	function buildTexture( texture, mapType, color ) {
+		const id = texture.source.id + '_' + texture.flipY;
+		textures[ id ] = texture;
+		const uv = texture.channel > 0 ? 'st' + texture.channel : 'st';
+		const WRAPPINGS = {
+			1000: 'repeat', // RepeatWrapping
+			1001: 'clamp', // ClampToEdgeWrapping
+			1002: 'mirror' // MirroredRepeatWrapping
+		};
+		const repeat = texture.repeat.clone();
+		const offset = texture.offset.clone();
+		const rotation = texture.rotation;
+		// rotation is around the wrong point. after rotation we need to shift offset again so that we're rotating around the right spot
+		const xRotationOffset = Math.sin( rotation );
+		const yRotationOffset = Math.cos( rotation );
+		// texture coordinates start in the opposite corner, need to correct
+		offset.y = 1 - offset.y - repeat.y;
+		// turns out QuickLook is buggy and interprets texture repeat inverted/applies operations in a different order.
+		// Apple Feedback: 	FB10036297 and FB11442287
+		if ( quickLookCompatible ) {
+			// This is NOT correct yet in QuickLook, but comes close for a range of models.
+			// It becomes more incorrect the bigger the offset is
+			offset.x = offset.x / repeat.x;
+			offset.y = offset.y / repeat.y;
+			offset.x += xRotationOffset / repeat.x;
+			offset.y += yRotationOffset - 1;
+		} else {
+			// results match glTF results exactly. verified correct in usdview.
+			offset.x += xRotationOffset * repeat.x;
+			offset.y += ( 1 - yRotationOffset ) * repeat.y;
+		}
+		return `
+		def Shader "PrimvarReader_${ mapType }"
+		{
+			uniform token info:id = "UsdPrimvarReader_float2"
+			float2 inputs:fallback = (0.0, 0.0)
+			token inputs:varname = "${ uv }"
+			float2 outputs:result
+		}
+		def Shader "Transform2d_${ mapType }"
+		{
+			uniform token info:id = "UsdTransform2d"
+			token inputs:in.connect = </Materials/Material_${ material.id }/PrimvarReader_${ mapType }.outputs:result>
+			float inputs:rotation = ${ ( rotation * ( 180 / Math.PI ) ).toFixed( PRECISION ) }
+			float2 inputs:scale = ${ buildVector2( repeat ) }
+			float2 inputs:translation = ${ buildVector2( offset ) }
+			float2 outputs:result
+		}
+		def Shader "Texture_${ texture.id }_${ mapType }"
+		{
+			uniform token info:id = "UsdUVTexture"
+			asset inputs:file = @textures/Texture_${ id }.png@
+			float2 inputs:st.connect = </Materials/Material_${ material.id }/Transform2d_${ mapType }.outputs:result>
+			${ color !== undefined ? 'float4 inputs:scale = ' + buildColor4( color ) : '' }
+			token inputs:sourceColorSpace = "${ texture.colorSpace === NoColorSpace ? 'raw' : 'sRGB' }"
+			token inputs:wrapS = "${ WRAPPINGS[ texture.wrapS ] }"
+			token inputs:wrapT = "${ WRAPPINGS[ texture.wrapT ] }"
+			float outputs:r
+			float outputs:g
+			float outputs:b
+			float3 outputs:rgb
+			${ material.transparent || material.alphaTest > 0.0 ? 'float outputs:a' : '' }
+		}`;
+	}
+	if ( material.side === DoubleSide ) {
+		console.warn( 'THREE.USDZExporter: USDZ does not support double sided materials', material );
+	}
+	if ( material.map !== null ) {
+		inputs.push( `${ pad }color3f inputs:diffuseColor.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:rgb>` );
+		if ( material.transparent ) {
+			inputs.push( `${ pad }float inputs:opacity.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:a>` );
+		} else if ( material.alphaTest > 0.0 ) {
+			inputs.push( `${ pad }float inputs:opacity.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:a>` );
+			inputs.push( `${ pad }float inputs:opacityThreshold = ${material.alphaTest}` );
+		}
+		samplers.push( buildTexture( material.map, 'diffuse', material.color ) );
+	} else {
+		inputs.push( `${ pad }color3f inputs:diffuseColor = ${ buildColor( material.color ) }` );
+	}
+	if ( material.emissiveMap !== null ) {
+		inputs.push( `${ pad }color3f inputs:emissiveColor.connect = </Materials/Material_${ material.id }/Texture_${ material.emissiveMap.id }_emissive.outputs:rgb>` );
+		samplers.push( buildTexture( material.emissiveMap, 'emissive', new Color( material.emissive.r * material.emissiveIntensity, material.emissive.g * material.emissiveIntensity, material.emissive.b * material.emissiveIntensity ) ) );
+	} else if ( material.emissive.getHex() > 0 ) {
+		inputs.push( `${ pad }color3f inputs:emissiveColor = ${ buildColor( material.emissive ) }` );
+	}
+	if ( material.normalMap !== null ) {
+		inputs.push( `${ pad }normal3f inputs:normal.connect = </Materials/Material_${ material.id }/Texture_${ material.normalMap.id }_normal.outputs:rgb>` );
+		samplers.push( buildTexture( material.normalMap, 'normal' ) );
+	}
+	if ( material.aoMap !== null ) {
+		inputs.push( `${ pad }float inputs:occlusion.connect = </Materials/Material_${ material.id }/Texture_${ material.aoMap.id }_occlusion.outputs:r>` );
+		samplers.push( buildTexture( material.aoMap, 'occlusion', new Color( material.aoMapIntensity, material.aoMapIntensity, material.aoMapIntensity ) ) );
+	}
+	if ( material.roughnessMap !== null ) {
+		inputs.push( `${ pad }float inputs:roughness.connect = </Materials/Material_${ material.id }/Texture_${ material.roughnessMap.id }_roughness.outputs:g>` );
+		samplers.push( buildTexture( material.roughnessMap, 'roughness', new Color( material.roughness, material.roughness, material.roughness ) ) );
+	} else {
+		inputs.push( `${ pad }float inputs:roughness = ${ material.roughness }` );
+	}
+	if ( material.metalnessMap !== null ) {
+		inputs.push( `${ pad }float inputs:metallic.connect = </Materials/Material_${ material.id }/Texture_${ material.metalnessMap.id }_metallic.outputs:b>` );
+		samplers.push( buildTexture( material.metalnessMap, 'metallic', new Color( material.metalness, material.metalness, material.metalness ) ) );
+	} else {
+		inputs.push( `${ pad }float inputs:metallic = ${ material.metalness }` );
+	}
+	if ( material.alphaMap !== null ) {
+		inputs.push( `${pad}float inputs:opacity.connect = </Materials/Material_${material.id}/Texture_${material.alphaMap.id}_opacity.outputs:r>` );
+		inputs.push( `${pad}float inputs:opacityThreshold = 0.0001` );
+		samplers.push( buildTexture( material.alphaMap, 'opacity' ) );
+	} else {
+		inputs.push( `${pad}float inputs:opacity = ${material.opacity}` );
+	}
+	if ( material.isMeshPhysicalMaterial ) {
+		if ( material.clearcoatMap !== null ) {
+			inputs.push( `${pad}float inputs:clearcoat.connect = </Materials/Material_${material.id}/Texture_${material.clearcoatMap.id}_clearcoat.outputs:r>` );
+			samplers.push( buildTexture( material.clearcoatMap, 'clearcoat', new Color( material.clearcoat, material.clearcoat, material.clearcoat ) ) );
+		} else {
+			inputs.push( `${pad}float inputs:clearcoat = ${material.clearcoat}` );
+		}
+		if ( material.clearcoatRoughnessMap !== null ) {
+			inputs.push( `${pad}float inputs:clearcoatRoughness.connect = </Materials/Material_${material.id}/Texture_${material.clearcoatRoughnessMap.id}_clearcoatRoughness.outputs:g>` );
+			samplers.push( buildTexture( material.clearcoatRoughnessMap, 'clearcoatRoughness', new Color( material.clearcoatRoughness, material.clearcoatRoughness, material.clearcoatRoughness ) ) );
+		} else {
+			inputs.push( `${pad}float inputs:clearcoatRoughness = ${material.clearcoatRoughness}` );
+		}
+		inputs.push( `${ pad }float inputs:ior = ${ material.ior }` );
+	}
+	return `
+	def Material "Material_${ material.id }"
+	{
+		def Shader "PreviewSurface"
+		{
+			uniform token info:id = "UsdPreviewSurface"
+${ inputs.join( '\n' ) }
+			int inputs:useSpecularWorkflow = 0
+			token outputs:surface
+		}
+		token outputs:surface.connect = </Materials/Material_${ material.id }/PreviewSurface.outputs:surface>
+${ samplers.join( '\n' ) }
+	}
+`;
+}
+function buildColor( color ) {
+	return `(${ color.r }, ${ color.g }, ${ color.b })`;
+}
+function buildColor4( color ) {
+	return `(${ color.r }, ${ color.g }, ${ color.b }, 1.0)`;
+}
+function buildVector2( vector ) {
+	return `(${ vector.x }, ${ vector.y })`;
+}
+function buildCamera( camera ) {
+	const name = camera.name ? camera.name : 'Camera_' + camera.id;
+	const transform = buildMatrix( camera.matrixWorld );
+	if ( camera.matrixWorld.determinant() < 0 ) {
+		console.warn( 'THREE.USDZExporter: USDZ does not support negative scales', camera );
+	}
+	if ( camera.isOrthographicCamera ) {
+		return `def Camera "${name}"
+		{
+			matrix4d xformOp:transform = ${ transform }
+			uniform token[] xformOpOrder = ["xformOp:transform"]
+			float2 clippingRange = (${ camera.near.toPrecision( PRECISION ) }, ${ camera.far.toPrecision( PRECISION ) })
+			float horizontalAperture = ${ ( ( Math.abs( camera.left ) + Math.abs( camera.right ) ) * 10 ).toPrecision( PRECISION ) }
+			float verticalAperture = ${ ( ( Math.abs( camera.top ) + Math.abs( camera.bottom ) ) * 10 ).toPrecision( PRECISION ) }
+			token projection = "orthographic"
+		}
+	`;
+	} else {
+		return `def Camera "${name}"
+		{
+			matrix4d xformOp:transform = ${ transform }
+			uniform token[] xformOpOrder = ["xformOp:transform"]
+			float2 clippingRange = (${ camera.near.toPrecision( PRECISION ) }, ${ camera.far.toPrecision( PRECISION ) })
+			float focalLength = ${ camera.getFocalLength().toPrecision( PRECISION ) }
+			float focusDistance = ${ camera.focus.toPrecision( PRECISION ) }
+			float horizontalAperture = ${ camera.getFilmWidth().toPrecision( PRECISION ) }
+			token projection = "perspective"
+			float verticalAperture = ${ camera.getFilmHeight().toPrecision( PRECISION ) }
+		}
+	`;
+	}
+}
+export { USDZExporter };

libs/three.js/0.172.0/jsm/geometries/BoxLineGeometry.js ADDED Viewed

	@@ -0,0 +1,69 @@

+import {
+	BufferGeometry,
+	Float32BufferAttribute
+} from 'three';
+class BoxLineGeometry extends BufferGeometry {
+	constructor( width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1 ) {
+		super();
+		widthSegments = Math.floor( widthSegments );
+		heightSegments = Math.floor( heightSegments );
+		depthSegments = Math.floor( depthSegments );
+		const widthHalf = width / 2;
+		const heightHalf = height / 2;
+		const depthHalf = depth / 2;
+		const segmentWidth = width / widthSegments;
+		const segmentHeight = height / heightSegments;
+		const segmentDepth = depth / depthSegments;
+		const vertices = [];
+		let x = - widthHalf;
+		let y = - heightHalf;
+		let z = - depthHalf;
+		for ( let i = 0; i <= widthSegments; i ++ ) {
+			vertices.push( x, - heightHalf, - depthHalf, x, heightHalf, - depthHalf );
+			vertices.push( x, heightHalf, - depthHalf, x, heightHalf, depthHalf );
+			vertices.push( x, heightHalf, depthHalf, x, - heightHalf, depthHalf );
+			vertices.push( x, - heightHalf, depthHalf, x, - heightHalf, - depthHalf );
+			x += segmentWidth;
+		}
+		for ( let i = 0; i <= heightSegments; i ++ ) {
+			vertices.push( - widthHalf, y, - depthHalf, widthHalf, y, - depthHalf );
+			vertices.push( widthHalf, y, - depthHalf, widthHalf, y, depthHalf );
+			vertices.push( widthHalf, y, depthHalf, - widthHalf, y, depthHalf );
+			vertices.push( - widthHalf, y, depthHalf, - widthHalf, y, - depthHalf );
+			y += segmentHeight;
+		}
+		for ( let i = 0; i <= depthSegments; i ++ ) {
+			vertices.push( - widthHalf, - heightHalf, z, - widthHalf, heightHalf, z );
+			vertices.push( - widthHalf, heightHalf, z, widthHalf, heightHalf, z );
+			vertices.push( widthHalf, heightHalf, z, widthHalf, - heightHalf, z );
+			vertices.push( widthHalf, - heightHalf, z, - widthHalf, - heightHalf, z );
+			z += segmentDepth;
+		}
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+	}
+}
+export { BoxLineGeometry };

libs/three.js/0.172.0/jsm/geometries/ConvexGeometry.js ADDED Viewed

	@@ -0,0 +1,53 @@

+import {
+	BufferGeometry,
+	Float32BufferAttribute
+} from 'three';
+import { ConvexHull } from '../math/ConvexHull.js';
+class ConvexGeometry extends BufferGeometry {
+	constructor( points = [] ) {
+		super();
+		// buffers
+		const vertices = [];
+		const normals = [];
+		const convexHull = new ConvexHull().setFromPoints( points );
+		// generate vertices and normals
+		const faces = convexHull.faces;
+		for ( let i = 0; i < faces.length; i ++ ) {
+			const face = faces[ i ];
+			let edge = face.edge;
+			// we move along a doubly-connected edge list to access all face points (see HalfEdge docs)
+			do {
+				const point = edge.head().point;
+				vertices.push( point.x, point.y, point.z );
+				normals.push( face.normal.x, face.normal.y, face.normal.z );
+				edge = edge.next;
+			} while ( edge !== face.edge );
+		}
+		// build geometry
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+	}
+}
+export { ConvexGeometry };

libs/three.js/0.172.0/jsm/geometries/DecalGeometry.js ADDED Viewed

	@@ -0,0 +1,408 @@

+import {
+	BufferGeometry,
+	Euler,
+	Float32BufferAttribute,
+	Matrix3,
+	Matrix4,
+	Mesh,
+	Vector3
+} from 'three';
+/**
+ * You can use this geometry to create a decal mesh, that serves different kinds of purposes.
+ * e.g. adding unique details to models, performing dynamic visual environmental changes or covering seams.
+ *
+ * Constructor parameter:
+ *
+ * mesh — Any mesh object
+ * position — Position of the decal projector
+ * orientation — Orientation of the decal projector
+ * size — Size of the decal projector
+ *
+ * reference: http://blog.wolfire.com/2009/06/how-to-project-decals/
+ *
+ */
+class DecalGeometry extends BufferGeometry {
+	constructor( mesh = new Mesh(), position = new Vector3(), orientation = new Euler(), size = new Vector3( 1, 1, 1 ) ) {
+		super();
+		// buffers
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+		// helpers
+		const plane = new Vector3();
+		const normalMatrix = new Matrix3().getNormalMatrix( mesh.matrixWorld );
+		// this matrix represents the transformation of the decal projector
+		const projectorMatrix = new Matrix4();
+		projectorMatrix.makeRotationFromEuler( orientation );
+		projectorMatrix.setPosition( position );
+		const projectorMatrixInverse = new Matrix4();
+		projectorMatrixInverse.copy( projectorMatrix ).invert();
+		// generate buffers
+		generate();
+		// build geometry
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+		if ( normals.length > 0 ) {
+			this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		}
+		//
+		function generate() {
+			let decalVertices = [];
+			const vertex = new Vector3();
+			const normal = new Vector3();
+			// handle different geometry types
+			const geometry = mesh.geometry;
+			const positionAttribute = geometry.attributes.position;
+			const normalAttribute = geometry.attributes.normal;
+			// first, create an array of 'DecalVertex' objects
+			// three consecutive 'DecalVertex' objects represent a single face
+			//
+			// this data structure will be later used to perform the clipping
+			if ( geometry.index !== null ) {
+				// indexed BufferGeometry
+				const index = geometry.index;
+				for ( let i = 0; i < index.count; i ++ ) {
+					vertex.fromBufferAttribute( positionAttribute, index.getX( i ) );
+					if ( normalAttribute ) {
+						normal.fromBufferAttribute( normalAttribute, index.getX( i ) );
+						pushDecalVertex( decalVertices, vertex, normal );
+					} else {
+						pushDecalVertex( decalVertices, vertex );
+					}
+				}
+			} else {
+				if ( positionAttribute === undefined ) return; // empty geometry
+				// non-indexed BufferGeometry
+				for ( let i = 0; i < positionAttribute.count; i ++ ) {
+					vertex.fromBufferAttribute( positionAttribute, i );
+					if ( normalAttribute ) {
+						normal.fromBufferAttribute( normalAttribute, i );
+						pushDecalVertex( decalVertices, vertex, normal );
+					} else {
+						pushDecalVertex( decalVertices, vertex );
+					}
+				}
+			}
+			// second, clip the geometry so that it doesn't extend out from the projector
+			decalVertices = clipGeometry( decalVertices, plane.set( 1, 0, 0 ) );
+			decalVertices = clipGeometry( decalVertices, plane.set( - 1, 0, 0 ) );
+			decalVertices = clipGeometry( decalVertices, plane.set( 0, 1, 0 ) );
+			decalVertices = clipGeometry( decalVertices, plane.set( 0, - 1, 0 ) );
+			decalVertices = clipGeometry( decalVertices, plane.set( 0, 0, 1 ) );
+			decalVertices = clipGeometry( decalVertices, plane.set( 0, 0, - 1 ) );
+			// third, generate final vertices, normals and uvs
+			for ( let i = 0; i < decalVertices.length; i ++ ) {
+				const decalVertex = decalVertices[ i ];
+				// create texture coordinates (we are still in projector space)
+				uvs.push(
+					0.5 + ( decalVertex.position.x / size.x ),
+					0.5 + ( decalVertex.position.y / size.y )
+				);
+				// transform the vertex back to world space
+				decalVertex.position.applyMatrix4( projectorMatrix );
+				// now create vertex and normal buffer data
+				vertices.push( decalVertex.position.x, decalVertex.position.y, decalVertex.position.z );
+				if ( decalVertex.normal !== null ) {
+					normals.push( decalVertex.normal.x, decalVertex.normal.y, decalVertex.normal.z );
+				}
+			}
+		}
+		function pushDecalVertex( decalVertices, vertex, normal = null ) {
+			// transform the vertex to world space, then to projector space
+			vertex.applyMatrix4( mesh.matrixWorld );
+			vertex.applyMatrix4( projectorMatrixInverse );
+			if ( normal ) {
+				normal.applyNormalMatrix( normalMatrix );
+				decalVertices.push( new DecalVertex( vertex.clone(), normal.clone() ) );
+			} else {
+				decalVertices.push( new DecalVertex( vertex.clone() ) );
+			}
+		}
+		function clipGeometry( inVertices, plane ) {
+			const outVertices = [];
+			const s = 0.5 * Math.abs( size.dot( plane ) );
+			// a single iteration clips one face,
+			// which consists of three consecutive 'DecalVertex' objects
+			for ( let i = 0; i < inVertices.length; i += 3 ) {
+				let total = 0;
+				let nV1;
+				let nV2;
+				let nV3;
+				let nV4;
+				const d1 = inVertices[ i + 0 ].position.dot( plane ) - s;
+				const d2 = inVertices[ i + 1 ].position.dot( plane ) - s;
+				const d3 = inVertices[ i + 2 ].position.dot( plane ) - s;
+				const v1Out = d1 > 0;
+				const v2Out = d2 > 0;
+				const v3Out = d3 > 0;
+				// calculate, how many vertices of the face lie outside of the clipping plane
+				total = ( v1Out ? 1 : 0 ) + ( v2Out ? 1 : 0 ) + ( v3Out ? 1 : 0 );
+				switch ( total ) {
+					case 0: {
+						// the entire face lies inside of the plane, no clipping needed
+						outVertices.push( inVertices[ i ] );
+						outVertices.push( inVertices[ i + 1 ] );
+						outVertices.push( inVertices[ i + 2 ] );
+						break;
+					}
+					case 1: {
+						// one vertex lies outside of the plane, perform clipping
+						if ( v1Out ) {
+							nV1 = inVertices[ i + 1 ];
+							nV2 = inVertices[ i + 2 ];
+							nV3 = clip( inVertices[ i ], nV1, plane, s );
+							nV4 = clip( inVertices[ i ], nV2, plane, s );
+						}
+						if ( v2Out ) {
+							nV1 = inVertices[ i ];
+							nV2 = inVertices[ i + 2 ];
+							nV3 = clip( inVertices[ i + 1 ], nV1, plane, s );
+							nV4 = clip( inVertices[ i + 1 ], nV2, plane, s );
+							outVertices.push( nV3 );
+							outVertices.push( nV2.clone() );
+							outVertices.push( nV1.clone() );
+							outVertices.push( nV2.clone() );
+							outVertices.push( nV3.clone() );
+							outVertices.push( nV4 );
+							break;
+						}
+						if ( v3Out ) {
+							nV1 = inVertices[ i ];
+							nV2 = inVertices[ i + 1 ];
+							nV3 = clip( inVertices[ i + 2 ], nV1, plane, s );
+							nV4 = clip( inVertices[ i + 2 ], nV2, plane, s );
+						}
+						outVertices.push( nV1.clone() );
+						outVertices.push( nV2.clone() );
+						outVertices.push( nV3 );
+						outVertices.push( nV4 );
+						outVertices.push( nV3.clone() );
+						outVertices.push( nV2.clone() );
+						break;
+					}
+					case 2: {
+						// two vertices lies outside of the plane, perform clipping
+						if ( ! v1Out ) {
+							nV1 = inVertices[ i ].clone();
+							nV2 = clip( nV1, inVertices[ i + 1 ], plane, s );
+							nV3 = clip( nV1, inVertices[ i + 2 ], plane, s );
+							outVertices.push( nV1 );
+							outVertices.push( nV2 );
+							outVertices.push( nV3 );
+						}
+						if ( ! v2Out ) {
+							nV1 = inVertices[ i + 1 ].clone();
+							nV2 = clip( nV1, inVertices[ i + 2 ], plane, s );
+							nV3 = clip( nV1, inVertices[ i ], plane, s );
+							outVertices.push( nV1 );
+							outVertices.push( nV2 );
+							outVertices.push( nV3 );
+						}
+						if ( ! v3Out ) {
+							nV1 = inVertices[ i + 2 ].clone();
+							nV2 = clip( nV1, inVertices[ i ], plane, s );
+							nV3 = clip( nV1, inVertices[ i + 1 ], plane, s );
+							outVertices.push( nV1 );
+							outVertices.push( nV2 );
+							outVertices.push( nV3 );
+						}
+						break;
+					}
+					case 3: {
+						// the entire face lies outside of the plane, so let's discard the corresponding vertices
+						break;
+					}
+				}
+			}
+			return outVertices;
+		}
+		function clip( v0, v1, p, s ) {
+			const d0 = v0.position.dot( p ) - s;
+			const d1 = v1.position.dot( p ) - s;
+			const s0 = d0 / ( d0 - d1 );
+			const position = new Vector3(
+				v0.position.x + s0 * ( v1.position.x - v0.position.x ),
+				v0.position.y + s0 * ( v1.position.y - v0.position.y ),
+				v0.position.z + s0 * ( v1.position.z - v0.position.z )
+			);
+			let normal = null;
+			if ( v0.normal !== null && v1.normal !== null ) {
+				normal = new Vector3(
+					v0.normal.x + s0 * ( v1.normal.x - v0.normal.x ),
+					v0.normal.y + s0 * ( v1.normal.y - v0.normal.y ),
+					v0.normal.z + s0 * ( v1.normal.z - v0.normal.z )
+				);
+			}
+			const v = new DecalVertex( position, normal );
+			// need to clip more values (texture coordinates)? do it this way:
+			// intersectpoint.value = a.value + s * ( b.value - a.value );
+			return v;
+		}
+	}
+}
+// helper
+class DecalVertex {
+	constructor( position, normal = null ) {
+		this.position = position;
+		this.normal = normal;
+	}
+	clone() {
+		const position = this.position.clone();
+		const normal = ( this.normal !== null ) ? this.normal.clone() : null;
+		return new this.constructor( position, normal );
+	}
+}
+export { DecalGeometry, DecalVertex };

libs/three.js/0.172.0/jsm/geometries/ParametricGeometries.js ADDED Viewed

	@@ -0,0 +1,254 @@

+import {
+	Curve,
+	Vector3
+} from 'three';
+import { ParametricGeometry } from './ParametricGeometry.js';
+/**
+ * Experimenting of primitive geometry creation using Surface Parametric equations
+ */
+const ParametricGeometries = {
+	klein: function ( v, u, target ) {
+		u *= Math.PI;
+		v *= 2 * Math.PI;
+		u = u * 2;
+		let x, z;
+		if ( u < Math.PI ) {
+			x = 3 * Math.cos( u ) * ( 1 + Math.sin( u ) ) + ( 2 * ( 1 - Math.cos( u ) / 2 ) ) * Math.cos( u ) * Math.cos( v );
+			z = - 8 * Math.sin( u ) - 2 * ( 1 - Math.cos( u ) / 2 ) * Math.sin( u ) * Math.cos( v );
+		} else {
+			x = 3 * Math.cos( u ) * ( 1 + Math.sin( u ) ) + ( 2 * ( 1 - Math.cos( u ) / 2 ) ) * Math.cos( v + Math.PI );
+			z = - 8 * Math.sin( u );
+		}
+		const y = - 2 * ( 1 - Math.cos( u ) / 2 ) * Math.sin( v );
+		target.set( x, y, z );
+	},
+	plane: function ( width, height ) {
+		return function ( u, v, target ) {
+			const x = u * width;
+			const y = 0;
+			const z = v * height;
+			target.set( x, y, z );
+		};
+	},
+	mobius: function ( u, t, target ) {
+		// flat mobius strip
+		// http://www.wolframalpha.com/input/?i=M%C3%B6bius+strip+parametric+equations&lk=1&a=ClashPrefs_*Surface.MoebiusStrip.SurfaceProperty.ParametricEquations-
+		u = u - 0.5;
+		const v = 2 * Math.PI * t;
+		const a = 2;
+		const x = Math.cos( v ) * ( a + u * Math.cos( v / 2 ) );
+		const y = Math.sin( v ) * ( a + u * Math.cos( v / 2 ) );
+		const z = u * Math.sin( v / 2 );
+		target.set( x, y, z );
+	},
+	mobius3d: function ( u, t, target ) {
+		// volumetric mobius strip
+		u *= Math.PI;
+		t *= 2 * Math.PI;
+		u = u * 2;
+		const phi = u / 2;
+		const major = 2.25, a = 0.125, b = 0.65;
+		let x = a * Math.cos( t ) * Math.cos( phi ) - b * Math.sin( t ) * Math.sin( phi );
+		const z = a * Math.cos( t ) * Math.sin( phi ) + b * Math.sin( t ) * Math.cos( phi );
+		const y = ( major + x ) * Math.sin( u );
+		x = ( major + x ) * Math.cos( u );
+		target.set( x, y, z );
+	}
+};
+/*********************************************
+ *
+ * Parametric Replacement for TubeGeometry
+ *
+ *********************************************/
+ParametricGeometries.TubeGeometry = class TubeGeometry extends ParametricGeometry {
+	constructor( path, segments = 64, radius = 1, segmentsRadius = 8, closed = false ) {
+		const numpoints = segments + 1;
+		const frames = path.computeFrenetFrames( segments, closed ),
+			tangents = frames.tangents,
+			normals = frames.normals,
+			binormals = frames.binormals;
+		const position = new Vector3();
+		function ParametricTube( u, v, target ) {
+			v *= 2 * Math.PI;
+			const i = Math.floor( u * ( numpoints - 1 ) );
+			path.getPointAt( u, position );
+			const normal = normals[ i ];
+			const binormal = binormals[ i ];
+			const cx = - radius * Math.cos( v ); // TODO: Hack: Negating it so it faces outside.
+			const cy = radius * Math.sin( v );
+			position.x += cx * normal.x + cy * binormal.x;
+			position.y += cx * normal.y + cy * binormal.y;
+			position.z += cx * normal.z + cy * binormal.z;
+			target.copy( position );
+		}
+		super( ParametricTube, segments, segmentsRadius );
+		// proxy internals
+		this.tangents = tangents;
+		this.normals = normals;
+		this.binormals = binormals;
+		this.path = path;
+		this.segments = segments;
+		this.radius = radius;
+		this.segmentsRadius = segmentsRadius;
+		this.closed = closed;
+	}
+};
+/*********************************************
+  *
+  * Parametric Replacement for TorusKnotGeometry
+  *
+  *********************************************/
+ParametricGeometries.TorusKnotGeometry = class TorusKnotGeometry extends ParametricGeometries.TubeGeometry {
+	constructor( radius = 200, tube = 40, segmentsT = 64, segmentsR = 8, p = 2, q = 3 ) {
+		class TorusKnotCurve extends Curve {
+			getPoint( t, optionalTarget = new Vector3() ) {
+				const point = optionalTarget;
+				t *= Math.PI * 2;
+				const r = 0.5;
+				const x = ( 1 + r * Math.cos( q * t ) ) * Math.cos( p * t );
+				const y = ( 1 + r * Math.cos( q * t ) ) * Math.sin( p * t );
+				const z = r * Math.sin( q * t );
+				return point.set( x, y, z ).multiplyScalar( radius );
+			}
+		}
+		const segments = segmentsT;
+		const radiusSegments = segmentsR;
+		const extrudePath = new TorusKnotCurve();
+		super( extrudePath, segments, tube, radiusSegments, true, false );
+		this.radius = radius;
+		this.tube = tube;
+		this.segmentsT = segmentsT;
+		this.segmentsR = segmentsR;
+		this.p = p;
+		this.q = q;
+	}
+};
+/*********************************************
+  *
+  * Parametric Replacement for SphereGeometry
+  *
+  *********************************************/
+ParametricGeometries.SphereGeometry = class SphereGeometry extends ParametricGeometry {
+	constructor( size, u, v ) {
+		function sphere( u, v, target ) {
+			u *= Math.PI;
+			v *= 2 * Math.PI;
+			const x = size * Math.sin( u ) * Math.cos( v );
+			const y = size * Math.sin( u ) * Math.sin( v );
+			const z = size * Math.cos( u );
+			target.set( x, y, z );
+		}
+		super( sphere, u, v );
+	}
+};
+/*********************************************
+  *
+  * Parametric Replacement for PlaneGeometry
+  *
+  *********************************************/
+ParametricGeometries.PlaneGeometry = class PlaneGeometry extends ParametricGeometry {
+	constructor( width, depth, segmentsWidth, segmentsDepth ) {
+		function plane( u, v, target ) {
+			const x = u * width;
+			const y = 0;
+			const z = v * depth;
+			target.set( x, y, z );
+		}
+		super( plane, segmentsWidth, segmentsDepth );
+	}
+};
+export { ParametricGeometries };

libs/three.js/0.172.0/jsm/geometries/ParametricGeometry.js ADDED Viewed

	@@ -0,0 +1,139 @@

+/**
+ * Parametric Surfaces Geometry
+ * based on the brilliant article by @prideout https://prideout.net/blog/old/blog/index.html@p=44.html
+ */
+import {
+	BufferGeometry,
+	Float32BufferAttribute,
+	Vector3
+} from 'three';
+class ParametricGeometry extends BufferGeometry {
+	constructor( func = ( u, v, target ) => target.set( u, v, Math.cos( u ) * Math.sin( v ) ), slices = 8, stacks = 8 ) {
+		super();
+		this.type = 'ParametricGeometry';
+		this.parameters = {
+			func: func,
+			slices: slices,
+			stacks: stacks
+		};
+		// buffers
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
+		const EPS = 0.00001;
+		const normal = new Vector3();
+		const p0 = new Vector3(), p1 = new Vector3();
+		const pu = new Vector3(), pv = new Vector3();
+		// generate vertices, normals and uvs
+		const sliceCount = slices + 1;
+		for ( let i = 0; i <= stacks; i ++ ) {
+			const v = i / stacks;
+			for ( let j = 0; j <= slices; j ++ ) {
+				const u = j / slices;
+				// vertex
+				func( u, v, p0 );
+				vertices.push( p0.x, p0.y, p0.z );
+				// normal
+				// approximate tangent vectors via finite differences
+				if ( u - EPS >= 0 ) {
+					func( u - EPS, v, p1 );
+					pu.subVectors( p0, p1 );
+				} else {
+					func( u + EPS, v, p1 );
+					pu.subVectors( p1, p0 );
+				}
+				if ( v - EPS >= 0 ) {
+					func( u, v - EPS, p1 );
+					pv.subVectors( p0, p1 );
+				} else {
+					func( u, v + EPS, p1 );
+					pv.subVectors( p1, p0 );
+				}
+				// cross product of tangent vectors returns surface normal
+				normal.crossVectors( pu, pv ).normalize();
+				normals.push( normal.x, normal.y, normal.z );
+				// uv
+				uvs.push( u, v );
+			}
+		}
+		// generate indices
+		for ( let i = 0; i < stacks; i ++ ) {
+			for ( let j = 0; j < slices; j ++ ) {
+				const a = i * sliceCount + j;
+				const b = i * sliceCount + j + 1;
+				const c = ( i + 1 ) * sliceCount + j + 1;
+				const d = ( i + 1 ) * sliceCount + j;
+				// faces one and two
+				indices.push( a, b, d );
+				indices.push( b, c, d );
+			}
+		}
+		// build geometry
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+	}
+	copy( source ) {
+		super.copy( source );
+		this.parameters = Object.assign( {}, source.parameters );
+		return this;
+	}
+}
+export { ParametricGeometry };

libs/three.js/0.172.0/jsm/geometries/RoundedBoxGeometry.js ADDED Viewed

	@@ -0,0 +1,155 @@

+import {
+	BoxGeometry,
+	Vector3
+} from 'three';
+const _tempNormal = new Vector3();
+function getUv( faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength ) {
+	const totArcLength = 2 * Math.PI * radius / 4;
+	// length of the planes between the arcs on each axis
+	const centerLength = Math.max( sideLength - 2 * radius, 0 );
+	const halfArc = Math.PI / 4;
+	// Get the vector projected onto the Y plane
+	_tempNormal.copy( normal );
+	_tempNormal[ projectionAxis ] = 0;
+	_tempNormal.normalize();
+	// total amount of UV space alloted to a single arc
+	const arcUvRatio = 0.5 * totArcLength / ( totArcLength + centerLength );
+	// the distance along one arc the point is at
+	const arcAngleRatio = 1.0 - ( _tempNormal.angleTo( faceDirVector ) / halfArc );
+	if ( Math.sign( _tempNormal[ uvAxis ] ) === 1 ) {
+		return arcAngleRatio * arcUvRatio;
+	} else {
+		// total amount of UV space alloted to the plane between the arcs
+		const lenUv = centerLength / ( totArcLength + centerLength );
+		return lenUv + arcUvRatio + arcUvRatio * ( 1.0 - arcAngleRatio );
+	}
+}
+class RoundedBoxGeometry extends BoxGeometry {
+	constructor( width = 1, height = 1, depth = 1, segments = 2, radius = 0.1 ) {
+		// ensure segments is odd so we have a plane connecting the rounded corners
+		segments = segments * 2 + 1;
+		// ensure radius isn't bigger than shortest side
+		radius = Math.min( width / 2, height / 2, depth / 2, radius );
+		super( 1, 1, 1, segments, segments, segments );
+		// if we just have one segment we're the same as a regular box
+		if ( segments === 1 ) return;
+		const geometry2 = this.toNonIndexed();
+		this.index = null;
+		this.attributes.position = geometry2.attributes.position;
+		this.attributes.normal = geometry2.attributes.normal;
+		this.attributes.uv = geometry2.attributes.uv;
+		//
+		const position = new Vector3();
+		const normal = new Vector3();
+		const box = new Vector3( width, height, depth ).divideScalar( 2 ).subScalar( radius );
+		const positions = this.attributes.position.array;
+		const normals = this.attributes.normal.array;
+		const uvs = this.attributes.uv.array;
+		const faceTris = positions.length / 6;
+		const faceDirVector = new Vector3();
+		const halfSegmentSize = 0.5 / segments;
+		for ( let i = 0, j = 0; i < positions.length; i += 3, j += 2 ) {
+			position.fromArray( positions, i );
+			normal.copy( position );
+			normal.x -= Math.sign( normal.x ) * halfSegmentSize;
+			normal.y -= Math.sign( normal.y ) * halfSegmentSize;
+			normal.z -= Math.sign( normal.z ) * halfSegmentSize;
+			normal.normalize();
+			positions[ i + 0 ] = box.x * Math.sign( position.x ) + normal.x * radius;
+			positions[ i + 1 ] = box.y * Math.sign( position.y ) + normal.y * radius;
+			positions[ i + 2 ] = box.z * Math.sign( position.z ) + normal.z * radius;
+			normals[ i + 0 ] = normal.x;
+			normals[ i + 1 ] = normal.y;
+			normals[ i + 2 ] = normal.z;
+			const side = Math.floor( i / faceTris );
+			switch ( side ) {
+				case 0: // right
+					// generate UVs along Z then Y
+					faceDirVector.set( 1, 0, 0 );
+					uvs[ j + 0 ] = getUv( faceDirVector, normal, 'z', 'y', radius, depth );
+					uvs[ j + 1 ] = 1.0 - getUv( faceDirVector, normal, 'y', 'z', radius, height );
+					break;
+				case 1: // left
+					// generate UVs along Z then Y
+					faceDirVector.set( - 1, 0, 0 );
+					uvs[ j + 0 ] = 1.0 - getUv( faceDirVector, normal, 'z', 'y', radius, depth );
+					uvs[ j + 1 ] = 1.0 - getUv( faceDirVector, normal, 'y', 'z', radius, height );
+					break;
+				case 2: // top
+					// generate UVs along X then Z
+					faceDirVector.set( 0, 1, 0 );
+					uvs[ j + 0 ] = 1.0 - getUv( faceDirVector, normal, 'x', 'z', radius, width );
+					uvs[ j + 1 ] = getUv( faceDirVector, normal, 'z', 'x', radius, depth );
+					break;
+				case 3: // bottom
+					// generate UVs along X then Z
+					faceDirVector.set( 0, - 1, 0 );
+					uvs[ j + 0 ] = 1.0 - getUv( faceDirVector, normal, 'x', 'z', radius, width );
+					uvs[ j + 1 ] = 1.0 - getUv( faceDirVector, normal, 'z', 'x', radius, depth );
+					break;
+				case 4: // front
+					// generate UVs along X then Y
+					faceDirVector.set( 0, 0, 1 );
+					uvs[ j + 0 ] = 1.0 - getUv( faceDirVector, normal, 'x', 'y', radius, width );
+					uvs[ j + 1 ] = 1.0 - getUv( faceDirVector, normal, 'y', 'x', radius, height );
+					break;
+				case 5: // back
+					// generate UVs along X then Y
+					faceDirVector.set( 0, 0, - 1 );
+					uvs[ j + 0 ] = getUv( faceDirVector, normal, 'x', 'y', radius, width );
+					uvs[ j + 1 ] = 1.0 - getUv( faceDirVector, normal, 'y', 'x', radius, height );
+					break;
+			}
+		}
+	}
+}
+export { RoundedBoxGeometry };

libs/three.js/0.172.0/jsm/geometries/TeapotGeometry.js ADDED Viewed

	@@ -0,0 +1,704 @@

+import {
+	BufferAttribute,
+	BufferGeometry,
+	Matrix4,
+	Vector3,
+	Vector4
+} from 'three';
+/**
+ * Tessellates the famous Utah teapot database by Martin Newell into triangles.
+ *
+ * Parameters: size = 50, segments = 10, bottom = true, lid = true, body = true,
+ *   fitLid = true, blinn = true
+ *
+ * size is a relative scale: I've scaled the teapot to fit vertically between -1 and 1.
+ * Think of it as a "radius".
+ * segments - number of line segments to subdivide each patch edge;
+ *   1 is possible but gives degenerates, so two is the real minimum.
+ * bottom - boolean, if true (default) then the bottom patches are added. Some consider
+ *   adding the bottom heresy, so set this to "false" to adhere to the One True Way.
+ * lid - to remove the lid and look inside, set to true.
+ * body - to remove the body and leave the lid, set this and "bottom" to false.
+ * fitLid - the lid is a tad small in the original. This stretches it a bit so you can't
+ *   see the teapot's insides through the gap.
+ * blinn - Jim Blinn scaled the original data vertically by dividing by about 1.3 to look
+ *   nicer. If you want to see the original teapot, similar to the real-world model, set
+ *   this to false. True by default.
+ *   See http://en.wikipedia.org/wiki/File:Original_Utah_Teapot.jpg for the original
+ *   real-world teapot (from http://en.wikipedia.org/wiki/Utah_teapot).
+ *
+ * Note that the bottom (the last four patches) is not flat - blame Frank Crow, not me.
+ *
+ * The teapot should normally be rendered as a double sided object, since for some
+ * patches both sides can be seen, e.g., the gap around the lid and inside the spout.
+ *
+ * Segments 'n' determines the number of triangles output.
+ *   Total triangles = 32*2*n*n - 8*n    [degenerates at the top and bottom cusps are deleted]
+ *
+ *   size_factor   # triangles
+ *       1          56
+ *       2         240
+ *       3         552
+ *       4         992
+ *
+ *      10        6320
+ *      20       25440
+ *      30       57360
+ *
+ * Code converted from my ancient SPD software, http://tog.acm.org/resources/SPD/
+ * Created for the Udacity course "Interactive Rendering", http://bit.ly/ericity
+ * YouTube video on teapot history: https://www.youtube.com/watch?v=DxMfblPzFNc
+ *
+ * See https://en.wikipedia.org/wiki/Utah_teapot for the history of the teapot
+ *
+ */
+class TeapotGeometry extends BufferGeometry {
+	constructor( size = 50, segments = 10, bottom = true, lid = true, body = true, fitLid = true, blinn = true ) {
+		// 32 * 4 * 4 Bezier spline patches
+		const teapotPatches = [
+			/*rim*/
+			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+			3, 16, 17, 18, 7, 19, 20, 21, 11, 22, 23, 24, 15, 25, 26, 27,
+			18, 28, 29, 30, 21, 31, 32, 33, 24, 34, 35, 36, 27, 37, 38, 39,
+			30, 40, 41, 0, 33, 42, 43, 4, 36, 44, 45, 8, 39, 46, 47, 12,
+			/*body*/
+			12, 13, 14, 15, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+			15, 25, 26, 27, 51, 60, 61, 62, 55, 63, 64, 65, 59, 66, 67, 68,
+			27, 37, 38, 39, 62, 69, 70, 71, 65, 72, 73, 74, 68, 75, 76, 77,
+			39, 46, 47, 12, 71, 78, 79, 48, 74, 80, 81, 52, 77, 82, 83, 56,
+			56, 57, 58, 59, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+			59, 66, 67, 68, 87, 96, 97, 98, 91, 99, 100, 101, 95, 102, 103, 104,
+			68, 75, 76, 77, 98, 105, 106, 107, 101, 108, 109, 110, 104, 111, 112, 113,
+			77, 82, 83, 56, 107, 114, 115, 84, 110, 116, 117, 88, 113, 118, 119, 92,
+			/*handle*/
+			120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
+			123, 136, 137, 120, 127, 138, 139, 124, 131, 140, 141, 128, 135, 142, 143, 132,
+			132, 133, 134, 135, 144, 145, 146, 147, 148, 149, 150, 151, 68, 152, 153, 154,
+			135, 142, 143, 132, 147, 155, 156, 144, 151, 157, 158, 148, 154, 159, 160, 68,
+			/*spout*/
+			161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,
+			164, 177, 178, 161, 168, 179, 180, 165, 172, 181, 182, 169, 176, 183, 184, 173,
+			173, 174, 175, 176, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196,
+			176, 183, 184, 173, 188, 197, 198, 185, 192, 199, 200, 189, 196, 201, 202, 193,
+			/*lid*/
+			203, 203, 203, 203, 204, 205, 206, 207, 208, 208, 208, 208, 209, 210, 211, 212,
+			203, 203, 203, 203, 207, 213, 214, 215, 208, 208, 208, 208, 212, 216, 217, 218,
+			203, 203, 203, 203, 215, 219, 220, 221, 208, 208, 208, 208, 218, 222, 223, 224,
+			203, 203, 203, 203, 221, 225, 226, 204, 208, 208, 208, 208, 224, 227, 228, 209,
+			209, 210, 211, 212, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240,
+			212, 216, 217, 218, 232, 241, 242, 243, 236, 244, 245, 246, 240, 247, 248, 249,
+			218, 222, 223, 224, 243, 250, 251, 252, 246, 253, 254, 255, 249, 256, 257, 258,
+			224, 227, 228, 209, 252, 259, 260, 229, 255, 261, 262, 233, 258, 263, 264, 237,
+			/*bottom*/
+			265, 265, 265, 265, 266, 267, 268, 269, 270, 271, 272, 273, 92, 119, 118, 113,
+			265, 265, 265, 265, 269, 274, 275, 276, 273, 277, 278, 279, 113, 112, 111, 104,
+			265, 265, 265, 265, 276, 280, 281, 282, 279, 283, 284, 285, 104, 103, 102, 95,
+			265, 265, 265, 265, 282, 286, 287, 266, 285, 288, 289, 270, 95, 94, 93, 92
+		];
+		const teapotVertices = [
+			1.4, 0, 2.4,
+			1.4, - 0.784, 2.4,
+			0.784, - 1.4, 2.4,
+			0, - 1.4, 2.4,
+			1.3375, 0, 2.53125,
+			1.3375, - 0.749, 2.53125,
+			0.749, - 1.3375, 2.53125,
+			0, - 1.3375, 2.53125,
+			1.4375, 0, 2.53125,
+			1.4375, - 0.805, 2.53125,
+			0.805, - 1.4375, 2.53125,
+			0, - 1.4375, 2.53125,
+			1.5, 0, 2.4,
+			1.5, - 0.84, 2.4,
+			0.84, - 1.5, 2.4,
+			0, - 1.5, 2.4,
+			- 0.784, - 1.4, 2.4,
+			- 1.4, - 0.784, 2.4,
+			- 1.4, 0, 2.4,
+			- 0.749, - 1.3375, 2.53125,
+			- 1.3375, - 0.749, 2.53125,
+			- 1.3375, 0, 2.53125,
+			- 0.805, - 1.4375, 2.53125,
+			- 1.4375, - 0.805, 2.53125,
+			- 1.4375, 0, 2.53125,
+			- 0.84, - 1.5, 2.4,
+			- 1.5, - 0.84, 2.4,
+			- 1.5, 0, 2.4,
+			- 1.4, 0.784, 2.4,
+			- 0.784, 1.4, 2.4,
+			0, 1.4, 2.4,
+			- 1.3375, 0.749, 2.53125,
+			- 0.749, 1.3375, 2.53125,
+			0, 1.3375, 2.53125,
+			- 1.4375, 0.805, 2.53125,
+			- 0.805, 1.4375, 2.53125,
+			0, 1.4375, 2.53125,
+			- 1.5, 0.84, 2.4,
+			- 0.84, 1.5, 2.4,
+			0, 1.5, 2.4,
+			0.784, 1.4, 2.4,
+			1.4, 0.784, 2.4,
+			0.749, 1.3375, 2.53125,
+			1.3375, 0.749, 2.53125,
+			0.805, 1.4375, 2.53125,
+			1.4375, 0.805, 2.53125,
+			0.84, 1.5, 2.4,
+			1.5, 0.84, 2.4,
+			1.75, 0, 1.875,
+			1.75, - 0.98, 1.875,
+			0.98, - 1.75, 1.875,
+			0, - 1.75, 1.875,
+			2, 0, 1.35,
+			2, - 1.12, 1.35,
+			1.12, - 2, 1.35,
+			0, - 2, 1.35,
+			2, 0, 0.9,
+			2, - 1.12, 0.9,
+			1.12, - 2, 0.9,
+			0, - 2, 0.9,
+			- 0.98, - 1.75, 1.875,
+			- 1.75, - 0.98, 1.875,
+			- 1.75, 0, 1.875,
+			- 1.12, - 2, 1.35,
+			- 2, - 1.12, 1.35,
+			- 2, 0, 1.35,
+			- 1.12, - 2, 0.9,
+			- 2, - 1.12, 0.9,
+			- 2, 0, 0.9,
+			- 1.75, 0.98, 1.875,
+			- 0.98, 1.75, 1.875,
+			0, 1.75, 1.875,
+			- 2, 1.12, 1.35,
+			- 1.12, 2, 1.35,
+			0, 2, 1.35,
+			- 2, 1.12, 0.9,
+			- 1.12, 2, 0.9,
+			0, 2, 0.9,
+			0.98, 1.75, 1.875,
+			1.75, 0.98, 1.875,
+			1.12, 2, 1.35,
+			2, 1.12, 1.35,
+			1.12, 2, 0.9,
+			2, 1.12, 0.9,
+			2, 0, 0.45,
+			2, - 1.12, 0.45,
+			1.12, - 2, 0.45,
+			0, - 2, 0.45,
+			1.5, 0, 0.225,
+			1.5, - 0.84, 0.225,
+			0.84, - 1.5, 0.225,
+			0, - 1.5, 0.225,
+			1.5, 0, 0.15,
+			1.5, - 0.84, 0.15,
+			0.84, - 1.5, 0.15,
+			0, - 1.5, 0.15,
+			- 1.12, - 2, 0.45,
+			- 2, - 1.12, 0.45,
+			- 2, 0, 0.45,
+			- 0.84, - 1.5, 0.225,
+			- 1.5, - 0.84, 0.225,
+			- 1.5, 0, 0.225,
+			- 0.84, - 1.5, 0.15,
+			- 1.5, - 0.84, 0.15,
+			- 1.5, 0, 0.15,
+			- 2, 1.12, 0.45,
+			- 1.12, 2, 0.45,
+			0, 2, 0.45,
+			- 1.5, 0.84, 0.225,
+			- 0.84, 1.5, 0.225,
+			0, 1.5, 0.225,
+			- 1.5, 0.84, 0.15,
+			- 0.84, 1.5, 0.15,
+			0, 1.5, 0.15,
+			1.12, 2, 0.45,
+			2, 1.12, 0.45,
+			0.84, 1.5, 0.225,
+			1.5, 0.84, 0.225,
+			0.84, 1.5, 0.15,
+			1.5, 0.84, 0.15,
+			- 1.6, 0, 2.025,
+			- 1.6, - 0.3, 2.025,
+			- 1.5, - 0.3, 2.25,
+			- 1.5, 0, 2.25,
+			- 2.3, 0, 2.025,
+			- 2.3, - 0.3, 2.025,
+			- 2.5, - 0.3, 2.25,
+			- 2.5, 0, 2.25,
+			- 2.7, 0, 2.025,
+			- 2.7, - 0.3, 2.025,
+			- 3, - 0.3, 2.25,
+			- 3, 0, 2.25,
+			- 2.7, 0, 1.8,
+			- 2.7, - 0.3, 1.8,
+			- 3, - 0.3, 1.8,
+			- 3, 0, 1.8,
+			- 1.5, 0.3, 2.25,
+			- 1.6, 0.3, 2.025,
+			- 2.5, 0.3, 2.25,
+			- 2.3, 0.3, 2.025,
+			- 3, 0.3, 2.25,
+			- 2.7, 0.3, 2.025,
+			- 3, 0.3, 1.8,
+			- 2.7, 0.3, 1.8,
+			- 2.7, 0, 1.575,
+			- 2.7, - 0.3, 1.575,
+			- 3, - 0.3, 1.35,
+			- 3, 0, 1.35,
+			- 2.5, 0, 1.125,
+			- 2.5, - 0.3, 1.125,
+			- 2.65, - 0.3, 0.9375,
+			- 2.65, 0, 0.9375,
+			- 2, - 0.3, 0.9,
+			- 1.9, - 0.3, 0.6,
+			- 1.9, 0, 0.6,
+			- 3, 0.3, 1.35,
+			- 2.7, 0.3, 1.575,
+			- 2.65, 0.3, 0.9375,
+			- 2.5, 0.3, 1.125,
+			- 1.9, 0.3, 0.6,
+			- 2, 0.3, 0.9,
+			1.7, 0, 1.425,
+			1.7, - 0.66, 1.425,
+			1.7, - 0.66, 0.6,
+			1.7, 0, 0.6,
+			2.6, 0, 1.425,
+			2.6, - 0.66, 1.425,
+			3.1, - 0.66, 0.825,
+			3.1, 0, 0.825,
+			2.3, 0, 2.1,
+			2.3, - 0.25, 2.1,
+			2.4, - 0.25, 2.025,
+			2.4, 0, 2.025,
+			2.7, 0, 2.4,
+			2.7, - 0.25, 2.4,
+			3.3, - 0.25, 2.4,
+			3.3, 0, 2.4,
+			1.7, 0.66, 0.6,
+			1.7, 0.66, 1.425,
+			3.1, 0.66, 0.825,
+			2.6, 0.66, 1.425,
+			2.4, 0.25, 2.025,
+			2.3, 0.25, 2.1,
+			3.3, 0.25, 2.4,
+			2.7, 0.25, 2.4,
+			2.8, 0, 2.475,
+			2.8, - 0.25, 2.475,
+			3.525, - 0.25, 2.49375,
+			3.525, 0, 2.49375,
+			2.9, 0, 2.475,
+			2.9, - 0.15, 2.475,
+			3.45, - 0.15, 2.5125,
+			3.45, 0, 2.5125,
+			2.8, 0, 2.4,
+			2.8, - 0.15, 2.4,
+			3.2, - 0.15, 2.4,
+			3.2, 0, 2.4,
+			3.525, 0.25, 2.49375,
+			2.8, 0.25, 2.475,
+			3.45, 0.15, 2.5125,
+			2.9, 0.15, 2.475,
+			3.2, 0.15, 2.4,
+			2.8, 0.15, 2.4,
+			0, 0, 3.15,
+			0.8, 0, 3.15,
+			0.8, - 0.45, 3.15,
+			0.45, - 0.8, 3.15,
+			0, - 0.8, 3.15,
+			0, 0, 2.85,
+			0.2, 0, 2.7,
+			0.2, - 0.112, 2.7,
+			0.112, - 0.2, 2.7,
+			0, - 0.2, 2.7,
+			- 0.45, - 0.8, 3.15,
+			- 0.8, - 0.45, 3.15,
+			- 0.8, 0, 3.15,
+			- 0.112, - 0.2, 2.7,
+			- 0.2, - 0.112, 2.7,
+			- 0.2, 0, 2.7,
+			- 0.8, 0.45, 3.15,
+			- 0.45, 0.8, 3.15,
+			0, 0.8, 3.15,
+			- 0.2, 0.112, 2.7,
+			- 0.112, 0.2, 2.7,
+			0, 0.2, 2.7,
+			0.45, 0.8, 3.15,
+			0.8, 0.45, 3.15,
+			0.112, 0.2, 2.7,
+			0.2, 0.112, 2.7,
+			0.4, 0, 2.55,
+			0.4, - 0.224, 2.55,
+			0.224, - 0.4, 2.55,
+			0, - 0.4, 2.55,
+			1.3, 0, 2.55,
+			1.3, - 0.728, 2.55,
+			0.728, - 1.3, 2.55,
+			0, - 1.3, 2.55,
+			1.3, 0, 2.4,
+			1.3, - 0.728, 2.4,
+			0.728, - 1.3, 2.4,
+			0, - 1.3, 2.4,
+			- 0.224, - 0.4, 2.55,
+			- 0.4, - 0.224, 2.55,
+			- 0.4, 0, 2.55,
+			- 0.728, - 1.3, 2.55,
+			- 1.3, - 0.728, 2.55,
+			- 1.3, 0, 2.55,
+			- 0.728, - 1.3, 2.4,
+			- 1.3, - 0.728, 2.4,
+			- 1.3, 0, 2.4,
+			- 0.4, 0.224, 2.55,
+			- 0.224, 0.4, 2.55,
+			0, 0.4, 2.55,
+			- 1.3, 0.728, 2.55,
+			- 0.728, 1.3, 2.55,
+			0, 1.3, 2.55,
+			- 1.3, 0.728, 2.4,
+			- 0.728, 1.3, 2.4,
+			0, 1.3, 2.4,
+			0.224, 0.4, 2.55,
+			0.4, 0.224, 2.55,
+			0.728, 1.3, 2.55,
+			1.3, 0.728, 2.55,
+			0.728, 1.3, 2.4,
+			1.3, 0.728, 2.4,
+			0, 0, 0,
+			1.425, 0, 0,
+			1.425, 0.798, 0,
+			0.798, 1.425, 0,
+			0, 1.425, 0,
+			1.5, 0, 0.075,
+			1.5, 0.84, 0.075,
+			0.84, 1.5, 0.075,
+			0, 1.5, 0.075,
+			- 0.798, 1.425, 0,
+			- 1.425, 0.798, 0,
+			- 1.425, 0, 0,
+			- 0.84, 1.5, 0.075,
+			- 1.5, 0.84, 0.075,
+			- 1.5, 0, 0.075,
+			- 1.425, - 0.798, 0,
+			- 0.798, - 1.425, 0,
+			0, - 1.425, 0,
+			- 1.5, - 0.84, 0.075,
+			- 0.84, - 1.5, 0.075,
+			0, - 1.5, 0.075,
+			0.798, - 1.425, 0,
+			1.425, - 0.798, 0,
+			0.84, - 1.5, 0.075,
+			1.5, - 0.84, 0.075
+		];
+		super();
+		// number of segments per patch
+		segments = Math.max( 2, Math.floor( segments ) );
+		// Jim Blinn scaled the teapot down in size by about 1.3 for
+		// some rendering tests. He liked the new proportions that he kept
+		// the data in this form. The model was distributed with these new
+		// proportions and became the norm. Trivia: comparing images of the
+		// real teapot and the computer model, the ratio for the bowl of the
+		// real teapot is more like 1.25, but since 1.3 is the traditional
+		// value given, we use it here.
+		const blinnScale = 1.3;
+		// scale the size to be the real scaling factor
+		const maxHeight = 3.15 * ( blinn ? 1 : blinnScale );
+		const maxHeight2 = maxHeight / 2;
+		const trueSize = size / maxHeight2;
+		// Number of elements depends on what is needed. Subtract degenerate
+		// triangles at tip of bottom and lid out in advance.
+		let numTriangles = bottom ? ( 8 * segments - 4 ) * segments : 0;
+		numTriangles += lid ? ( 16 * segments - 4 ) * segments : 0;
+		numTriangles += body ? 40 * segments * segments : 0;
+		const indices = new Uint32Array( numTriangles * 3 );
+		let numVertices = bottom ? 4 : 0;
+		numVertices += lid ? 8 : 0;
+		numVertices += body ? 20 : 0;
+		numVertices *= ( segments + 1 ) * ( segments + 1 );
+		const vertices = new Float32Array( numVertices * 3 );
+		const normals = new Float32Array( numVertices * 3 );
+		const uvs = new Float32Array( numVertices * 2 );
+		// Bezier form
+		const ms = new Matrix4();
+		ms.set(
+			- 1.0, 3.0, - 3.0, 1.0,
+			3.0, - 6.0, 3.0, 0.0,
+			- 3.0, 3.0, 0.0, 0.0,
+			1.0, 0.0, 0.0, 0.0 );
+		const g = [];
+		const sp = [];
+		const tp = [];
+		const dsp = [];
+		const dtp = [];
+		// M * G * M matrix, sort of see
+		// http://www.cs.helsinki.fi/group/goa/mallinnus/curves/surfaces.html
+		const mgm = [];
+		const vert = [];
+		const sdir = [];
+		const tdir = [];
+		const norm = new Vector3();
+		let tcoord;
+		let sval;
+		let tval;
+		let p;
+		let dsval = 0;
+		let dtval = 0;
+		const normOut = new Vector3();
+		const gmx = new Matrix4();
+		const tmtx = new Matrix4();
+		const vsp = new Vector4();
+		const vtp = new Vector4();
+		const vdsp = new Vector4();
+		const vdtp = new Vector4();
+		const vsdir = new Vector3();
+		const vtdir = new Vector3();
+		const mst = ms.clone();
+		mst.transpose();
+		// internal function: test if triangle has any matching vertices;
+		// if so, don't save triangle, since it won't display anything.
+		const notDegenerate = ( vtx1, vtx2, vtx3 ) => // if any vertex matches, return false
+			! ( ( ( vertices[ vtx1 * 3 ] === vertices[ vtx2 * 3 ] ) &&
+					( vertices[ vtx1 * 3 + 1 ] === vertices[ vtx2 * 3 + 1 ] ) &&
+					( vertices[ vtx1 * 3 + 2 ] === vertices[ vtx2 * 3 + 2 ] ) ) ||
+					( ( vertices[ vtx1 * 3 ] === vertices[ vtx3 * 3 ] ) &&
+					( vertices[ vtx1 * 3 + 1 ] === vertices[ vtx3 * 3 + 1 ] ) &&
+					( vertices[ vtx1 * 3 + 2 ] === vertices[ vtx3 * 3 + 2 ] ) ) || ( vertices[ vtx2 * 3 ] === vertices[ vtx3 * 3 ] ) &&
+					( vertices[ vtx2 * 3 + 1 ] === vertices[ vtx3 * 3 + 1 ] ) &&
+					( vertices[ vtx2 * 3 + 2 ] === vertices[ vtx3 * 3 + 2 ] ) );
+		for ( let i = 0; i < 3; i ++ ) {
+			mgm[ i ] = new Matrix4();
+		}
+		const minPatches = body ? 0 : 20;
+		const maxPatches = bottom ? 32 : 28;
+		const vertPerRow = segments + 1;
+		let surfCount = 0;
+		let vertCount = 0;
+		let normCount = 0;
+		let uvCount = 0;
+		let indexCount = 0;
+		for ( let surf = minPatches; surf < maxPatches; surf ++ ) {
+			// lid is in the middle of the data, patches 20-27,
+			// so ignore it for this part of the loop if the lid is not desired
+			if ( lid || ( surf < 20 || surf >= 28 ) ) {
+				// get M * G * M matrix for x,y,z
+				for ( let i = 0; i < 3; i ++ ) {
+					// get control patches
+					for ( let r = 0; r < 4; r ++ ) {
+						for ( let c = 0; c < 4; c ++ ) {
+							// transposed
+							g[ c * 4 + r ] = teapotVertices[ teapotPatches[ surf * 16 + r * 4 + c ] * 3 + i ];
+							// is the lid to be made larger, and is this a point on the lid
+							// that is X or Y?
+							if ( fitLid && ( surf >= 20 && surf < 28 ) && ( i !== 2 ) ) {
+								// increase XY size by 7.7%, found empirically. I don't
+								// increase Z so that the teapot will continue to fit in the
+								// space -1 to 1 for Y (Y is up for the final model).
+								g[ c * 4 + r ] *= 1.077;
+							}
+							// Blinn "fixed" the teapot by dividing Z by blinnScale, and that's the
+							// data we now use. The original teapot is taller. Fix it:
+							if ( ! blinn && ( i === 2 ) ) {
+								g[ c * 4 + r ] *= blinnScale;
+							}
+						}
+					}
+					gmx.set( g[ 0 ], g[ 1 ], g[ 2 ], g[ 3 ], g[ 4 ], g[ 5 ], g[ 6 ], g[ 7 ], g[ 8 ], g[ 9 ], g[ 10 ], g[ 11 ], g[ 12 ], g[ 13 ], g[ 14 ], g[ 15 ] );
+					tmtx.multiplyMatrices( gmx, ms );
+					mgm[ i ].multiplyMatrices( mst, tmtx );
+				}
+				// step along, get points, and output
+				for ( let sstep = 0; sstep <= segments; sstep ++ ) {
+					const s = sstep / segments;
+					for ( let tstep = 0; tstep <= segments; tstep ++ ) {
+						const t = tstep / segments;
+						// point from basis
+						// get power vectors and their derivatives
+						for ( p = 4, sval = tval = 1.0; p --; ) {
+							sp[ p ] = sval;
+							tp[ p ] = tval;
+							sval *= s;
+							tval *= t;
+							if ( p === 3 ) {
+								dsp[ p ] = dtp[ p ] = 0.0;
+								dsval = dtval = 1.0;
+							} else {
+								dsp[ p ] = dsval * ( 3 - p );
+								dtp[ p ] = dtval * ( 3 - p );
+								dsval *= s;
+								dtval *= t;
+							}
+						}
+						vsp.fromArray( sp );
+						vtp.fromArray( tp );
+						vdsp.fromArray( dsp );
+						vdtp.fromArray( dtp );
+						// do for x,y,z
+						for ( let i = 0; i < 3; i ++ ) {
+							// multiply power vectors times matrix to get value
+							tcoord = vsp.clone();
+							tcoord.applyMatrix4( mgm[ i ] );
+							vert[ i ] = tcoord.dot( vtp );
+							// get s and t tangent vectors
+							tcoord = vdsp.clone();
+							tcoord.applyMatrix4( mgm[ i ] );
+							sdir[ i ] = tcoord.dot( vtp );
+							tcoord = vsp.clone();
+							tcoord.applyMatrix4( mgm[ i ] );
+							tdir[ i ] = tcoord.dot( vdtp );
+						}
+						// find normal
+						vsdir.fromArray( sdir );
+						vtdir.fromArray( tdir );
+						norm.crossVectors( vtdir, vsdir );
+						norm.normalize();
+						// if X and Z length is 0, at the cusp, so point the normal up or down, depending on patch number
+						if ( vert[ 0 ] === 0 && vert[ 1 ] === 0 ) {
+							// if above the middle of the teapot, normal points up, else down
+							normOut.set( 0, vert[ 2 ] > maxHeight2 ? 1 : - 1, 0 );
+						} else {
+							// standard output: rotate on X axis
+							normOut.set( norm.x, norm.z, - norm.y );
+						}
+						// store it all
+						vertices[ vertCount ++ ] = trueSize * vert[ 0 ];
+						vertices[ vertCount ++ ] = trueSize * ( vert[ 2 ] - maxHeight2 );
+						vertices[ vertCount ++ ] = - trueSize * vert[ 1 ];
+						normals[ normCount ++ ] = normOut.x;
+						normals[ normCount ++ ] = normOut.y;
+						normals[ normCount ++ ] = normOut.z;
+						uvs[ uvCount ++ ] = 1 - t;
+						uvs[ uvCount ++ ] = 1 - s;
+					}
+				}
+				// save the faces
+				for ( let sstep = 0; sstep < segments; sstep ++ ) {
+					for ( let tstep = 0; tstep < segments; tstep ++ ) {
+						const v1 = surfCount * vertPerRow * vertPerRow + sstep * vertPerRow + tstep;
+						const v2 = v1 + 1;
+						const v3 = v2 + vertPerRow;
+						const v4 = v1 + vertPerRow;
+						// Normals and UVs cannot be shared. Without clone(), you can see the consequences
+						// of sharing if you call geometry.applyMatrix4( matrix ).
+						if ( notDegenerate( v1, v2, v3 ) ) {
+							indices[ indexCount ++ ] = v1;
+							indices[ indexCount ++ ] = v2;
+							indices[ indexCount ++ ] = v3;
+						}
+						if ( notDegenerate( v1, v3, v4 ) ) {
+							indices[ indexCount ++ ] = v1;
+							indices[ indexCount ++ ] = v3;
+							indices[ indexCount ++ ] = v4;
+						}
+					}
+				}
+				// increment only if a surface was used
+				surfCount ++;
+			}
+		}
+		this.setIndex( new BufferAttribute( indices, 1 ) );
+		this.setAttribute( 'position', new BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new BufferAttribute( uvs, 2 ) );
+		this.computeBoundingSphere();
+	}
+}
+export { TeapotGeometry };

libs/three.js/0.172.0/jsm/geometries/TextGeometry.js ADDED Viewed

	@@ -0,0 +1,54 @@

+/**
+ * Text = 3D Text
+ *
+ * parameters = {
+ *  font: <THREE.Font>, // font
+ *
+ *  size: <float>, // size of the text
+ *  depth: <float>, // thickness to extrude text
+ *  curveSegments: <int>, // number of points on the curves
+ *
+ *  bevelEnabled: <bool>, // turn on bevel
+ *  bevelThickness: <float>, // how deep into text bevel goes
+ *  bevelSize: <float>, // how far from text outline (including bevelOffset) is bevel
+ *  bevelOffset: <float> // how far from text outline does bevel start
+ * }
+ */
+import {
+	ExtrudeGeometry
+} from 'three';
+class TextGeometry extends ExtrudeGeometry {
+	constructor( text, parameters = {} ) {
+		const font = parameters.font;
+		if ( font === undefined ) {
+			super(); // generate default extrude geometry
+		} else {
+			const shapes = font.generateShapes( text, parameters.size );
+			// defaults
+			if ( parameters.depth === undefined ) parameters.depth = 50;
+			if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;
+			if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;
+			if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;
+			super( shapes, parameters );
+		}
+		this.type = 'TextGeometry';
+	}
+}
+export { TextGeometry };