@meimu/mutracer 0.0.0-stage → 0.1.1

package/lib/util/fromTHREE.js

@@ -0,0 +1,1111 @@
+import { specularAnisotropyModelIndex } from '../scene/anisotropyParameters.js';
+import { normalizeMaterialParams } from '../scene/openPbrSchema.js';
+import { thinFilmMapChannelIndex } from '../scene/thinFilmParameters.js';
+import { snapshotMaterialParameters, materialParametersEqual } from '../renderer/sceneChangeDetector.js';
+import InstancedMesh from '../scene/InstancedMesh.js';
+import Sync from '../Sync.js';
+import { markDeformedGeometry } from '../scene/geometryChanges.js';
+import Mesh from '../scene/Mesh.js';
+import OpenPBRMaterial, { getMaterialHashKey, materialKeys } from '../scene/OpenPBRMaterial.js';
+import Geometry, { Attribute } from '../scene/Geometry.js';
+import Texture from '../scene/Texture.js';
+import DirectionalLight from '../scene/DirectionalLight.js';
+import AmbientLight from '../scene/AmbientLight.js';
+import EnvironmentLight from '../scene/EnvironmentLight.js';
+import RectLight from '../scene/RectLight.js';
+import SphereLight from '../scene/SphereLight.js';
+import SpotLight from '../scene/SpotLight.js';
+import IESProfile from '../scene/IESProfile.js';
+import Camera from '../scene/Camera.js';
+import { mat4 } from '../math.js';
+import { generateVertexNormals, updateBoundingBox, updateDynamicTangents } from './geometry.js';
+import { THREEDeformation, isDeformingMesh } from './threeDeformation.js';
+import { snapshotsEqual, snapshotFields } from '../renderer/sceneChangeDetector.js';
+function convertTexture(threeTexture, textureStore) {
+    if (!threeTexture)
+        return;
+    const state = [threeTexture.version, threeTexture.image, threeTexture.flipY,
+        threeTexture.repeat.x, threeTexture.repeat.y, threeTexture.offset.x,
+        threeTexture.offset.y, threeTexture.channel];
+    const cached = textureStore.get(threeTexture);
+    if (cached && snapshotsEqual(cached.state, state))
+        return cached.texture;
+    const image = threeTexture.image;
+    const texture = cached?.texture ?? new Texture(image);
+    texture.image = image;
+    texture.source = threeTexture;
+    texture.flipY = threeTexture.flipY;
+    texture.uvScale = [threeTexture.repeat.x, threeTexture.repeat.y];
+    texture.uvOffset = [threeTexture.offset.x, threeTexture.offset.y];
+    texture.uvChannel = threeTexture.channel === 1 ? 1 : 0;
+    if (cached)
+        texture.markUpdated();
+    else
+        texture.version = threeTexture.version;
+    textureStore.set(threeTexture, { texture, state });
+    return texture;
+}
+function halfFloatToFloat(value) {
+    const sign = value & 0x8000 ? -1 : 1;
+    const exponent = (value >> 10) & 0x1f;
+    const fraction = value & 0x03ff;
+    if (exponent === 0) {
+        return sign * Math.pow(2, -14) * (fraction / 0x400);
+    }
+    if (exponent === 0x1f) {
+        return fraction ? NaN : sign * Infinity;
+    }
+    return sign * Math.pow(2, exponent - 15) * (1 + fraction / 0x400);
+}
+function convertDataTexture(threeTexture, textureStore) {
+    if (!threeTexture?.image?.data || !threeTexture.image.width || !threeTexture.image.height)
+        return;
+    const previous = textureStore.get(threeTexture);
+    const texture = convertTexture(threeTexture, textureStore);
+    if (previous?.state === textureStore.get(threeTexture)?.state)
+        return texture;
+    const source = threeTexture.image.data;
+    const data = source instanceof Uint16Array
+        ? Float32Array.from(source, halfFloatToFloat)
+        : source instanceof Float32Array || source instanceof Uint8Array || source instanceof Int32Array
+            ? source : Float32Array.from(source);
+    texture.image = { data, width: threeTexture.image.width, height: threeTexture.image.height };
+    return texture;
+}
+function convertMaterial(threeMaterial, textureCache) {
+    const material = new OpenPBRMaterial();
+    if (threeMaterial.userData.mutracerShadowCatcher === true) {
+        material.shadowCatcher = true;
+        return material;
+    }
+    if (threeMaterial.isMeshBasicMaterial) {
+        const basic = threeMaterial;
+        // GLTFLoader represents KHR_materials_unlit as MeshBasicMaterial. Keep its
+        // base-color texture's alpha while displaying RGB without scene lighting.
+        material.unlit = true;
+        material.baseWeight = 0;
+        material.specularWeight = 0;
+        material.baseColor = basic.color.toArray();
+        material.emissionColor = material.baseColor;
+        material.emissionLuminance = 1;
+        material.map = convertTexture(basic.map, textureCache);
+        material.emissiveMap = material.map;
+        material.alphaMap = convertTexture(basic.alphaMap, textureCache);
+        material.geometryOpacity = basic.opacity;
+        material.alphaCutoff = Math.max(0, basic.alphaTest);
+        material.alphaMode = basic.alphaTest > 0
+            ? 'mask'
+            : basic.transparent || basic.opacity < 1 || !!basic.alphaMap
+                ? 'blend'
+                : 'opaque';
+        material.mapAlphaUsage = material.alphaMode === 'opaque'
+            ? "opaque"
+            : "alpha";
+        material.doubleSided = basic.side === 2;
+        return material;
+    }
+    const standardMaterial = threeMaterial;
+    material.baseColor = standardMaterial.color.toArray();
+    material.emissionColor =
+        standardMaterial.emissive &&
+            standardMaterial.emissive.toArray();
+    material.specularRoughness = standardMaterial.roughness;
+    material.baseMetalness = standardMaterial.metalness;
+    material.emissionLuminance = standardMaterial.emissiveIntensity;
+    material.normalScale =
+        standardMaterial.normalScale && standardMaterial.normalScale.toArray();
+    const materialUvProjection = standardMaterial.userData
+        .mutracerUvProjection;
+    if (materialUvProjection === 'triplanar' ||
+        materialUvProjection === 'spherical' ||
+        materialUvProjection === 'cylindrical' ||
+        materialUvProjection === 'none') {
+        material.uvProjection = materialUvProjection;
+    }
+    const materialUvScale = standardMaterial.userData.mutracerUvProjectionScale;
+    if (Array.isArray(materialUvScale) && materialUvScale.length >= 2) {
+        const referenceLength = Math.max(Number(standardMaterial.userData.mutracerUvReferenceLength) || 1, 0.000001);
+        const scaleX = Math.max(Number(materialUvScale[0]) || 0.000001, 0.000001);
+        const scaleY = Math.max(Number(materialUvScale[1]) || 0.000001, 0.000001);
+        material.uvProjectionScale = material.uvProjection === 'triplanar'
+            ? [scaleX / referenceLength, scaleY / referenceLength]
+            : material.uvProjection === 'cylindrical'
+                ? [scaleX, scaleY / referenceLength]
+                : [scaleX, scaleY];
+    }
+    material.map = convertTexture(standardMaterial.map, textureCache);
+    material.alphaMap = convertTexture(standardMaterial.alphaMap, textureCache);
+    material.alphaCutoff = Math.max(0, Number.isFinite(standardMaterial.alphaTest) ? standardMaterial.alphaTest : 0);
+    material.emissiveMap = convertTexture(standardMaterial.emissiveMap, textureCache);
+    material.normalMap = convertTexture(standardMaterial.normalMap, textureCache);
+    material.displacementMap = convertTexture(standardMaterial.displacementMap, textureCache);
+    const displacementScale = Number(standardMaterial.displacementScale);
+    material.displacementScale = Number.isFinite(displacementScale)
+        ? displacementScale
+        : material.displacementScale;
+    const displacementStepSize = Number(standardMaterial.userData.mutracerDisplacementStepSize);
+    if (Number.isFinite(displacementStepSize)) {
+        material.displacementStepSize = Math.max(0.000001, displacementStepSize);
+    }
+    const uvProjection = standardMaterial.userData
+        .mutracerDisplacementUvProjection;
+    if (uvProjection === 'triplanar' ||
+        uvProjection === 'spherical' ||
+        uvProjection === 'cylindrical' ||
+        uvProjection === 'none') {
+        material.displacementUvProjection = uvProjection;
+    }
+    const displacementUvProjectionScale = Number(standardMaterial.userData.mutracerDisplacementUvProjectionScale);
+    if (Number.isFinite(displacementUvProjectionScale)) {
+        material.displacementUvProjectionScale = Math.max(displacementUvProjectionScale, 0.000001);
+    }
+    if (standardMaterial.roughnessMap &&
+        standardMaterial.roughnessMap === standardMaterial.metalnessMap) {
+        material.metallicRoughnessMap = convertTexture(standardMaterial.roughnessMap, textureCache);
+    }
+    else {
+        material.roughnessMap = convertTexture(standardMaterial.roughnessMap, textureCache);
+        material.metalnessMap = convertTexture(standardMaterial.metalnessMap, textureCache);
+    }
+    const physicalMaterial = standardMaterial;
+    if (physicalMaterial.type === 'MeshPhysicalMaterial') {
+        material.transmissionWeight = physicalMaterial.transmission;
+        material.transmissionMap = convertTexture(physicalMaterial.transmissionMap, textureCache);
+        material.specularIor = physicalMaterial.ior;
+        material.specularWeight = physicalMaterial.specularIntensity;
+        if (physicalMaterial.specularColor) {
+            material.specularColor =
+                physicalMaterial.specularColor.toArray();
+        }
+        material.coatWeightMap = convertTexture(physicalMaterial.clearcoatMap, textureCache);
+        material.coatRoughnessMap = convertTexture(physicalMaterial.clearcoatRoughnessMap, textureCache);
+        material.coatNormalMap = convertTexture(physicalMaterial.clearcoatNormalMap, textureCache);
+        material.coatNormalScale = physicalMaterial.clearcoatNormalScale.toArray();
+        material.fuzzColorMap = convertTexture(physicalMaterial.sheenColorMap, textureCache);
+        material.fuzzRoughnessMap = convertTexture(physicalMaterial.sheenRoughnessMap, textureCache);
+        material.specularWeightMap = convertTexture(physicalMaterial.specularIntensityMap, textureCache);
+        material.specularColorMap = convertTexture(physicalMaterial.specularColorMap, textureCache);
+        material.coatWeight = physicalMaterial.clearcoat;
+        material.coatRoughness = physicalMaterial.clearcoatRoughness;
+        // MeshPhysicalMaterial's clearcoat BRDF uses the fixed dielectric F0
+        // for IOR 1.5. Match that in the OpenPBR path representation; explicit
+        // mutracerOpenPBR metadata below may provide a different coat IOR.
+        material.coatIor = 1.5;
+        // Three.js/glTF clearcoat does not model internal-reflection darkening.
+        material.coatDarkening = 0;
+        material.fuzzWeight = physicalMaterial.sheen;
+        material.fuzzRoughness = physicalMaterial.sheenRoughness;
+        if (physicalMaterial.sheenColor) {
+            material.fuzzColor = physicalMaterial.sheenColor.toArray();
+        }
+        if (physicalMaterial.attenuationColor) {
+            material.transmissionColor =
+                physicalMaterial.attenuationColor.toArray();
+        }
+        if (Number.isFinite(physicalMaterial.attenuationDistance)) {
+            material.transmissionDepth = Math.max(0, physicalMaterial.attenuationDistance);
+        }
+    }
+    const dispersion = Number(physicalMaterial.dispersion);
+    material.transmissionDispersionScale = Number.isFinite(dispersion)
+        ? Math.min(1, Math.max(0, dispersion))
+        : 0;
+    const realtimeIridescence = physicalMaterial;
+    material.thinFilmThickness = Math.min(20, Math.max(0, (realtimeIridescence.iridescenceThicknessRange?.[1] ?? 500) / 1000));
+    material.thinFilmWeight = Math.min(1, Math.max(0, realtimeIridescence.iridescence ?? 0));
+    material.thinFilmIor = Math.min(2.5, Math.max(1, realtimeIridescence.iridescenceIOR ?? 1.4));
+    const nativeThinFilmMap = standardMaterial.userData.mutracerThinFilmMap;
+    const thinFilmMap = standardMaterial.userData
+        .mutracerThinFilmMap ??
+        realtimeIridescence.iridescenceThicknessMap ??
+        undefined;
+    if (thinFilmMap) {
+        material.thinFilmMap = convertTexture(thinFilmMap, textureCache);
+        if (!nativeThinFilmMap) {
+            material.thinFilmThicknessMinimum = Math.min(20, Math.max(0, (realtimeIridescence.iridescenceThicknessRange?.[0] ?? 0) / 1000));
+            material.thinFilmMapChannel = 'g';
+        }
+    }
+    const anisotropy = Number(physicalMaterial.anisotropy);
+    material.specularRoughnessAnisotropy = Number.isFinite(anisotropy)
+        ? Math.min(1, Math.max(0, anisotropy))
+        : 0;
+    if (physicalMaterial.isMeshPhysicalMaterial) {
+        material.specularAnisotropyModel = 'gltf';
+        material.anisotropyMap = convertTexture(physicalMaterial.anisotropyMap, textureCache);
+        const rotation = Number(physicalMaterial.anisotropyRotation);
+        material.specularAnisotropyRotation = Number.isFinite(rotation) ? rotation : 0;
+    }
+    const sourceOpenPbr = standardMaterial.userData.mutracerOpenPBR;
+    const openPbr = sourceOpenPbr ? normalizeMaterialParams(sourceOpenPbr) : undefined;
+    const finite = (value, fallback, minimum = 0, maximum = 1) => {
+        const number = Number(value);
+        return Number.isFinite(number)
+            ? Math.min(maximum, Math.max(minimum, number))
+            : fallback;
+    };
+    const color = (value, fallback) => {
+        const components = value;
+        return components && components.length >= 3
+            ? [
+                finite(components[0], fallback[0]),
+                finite(components[1], fallback[1]),
+                finite(components[2], fallback[2])
+            ]
+            : fallback;
+    };
+    if (openPbr) {
+        if (openPbr.specularAnisotropyModel !== undefined) {
+            specularAnisotropyModelIndex(openPbr.specularAnisotropyModel);
+            material.specularAnisotropyModel = openPbr.specularAnisotropyModel;
+        }
+        if (openPbr.specularAnisotropy !== undefined && openPbr.specularAnisotropyModel !== 'gltf') {
+            material.specularAnisotropyModel = 'openpbr';
+            material.anisotropyMap = undefined;
+            material.specularAnisotropyRotation = 0;
+        }
+        // Only supported Texture inputs are accepted; arbitrary metadata objects
+        // must never enter the atlas as textures. Explicit null clears an import.
+        for (const name of ['coatWeightMap', 'coatRoughnessMap', 'fuzzColorMap',
+            'fuzzRoughnessMap', 'specularWeightMap', 'specularColorMap', 'anisotropyMap', 'coatNormalMap']) {
+            const texture = openPbr[name];
+            if (texture === null)
+                material[name] = undefined;
+            else if (texture instanceof Texture)
+                material[name] = texture;
+            else if (texture && texture.isTexture &&
+                typeof texture.clone === 'function') {
+                material[name] = convertTexture(texture, textureCache);
+            }
+        }
+        material.specularAnisotropyRotation = finite(openPbr.specularAnisotropyRotation, material.specularAnisotropyRotation, -Infinity, Infinity);
+        material.coatAnisotropyRotation = finite(openPbr.coatAnisotropyRotation, material.coatAnisotropyRotation, -Infinity, Infinity);
+        const coatScale = openPbr.coatNormalScale;
+        if (coatScale && coatScale.length >= 2) {
+            material.coatNormalScale = [
+                finite(coatScale[0], material.coatNormalScale[0], -Infinity, Infinity),
+                finite(coatScale[1], material.coatNormalScale[1], -Infinity, Infinity)
+            ];
+        }
+        material.baseWeight = finite(openPbr.baseWeight, material.baseWeight);
+        material.baseDiffuseRoughness = finite(openPbr.baseDiffuseRoughness, material.baseDiffuseRoughness);
+        material.specularWeight = finite(openPbr.specularWeight, material.specularWeight);
+        material.specularColor = color(openPbr.specularColor, material.specularColor);
+        material.transmissionScatter = color(openPbr.transmissionScatter, material.transmissionScatter);
+        material.transmissionScatterAnisotropy = finite(openPbr.transmissionScatterAnisotropy, material.transmissionScatterAnisotropy, -0.95, 0.95);
+        material.transmissionDispersionScale = finite(openPbr.transmissionDispersionScale, material.transmissionDispersionScale);
+        material.transmissionDispersionAbbeNumber = finite(openPbr.transmissionDispersionAbbeNumber, material.transmissionDispersionAbbeNumber, 1, 100);
+        material.subsurfaceWeight = finite(openPbr.subsurfaceWeight, material.subsurfaceWeight);
+        material.subsurfaceColor = color(openPbr.subsurfaceColor, material.subsurfaceColor);
+        material.subsurfaceRadius = finite(openPbr.subsurfaceRadius, material.subsurfaceRadius, 0, Infinity);
+        material.subsurfaceRadiusScale = color(openPbr.subsurfaceRadiusScale, material.subsurfaceRadiusScale);
+        material.subsurfaceScatterAnisotropy = finite(openPbr.subsurfaceAnisotropy, material.subsurfaceAnisotropy, -0.95, 0.95);
+        material.coatWeight = finite(openPbr.coatWeight, material.coatWeight);
+        material.coatColor = color(openPbr.coatColor, material.coatColor);
+        material.coatRoughness = finite(openPbr.coatRoughness, material.coatRoughness);
+        material.coatRoughnessAnisotropy = finite(openPbr.coatAnisotropy, material.coatAnisotropy);
+        material.coatIor = finite(openPbr.coatIor, material.coatIor, 1, 2.5);
+        material.coatDarkening = finite(openPbr.coatDarkening, material.coatDarkening);
+        material.fuzzWeight = finite(openPbr.fuzzWeight, material.fuzzWeight);
+        material.fuzzColor = color(openPbr.fuzzColor, material.fuzzColor);
+        material.fuzzRoughness = finite(openPbr.fuzzRoughness, material.fuzzRoughness);
+        if ('thinWalled' in openPbr) {
+            material.geometryThinWalled = openPbr.thinWalled === true;
+        }
+        material.thinFilmWeight = finite(openPbr.thinFilmWeight, material.thinFilmWeight);
+        material.thinFilmThickness = finite(openPbr.thinFilmThickness, material.thinFilmThickness, 0, 20);
+        material.thinFilmThicknessMinimum = finite(openPbr.thinFilmThicknessMinimum, material.thinFilmThicknessMinimum, 0, 20);
+        if (openPbr.thinFilmMapChannel !== undefined) {
+            material.thinFilmMapChannel = ['r', 'g', 'b', 'a'][thinFilmMapChannelIndex(openPbr.thinFilmMapChannel)];
+        }
+        if (openPbr.thinFilmMap instanceof Texture)
+            material.thinFilmMap = openPbr.thinFilmMap;
+        else if (openPbr.thinFilmMap && openPbr.thinFilmMap.isTexture) {
+            material.thinFilmMap = convertTexture(openPbr.thinFilmMap, textureCache);
+        }
+        material.thinFilmIor = finite(openPbr.thinFilmIor, material.thinFilmIor, 1, 2.5);
+    }
+    material.geometryOpacity = standardMaterial.opacity;
+    // THREE.DoubleSide is the numeric enum value 2. Keep this module's Three.js
+    // import type-only while preserving the source material's culling semantics.
+    material.doubleSided = standardMaterial.side === 2;
+    if (openPbr) {
+        material.specularRoughnessAnisotropy = finite(openPbr.specularAnisotropy, material.specularRoughnessAnisotropy);
+        material.geometryOpacity = finite(openPbr.opacity, material.geometryOpacity);
+    }
+    const bevelSize = Number(standardMaterial.userData.mutracerBevelSize);
+    material.bevelSize = Number.isFinite(bevelSize) ? Math.max(0, bevelSize) : 0;
+    material.mapAlphaUsage =
+        standardMaterial.transparent ||
+            !!standardMaterial.alphaMap ||
+            standardMaterial.alphaTest > 0
+            ? "alpha"
+            : "opaque";
+    material.alphaMode = standardMaterial.alphaTest > 0
+        ? 'mask'
+        : standardMaterial.transparent ||
+            material.geometryOpacity < 1 ||
+            !!standardMaterial.alphaMap
+            ? 'blend'
+            : 'opaque';
+    return material;
+}
+function copyFloatAttribute(attribute, itemSize = attribute.itemSize) {
+    const result = new Float32Array(attribute.count * itemSize);
+    if (attribute.array instanceof Float32Array && !attribute.normalized) {
+        const interleaved = attribute;
+        if (!interleaved.isInterleavedBufferAttribute && itemSize === attribute.itemSize) {
+            result.set(attribute.array.subarray(0, result.length));
+        }
+        else {
+            const stride = interleaved.isInterleavedBufferAttribute
+                ? interleaved.data.stride : attribute.itemSize;
+            const offset = interleaved.isInterleavedBufferAttribute ? interleaved.offset : 0;
+            for (let index = 0; index < attribute.count; index++) {
+                const sourceOffset = index * stride + offset;
+                const targetOffset = index * itemSize;
+                for (let component = 0; component < itemSize; component++) {
+                    result[targetOffset + component] = attribute.array[sourceOffset + component];
+                }
+            }
+        }
+        return result;
+    }
+    // Getters preserve normalized integer and Float16BufferAttribute decoding.
+    const getters = [
+        attribute.getX,
+        attribute.getY,
+        attribute.getZ,
+        attribute.getW
+    ];
+    for (let index = 0; index < attribute.count; index++) {
+        for (let component = 0; component < itemSize; component++) {
+            result[index * itemSize + component] = getters[component].call(attribute, index);
+        }
+    }
+    return result;
+}
+function convertGeometry(threeGeometry, drawRange) {
+    const positionAttrb = threeGeometry.getAttribute('position');
+    const normalAttrb = threeGeometry.getAttribute('normal');
+    const tangentAttrb = threeGeometry.getAttribute('tangent');
+    const uvAttrb = threeGeometry.getAttribute('uv');
+    const uv1Attrb = threeGeometry.getAttribute('uv1');
+    const indexAttrb = threeGeometry.getIndex();
+    const sourceCount = indexAttrb ? indexAttrb.array.length : positionAttrb.count;
+    // Match Array.slice range handling without expanding the complete index stream.
+    const clampOffset = (offset) => {
+        const integer = Math.trunc(offset) || 0;
+        return integer < 0 ? Math.max(sourceCount + integer, 0) : Math.min(integer, sourceCount);
+    };
+    const start = drawRange ? clampOffset(drawRange.start) : 0;
+    const end = drawRange ? clampOffset(drawRange.start + drawRange.count) : sourceCount;
+    let indexCount = Math.max(end - start, 0);
+    // WebGL's TRIANGLES draw mode ignores an incomplete final primitive. Keep
+    // path tracing on the same index stream so valid BufferGeometry with a
+    // dangling one or two elements cannot produce invalid BLAS input.
+    indexCount -= indexCount % 3;
+    if (indexCount === 0)
+        return null;
+    const indices = new Uint32Array(indexCount);
+    if (indexAttrb) {
+        indices.set(indexAttrb.array.subarray(start, start + indexCount));
+    }
+    else {
+        for (let index = 0; index < indexCount; index++)
+            indices[index] = start + index;
+    }
+    const geometry = new Geometry({
+        position: new Attribute(copyFloatAttribute(positionAttrb), positionAttrb.itemSize),
+        normal: normalAttrb &&
+            new Attribute(copyFloatAttribute(normalAttrb), normalAttrb.itemSize),
+        tangent: tangentAttrb && new Attribute(copyFloatAttribute(tangentAttrb, Math.min(4, tangentAttrb.itemSize)), Math.min(4, tangentAttrb.itemSize)),
+        uv: uvAttrb && new Attribute(copyFloatAttribute(uvAttrb), uvAttrb.itemSize),
+        uv1: uv1Attrb &&
+            new Attribute(copyFloatAttribute(uv1Attrb), uv1Attrb.itemSize),
+        indices: new Attribute(indices, 1)
+    });
+    if (!geometry.normal) {
+        generateVertexNormals(geometry);
+    }
+    updateBoundingBox(geometry);
+    return geometry;
+}
+function createConversionStore() {
+    return { updateId: 0, textures: new WeakMap(), materials: new WeakMap(), geometries: new WeakMap(),
+        materialHooks: new WeakMap(), lightHooks: new WeakMap(),
+        poseChanged: false, meshes: new WeakMap(), lights: new WeakMap(), deformedGeometries: new WeakMap(), deformations: new WeakMap(),
+        instanceMeshes: new WeakMap(), projectionVariants: new Map(), warned: new WeakSet() };
+}
+const geometryAttributeNames = ['position', 'normal', 'tangent', 'uv', 'uv1', 'index'];
+function geometryState(geometry, deformation) {
+    const state = [];
+    for (let i = 0; i < geometryAttributeNames.length; i++) {
+        const name = geometryAttributeNames[i];
+        const attribute = name === 'index' ? geometry.index : geometry.getAttribute(name);
+        if (!attribute) {
+            state.push(undefined);
+            continue;
+        }
+        const interleaved = attribute;
+        const buffer = interleaved.isInterleavedBufferAttribute ? interleaved.data : attribute;
+        state.push(attribute, buffer, deformation && i < 3 ? undefined : buffer.version, buffer.array, attribute.count, attribute.itemSize, attribute.normalized, interleaved.offset, interleaved.data?.stride);
+    }
+    return state;
+}
+/** Compare cached fields directly; unchanged geometry creates no snapshot arrays. */
+function geometryStateMatches(geometry, state, deformation) {
+    let field = 0;
+    for (let i = 0; i < geometryAttributeNames.length; i++) {
+        const name = geometryAttributeNames[i];
+        const attribute = name === 'index' ? geometry.index : geometry.getAttribute(name);
+        if (!attribute) {
+            if (state[field++] !== undefined)
+                return false;
+            continue;
+        }
+        const interleaved = attribute;
+        const buffer = interleaved.isInterleavedBufferAttribute ? interleaved.data : attribute;
+        if (state[field++] !== attribute || state[field++] !== buffer ||
+            !Object.is(state[field++], deformation && i < 3 ? undefined : buffer.version) ||
+            state[field++] !== buffer.array || !Object.is(state[field++], attribute.count) ||
+            !Object.is(state[field++], attribute.itemSize) || !Object.is(state[field++], attribute.normalized) ||
+            !Object.is(state[field++], interleaved.offset) || !Object.is(state[field++], interleaved.data?.stride))
+            return false;
+    }
+    return field === state.length;
+}
+function retainLight(store, source, value) {
+    const cached = store.lights.get(source);
+    if (!cached || cached.type !== value.type) {
+        store.lights.set(source, value);
+        return value;
+    }
+    // Matrix and color arrays are retained when unchanged; light identity always is.
+    for (const key of Object.keys(value)) {
+        const previous = cached[key];
+        const next = value[key];
+        if (Array.isArray(previous) && Array.isArray(next) && snapshotsEqual(previous, next))
+            continue;
+        cached[key] = next;
+    }
+    return cached;
+}
+/**
+ * Converts a Three.js scene into a MuTracer {@link Scene}: meshes with
+ * `MeshStandardMaterial` / `MeshPhysicalMaterial` (mapped to OpenPBR),
+ * directional, ambient, rect-area, point and spot lights, and the scene
+ * background / environment. Calls `scene.updateMatrixWorld()` and creates fresh objects on every call.
+ * CPU-evaluates skinning/morph targets and batches InstancedMesh instances
+ * with shared geometry, native colors and cached projection material variants. Unsupported batched
+ * or instanced deformation falls back to an ordinary mesh with a warning.
+ * For animation and editing, use {@link THREESync}.
+ *
+ * Renderer-specific material settings can be supplied through
+ * `material.userData`, e.g. `userData.mutracerShadowCatcher = true` or
+ * `userData.mutracerOpenPBR = { ... }` for OpenPBR inputs without a Three.js
+ * equivalent.
+ */
+export function fromTHREEScene(scene, options = {}) {
+    return convertScene(scene, options, createConversionStore());
+}
+function convertScene(scene, options, store) {
+    const updateId = ++store.updateId;
+    const meshes = [];
+    const lights = [];
+    const textureCache = store.textures;
+    const convertedMaterials = new Set();
+    const baseHashes = new Map();
+    function refreshVariant(entry, base) {
+        let hash = baseHashes.get(base);
+        if (hash === undefined) {
+            hash = getMaterialHashKey(base);
+            baseHashes.set(base, hash);
+        }
+        if (entry.base === base && entry.hash === hash && materialParametersEqual(base, entry.parameters))
+            return;
+        for (const field of materialKeys)
+            entry.material[field] = base[field];
+        if (entry.autoUvProjection)
+            entry.material.uvProjection = 'triplanar';
+        if (entry.autoDisplacementUvProjection)
+            entry.material.displacementUvProjection = 'triplanar';
+        entry.parameters = snapshotMaterialParameters(base);
+        entry.hash = hash;
+        entry.base = base;
+    }
+    function materialVariant(source, base, autoUvProjection, autoDisplacementUvProjection) {
+        if (!autoUvProjection && !autoDisplacementUvProjection)
+            return base;
+        let variants = store.projectionVariants.get(source);
+        if (!variants) {
+            variants = new Map();
+            store.projectionVariants.set(source, variants);
+        }
+        const key = `${+autoUvProjection}:${+autoDisplacementUvProjection}`;
+        let variant = variants.get(key);
+        if (!variant) {
+            variant = { material: new OpenPBRMaterial(), parameters: [],
+                autoUvProjection, autoDisplacementUvProjection };
+            variants.set(key, variant);
+        }
+        refreshVariant(variant, base);
+        return variant.material;
+    }
+    function materialHook(source) {
+        if (!options.convertMaterial)
+            return undefined;
+        let entry = store.materialHooks.get(source);
+        if (!entry || entry.version !== source.version) {
+            entry = { version: source.version, value: options.convertMaterial(source) };
+            store.materialHooks.set(source, entry);
+        }
+        return entry.value;
+    }
+    function lightHook(source) {
+        if (!options.convertLight)
+            return undefined;
+        // Three.js Light has no built-in version; applications revise it through userData.
+        const revision = source.userData.mutracerVersion;
+        const version = typeof revision === 'number' ? revision : undefined;
+        let entry = store.lightHooks.get(source);
+        if (!entry || entry.version !== version) {
+            entry = { version, value: options.convertLight(source) };
+            store.lightHooks.set(source, entry);
+        }
+        return entry.value;
+    }
+    function resolveMaterial(source) {
+        const custom = materialHook(source);
+        if (custom !== undefined)
+            return custom;
+        const cached = store.materials.get(source);
+        if (convertedMaterials.has(source))
+            return cached.material;
+        const converted = convertMaterial(source, textureCache);
+        const hash = getMaterialHashKey(converted);
+        let material = converted;
+        if (cached) {
+            if (cached.hash !== hash) {
+                for (const key of materialKeys)
+                    cached.material[key] = converted[key];
+                cached.hash = hash;
+            }
+            material = cached.material;
+        }
+        else
+            store.materials.set(source, { material, hash });
+        convertedMaterials.add(source);
+        return material;
+    }
+    function isMesh(node) {
+        return node.isMesh;
+    }
+    function isDirectionalLight(node) {
+        return node.isDirectionalLight;
+    }
+    function isAmbientLight(node) {
+        return node.isAmbientLight;
+    }
+    function isRectAreaLight(node) {
+        return node.isRectAreaLight;
+    }
+    function isPointLight(node) {
+        return node.type === 'PointLight';
+    }
+    function isSpotLight(node) {
+        return node.type === 'SpotLight';
+    }
+    scene.updateMatrixWorld(true);
+    scene.traverseVisible((child) => {
+        if (child.isLight) {
+            const custom = lightHook(child);
+            if (custom !== undefined) {
+                if (custom !== null)
+                    lights.push(custom);
+                return;
+            }
+        }
+        if (isMesh(child)) {
+            if (child.userData.viewerEnvironment)
+                return;
+            // Viewer-only proxy geometry is already represented by its source mesh.
+            if (child.userData.viewerRealtimeDisplacement)
+                return;
+            const childMaterials = Array.isArray(child.material)
+                ? child.material
+                : [child.material];
+            // A null result rejects the source mesh, including all of its groups/instances.
+            if (childMaterials.some(material => materialHook(material) === null))
+                return;
+            if (!child.geometry) {
+                console.warn(child, 'must have a geometry property');
+            }
+            else if (childMaterials.some((material) => materialHook(material) === undefined &&
+                !material.isMeshStandardMaterial &&
+                !material.isMeshBasicMaterial &&
+                material.userData.mutracerShadowCatcher !== true)) {
+                console.warn(child, 'must use MeshStandardMaterial or MeshBasicMaterial in order to be rendered.');
+            }
+            else {
+                const instanced = child;
+                const unsupported = child.isBatchedMesh ||
+                    instanced.isInstancedMesh && (!!instanced.morphTexture || child.isSkinnedMesh);
+                if (unsupported && !store.warned.has(child)) {
+                    console.warn('MuTracer: BatchedMesh, instanced morph targets and skinned instancing are not supported; converting as an ordinary mesh.', child);
+                    store.warned.add(child);
+                }
+                const expand = instanced.isInstancedMesh && !unsupported;
+                let deformation;
+                let deformed = false;
+                if (!unsupported && isDeformingMesh(child)) {
+                    deformation = store.deformations.get(child);
+                    if (!deformation?.matches(child.geometry)) {
+                        deformation = new THREEDeformation(child.geometry);
+                        store.deformations.set(child, deformation);
+                        store.deformedGeometries.delete(child);
+                    }
+                    deformed = deformation.update(child);
+                    store.poseChanged ||= deformed;
+                }
+                const threeMaterials = childMaterials;
+                const groups = threeMaterials.length > 1 && child.geometry.groups.length
+                    ? child.geometry.groups
+                    : [{ start: 0, count: Infinity, materialIndex: 0 }];
+                // Shared static geometry is checked once per update, before its groups.
+                // Deforming meshes keep independent entries for their evaluated geometry.
+                let entry = deformation ? store.deformedGeometries.get(child) : store.geometries.get(child.geometry);
+                if (!entry || entry.checkedAt !== updateId) {
+                    if (!entry || !geometryStateMatches(child.geometry, entry.state, !!deformation)) {
+                        entry = { state: geometryState(child.geometry, !!deformation), groups: new Map(), checkedAt: updateId };
+                        if (deformation)
+                            store.deformedGeometries.set(child, entry);
+                        else
+                            store.geometries.set(child.geometry, entry);
+                    }
+                    entry.checkedAt = updateId;
+                }
+                const geometryEntry = entry;
+                groups.forEach((group, groupIndex) => {
+                    const count = Number.isFinite(group.count)
+                        ? group.count
+                        : (child.geometry.getIndex()?.count ??
+                            child.geometry.getAttribute('position').count);
+                    const geometryKey = `${group.start}:${count}`;
+                    let geometry = geometryEntry.groups.get(geometryKey);
+                    const newGeometry = !geometry;
+                    if (!geometry) {
+                        const converted = convertGeometry(child.geometry, { start: group.start, count });
+                        if (!converted)
+                            return;
+                        geometry = converted;
+                        geometryEntry.groups.set(geometryKey, geometry);
+                    }
+                    if (deformation && (deformed || newGeometry)) {
+                        geometry.dynamic = true;
+                        geometry.position.array.set(deformation.position);
+                        if (deformation.normal)
+                            geometry.normal.array.set(deformation.normal);
+                        if (deformation.tangent && geometry.tangent)
+                            geometry.tangent.array.set(deformation.tangent);
+                        if (!child.geometry.getAttribute('tangent'))
+                            updateDynamicTangents(geometry);
+                        updateBoundingBox(geometry);
+                        if (!newGeometry)
+                            markDeformedGeometry(geometry);
+                    }
+                    const sourceMaterial = threeMaterials[group.materialIndex ?? 0];
+                    let material = resolveMaterial(sourceMaterial);
+                    const baseMaterial = material;
+                    const autoUvProjection = !geometry.uv && baseMaterial.uvProjection === 'none' &&
+                        !!(baseMaterial.map || baseMaterial.normalMap || baseMaterial.emissiveMap || baseMaterial.metallicRoughnessMap ||
+                            baseMaterial.roughnessMap || baseMaterial.metalnessMap || baseMaterial.thinFilmMap ||
+                            baseMaterial.coatWeightMap || baseMaterial.coatRoughnessMap || baseMaterial.fuzzColorMap ||
+                            baseMaterial.fuzzRoughnessMap || baseMaterial.specularWeightMap || baseMaterial.specularColorMap || baseMaterial.anisotropyMap || baseMaterial.coatNormalMap);
+                    const autoDisplacementUvProjection = !geometry.uv && !!baseMaterial.displacementMap &&
+                        baseMaterial.displacementUvProjection === 'none';
+                    const instanceCount = expand ? instanced.count : 1;
+                    if (expand) {
+                        let batchesByGroup = store.instanceMeshes.get(child);
+                        if (!batchesByGroup) {
+                            batchesByGroup = new Map();
+                            store.instanceMeshes.set(child, batchesByGroup);
+                        }
+                        const variant = materialVariant(sourceMaterial, baseMaterial, autoUvProjection, autoDisplacementUvProjection);
+                        let batch = batchesByGroup.get(groupIndex);
+                        if (!batch) {
+                            batch = new InstancedMesh(geometry, variant, { count: instanceCount });
+                            batch.transform = child.matrixWorld.elements.slice();
+                            batchesByGroup.set(groupIndex, batch);
+                        }
+                        batch.geometry = geometry;
+                        if (batch.materials[0] !== variant)
+                            batch.materials = [variant];
+                        let changed = batch.count !== instanceCount;
+                        if (batch.transforms.length < instanceCount * 16) {
+                            batch.transforms = new Float32Array(instanceCount * 16);
+                            changed = true;
+                        }
+                        // Grow colors before count validation in either notification method.
+                        const sourceColors = instanced.instanceColor;
+                        let colorsChanged = false;
+                        if (sourceColors) {
+                            if (!batch.colors || batch.colors.length < instanceCount * 3)
+                                batch.colors = new Float32Array(instanceCount * 3);
+                            for (let i = 0; i < instanceCount; i++) {
+                                for (let k = 0; k < 3; k++) {
+                                    const value = Math.fround(k === 0 ? sourceColors.getX(i) : k === 1 ? sourceColors.getY(i) : sourceColors.getZ(i));
+                                    if (!Object.is(batch.colors[i * 3 + k], value)) {
+                                        batch.colors[i * 3 + k] = value;
+                                        colorsChanged = true;
+                                    }
+                                }
+                            }
+                        }
+                        else
+                            batch.colors = undefined;
+                        batch.count = instanceCount;
+                        const matrices = instanced.instanceMatrix;
+                        for (let i = 0; i < instanceCount; i++)
+                            for (let k = 0; k < 16; k++) {
+                                const value = Math.fround(matrices.array[i * matrices.itemSize + k]);
+                                if (!Object.is(batch.transforms[i * 16 + k], value)) {
+                                    batch.transforms[i * 16 + k] = value;
+                                    changed = true;
+                                }
+                            }
+                        for (let i = 0; i < 16; i++)
+                            batch.transform[i] = child.matrixWorld.elements[i];
+                        if (changed)
+                            batch.markTransformsUpdated();
+                        if (colorsChanged)
+                            batch.markColorsUpdated();
+                        batch.name = child.name || `Mesh ${meshes.length + 1}${groups.length > 1 ? `.${groupIndex + 1}` : ''}`;
+                        if (instanceCount > 0) {
+                            meshes.push(batch);
+                            options.onMeshConverted?.(batch, child, group, groupIndex);
+                        }
+                    }
+                    else {
+                        material = materialVariant(sourceMaterial, baseMaterial, autoUvProjection, autoDisplacementUvProjection);
+                        let meshGroups = store.meshes.get(child);
+                        if (!meshGroups) {
+                            meshGroups = new Map();
+                            store.meshes.set(child, meshGroups);
+                        }
+                        let mesh = meshGroups.get(groupIndex);
+                        if (!mesh) {
+                            mesh = new Mesh(geometry, material);
+                            mesh.transform = child.matrixWorld.elements.slice();
+                            meshGroups.set(groupIndex, mesh);
+                        }
+                        mesh.geometry = geometry;
+                        if (mesh.materials[0] !== material)
+                            mesh.materials = [material];
+                        mesh.name = child.name || `Mesh ${meshes.length + 1}${groups.length > 1 ? `.${groupIndex + 1}` : ''}`;
+                        for (let i = 0; i < 16; i++)
+                            mesh.transform[i] = child.matrixWorld.elements[i];
+                        meshes.push(mesh);
+                        options.onMeshConverted?.(mesh, child, group, groupIndex);
+                    }
+                });
+            }
+        }
+        else if (isDirectionalLight(child)) {
+            const light = new DirectionalLight({ color: child.color.toArray(), intensity: child.intensity });
+            light.transform = Array.from(light.transform);
+            light.position = child.getWorldPosition(child.position.clone()).toArray();
+            light.lookAt(child.target.getWorldPosition(child.target.position.clone()).toArray());
+            lights.push(retainLight(store, child, light));
+        }
+        else if (isRectAreaLight(child)) {
+            const worldMatrix = child.matrixWorld.clone();
+            // Shear decomposition can return a non-unit quaternion. The size below
+            // carries scale; this approximated rectangle's sampling frame is rigid.
+            const worldRotation = child.getWorldQuaternion(child.quaternion.clone()).normalize();
+            const worldPosition = child.getWorldPosition(child.position.clone());
+            const elements = worldMatrix.elements;
+            const widthScale = Math.hypot(elements[0], elements[1], elements[2]);
+            const heightScale = Math.hypot(elements[4], elements[5], elements[6]);
+            const light = new RectLight({
+                size: [child.width * widthScale, child.height * heightScale],
+                color: child.color.toArray(),
+                intensity: child.intensity
+            });
+            worldMatrix.compose(worldPosition, worldRotation, child.scale.clone().set(1, 1, 1));
+            light.transform = worldMatrix.elements.slice();
+            lights.push(retainLight(store, child, light));
+        }
+        else if (isSpotLight(child)) {
+            const worldPosition = child.getWorldPosition(child.position.clone());
+            const worldTarget = child.target.getWorldPosition(child.target.position.clone());
+            const outerAngle = (child.angle * 180) / Math.PI;
+            const profile = child.userData.mutracerIesProfile;
+            if (profile != null && !(profile instanceof IESProfile)) {
+                throw new Error(`THREE.SpotLight "${child.name || '<unnamed>'}" has an invalid mutracerIesProfile`);
+            }
+            const light = new SpotLight({
+                color: child.color.toArray(),
+                intensity: child.intensity,
+                radius: child.userData.mutracerRadius ?? 0.01,
+                innerAngle: outerAngle * (1 - child.penumbra),
+                outerAngle,
+                iesProfile: profile
+            });
+            light.transform = Array.from(light.transform);
+            light.position = worldPosition.toArray();
+            light.lookAt(worldTarget.toArray());
+            const rotation = -(child.userData.mutracerIesRotation ?? 0) * Math.PI / 180;
+            if (rotation)
+                mat4.rotateZ(light.transform, light.transform, rotation);
+            lights.push(retainLight(store, child, light));
+        }
+        else if (isPointLight(child)) {
+            const world = child.matrixWorld.elements;
+            const position = [
+                world[12],
+                world[13],
+                world[14]
+            ];
+            lights.push(retainLight(store, child, Object.assign(new SphereLight({
+                color: child.color.toArray(),
+                intensity: child.intensity,
+                radius: child.userData.mutracerRadius ?? 0.25
+            }), { transform: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, ...position, 1] })));
+        }
+        else if (isAmbientLight(child)) {
+            lights.push(retainLight(store, child, new AmbientLight({ color: child.color.toArray(), intensity: child.intensity })));
+        }
+    });
+    const threeEnvironment = scene.environment;
+    const environmentMap = convertDataTexture(threeEnvironment, textureCache);
+    const environmentLight = threeEnvironment && environmentMap
+        ? retainLight(store, threeEnvironment, new EnvironmentLight({ map: environmentMap }))
+        : undefined;
+    if (environmentLight)
+        lights.push(environmentLight);
+    const grounded = scene.userData.mutracerGroundedSkybox;
+    const groundedTexture = grounded && convertDataTexture(grounded.texture, textureCache);
+    const hideEnvironmentBackground = scene.userData.mutracerHiddenBackground === true;
+    let background = hideEnvironmentBackground
+        ? [0, 0, 0, 0]
+        : grounded && groundedTexture
+            ? {
+                type: 'GroundedSkybox',
+                map: groundedTexture,
+                height: grounded.height,
+                radius: grounded.radius,
+                groundHeight: grounded.groundHeight,
+                center: grounded.center
+            }
+            : scene.background
+                ? scene.background.isColor
+                    ? [...scene.background.toArray(), 1]
+                    : scene.background === scene.environment && environmentLight
+                        ? environmentLight.map
+                        : convertDataTexture(scene.background, textureCache)
+                : undefined;
+    const oldBackground = store.background;
+    if (Array.isArray(background) && Array.isArray(oldBackground) && snapshotsEqual(background, oldBackground)) {
+        background = oldBackground;
+    }
+    else if (background && oldBackground && !Array.isArray(background) && !Array.isArray(oldBackground)
+        && !(background instanceof Texture) && !(oldBackground instanceof Texture)) {
+        // Compare by values, ignoring the newly constructed wrapper's identity.
+        if (snapshotsEqual(snapshotFields(background).slice(1), snapshotFields(oldBackground).slice(1)))
+            background = oldBackground;
+        else {
+            Object.assign(oldBackground, background);
+            background = oldBackground;
+        }
+    }
+    store.background = background;
+    // Inspect the final converted meshes, including onMeshConverted overrides.
+    // Iterate across source materials so removed/hidden objects are pruned too.
+    const usedMaterials = new Set(meshes.flatMap(mesh => mesh.materials));
+    for (const [source, variants] of store.projectionVariants) {
+        for (const [key, variant] of variants)
+            if (!usedMaterials.has(variant.material))
+                variants.delete(key);
+        if (!variants.size)
+            store.projectionVariants.delete(source);
+    }
+    return {
+        background,
+        meshes,
+        lights
+    };
+}
+/** Inputs that can wake an idle OrbitControls instance, without inspecting its private inertia. */
+function orbitControlsState(camera, controls) {
+    if (!camera || !controls.getPolarAngle || !controls.getAzimuthalAngle)
+        return;
+    camera.parent?.updateWorldMatrix(true, false);
+    const state = [camera, controls.update, camera.parent, ...camera.position.toArray(), ...camera.quaternion.toArray(),
+        ...camera.scale.toArray(), ...camera.up.toArray(), camera.zoom, ...(camera.parent?.matrixWorld.elements ?? [])];
+    for (const [key, value] of Object.entries(controls)) {
+        if (key.startsWith('_'))
+            continue;
+        const vector = value;
+        if (vector?.isVector3)
+            state.push(key, ...vector.toArray());
+        else if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string')
+            state.push(key, value);
+    }
+    return state;
+}
+/**
+ * Keeps one MuTracer scene in sync with a Three.js scene, reusing unchanged objects.
+ * Skinning/morph targets run on the CPU with per-source-mesh dynamic geometry.
+ * InstancedMesh retains its prefix on count changes and shares geometry/BLAS;
+ * Instance colors use native batch storage; automatic UV-less projections
+ * share cached material variants per source material. Source edits refresh variants; unused variants
+ * are removed after each update.
+ */
+export class THREESync extends Sync {
+    _options;
+    /** Retained converted scene; absent when no scene source was supplied. */
+    scene;
+    /** Retained converted camera; absent until the first camera update. */
+    _camera;
+    _store = createConversionStore();
+    _disposed = false;
+    _started = false;
+    _cameraState = [];
+    _lastUpdate;
+    _idleControlsState;
+    _start = () => { this._started = true; this._idleControlsState = undefined; this.setActive(true); };
+    _end = () => { this._started = false; };
+    /** Subscribes to controls without converting sources or modifying the engine. */
+    constructor(engine, _options = {}) {
+        super(engine);
+        this._options = _options;
+        if (_options.scene)
+            this.scene = { meshes: [], lights: [] };
+        _options.controls?.addEventListener('start', this._start);
+        _options.controls?.addEventListener('end', this._end);
+    }
+    /** Updates controls, world matrices, retained instances and camera before engine.update. */
+    update() {
+        if (this._disposed)
+            throw new Error('THREESync has been disposed');
+        const now = performance.now(), controls = this._options.controls, sourceCamera = this._options.camera;
+        const elapsed = this._lastUpdate === undefined ? 0 : Math.max(0, (now - this._lastUpdate) / 1000);
+        const dt = Math.min(.1, elapsed);
+        this._lastUpdate = now;
+        let moving = false, settled = false;
+        if (controls && this._options.updateControls !== false) {
+            const orbitInputs = orbitControlsState(sourceCamera, controls);
+            const idle = !this._started && !controls.autoRotate && orbitInputs && this._idleControlsState && snapshotsEqual(orbitInputs, this._idleControlsState);
+            if (!idle) {
+                this._idleControlsState = undefined;
+                const position = sourceCamera?.position.clone(), rotation = sourceCamera?.quaternion.clone(), zoom = sourceCamera?.zoom;
+                const target = controls.target?.clone(), damping = controls.dampingFactor;
+                const frameDamping = controls.enableDamping && damping !== undefined && damping >= 0 && damping <= 1
+                    ? 1 - Math.pow(1 - damping, elapsed * 60) : undefined;
+                if (frameDamping !== undefined)
+                    controls.dampingFactor = frameDamping;
+                try {
+                    moving = !!controls.update(dt);
+                }
+                finally {
+                    if (frameDamping !== undefined)
+                        controls.dampingFactor = damping;
+                }
+                if (!this._started && !controls.autoRotate && controls.enableDamping && position && sourceCamera && controls.target) {
+                    const referenceScale = frameDamping ? damping / frameDamping : 1;
+                    const step = position.distanceTo(sourceCamera.position) * referenceScale;
+                    const zoomStep = Math.abs(Math.log(sourceCamera.zoom / zoom)) * referenceScale;
+                    const poseChanged = step > 0 || sourceCamera.zoom !== zoom || !!(orbitInputs && (!rotation.equals(sourceCamera.quaternion) || !target.equals(controls.target)));
+                    // End the remaining inertia once its 60 Hz movement is imperceptible.
+                    // update() can return false before that tail has actually stopped.
+                    if ((moving || poseChanged) && step < 5e-4 * sourceCamera.position.distanceTo(controls.target) && zoomStep < 5e-4) {
+                        controls.enableDamping = false;
+                        try {
+                            controls.update(0);
+                        }
+                        finally {
+                            controls.enableDamping = true;
+                        }
+                        moving = false;
+                        settled = true;
+                    }
+                    // Once stopped, no more spherical/cartesian round trips occur until
+                    // a gesture, source pose, parent transform or public control option changes.
+                    if (orbitInputs && (settled || (!moving && !poseChanged)))
+                        this._idleControlsState = orbitControlsState(sourceCamera, controls);
+                }
+                else if (orbitInputs && !this._started && !controls.autoRotate && !moving) {
+                    this._idleControlsState = orbitControlsState(sourceCamera, controls);
+                }
+            }
+        }
+        this._store.poseChanged = false;
+        if (this._options.scene && this.scene) {
+            const next = convertScene(this._options.scene, this._options, this._store);
+            if (!snapshotsEqual(this.scene.meshes, next.meshes))
+                this.scene.meshes = next.meshes;
+            if (!snapshotsEqual(this.scene.lights, next.lights))
+                this.scene.lights = next.lights;
+            this.scene.background = next.background;
+            this.engine.scene = this.scene;
+        }
+        let cameraChanged = false;
+        if (sourceCamera) {
+            sourceCamera.updateWorldMatrix(true, false);
+            const next = fromTHREECamera(sourceCamera);
+            const state = snapshotFields(next).slice(1);
+            cameraChanged = this._cameraState.length > 0 && !snapshotsEqual(state, this._cameraState);
+            this._cameraState = state;
+            if (!this._camera)
+                this._camera = next;
+            else
+                this._camera.copy(next);
+            this.engine.camera = this._camera;
+        }
+        this.setActive(this._started || moving || this._store.poseChanged || (cameraChanged && !settled));
+    }
+    /** Removes control subscriptions and caches. The last converted objects remain usable. */
+    dispose() {
+        if (this._disposed)
+            return;
+        this._options.controls?.removeEventListener('start', this._start);
+        this._options.controls?.removeEventListener('end', this._end);
+        this._store = createConversionStore();
+        this._idleControlsState = undefined;
+        this._disposed = true;
+        super.dispose();
+    }
+}
+/**
+ * Converts a Three.js perspective or orthographic camera. A perspective
+ * camera's `focus` and film height (`filmGauge` and `aspect`) become
+ * `focusDistance` and `sensorHeight`.
+ */
+export function fromTHREECamera(threeCamera, options = {}) {
+    const camera = threeCamera.fov
+        ? new Camera({ projection: 'perspective', fov: threeCamera.fov, aspect: threeCamera.aspect, near: threeCamera.near, far: threeCamera.far })
+        : new Camera({ projection: 'orthographic', left: threeCamera.left, right: threeCamera.right, bottom: threeCamera.bottom, top: threeCamera.top, near: threeCamera.near, far: threeCamera.far });
+    threeCamera.updateWorldMatrix(true, false);
+    camera.zoom = threeCamera.zoom;
+    camera.transform =
+        threeCamera.matrixWorld.elements.slice();
+    const perspective = threeCamera;
+    if (perspective.isPerspectiveCamera) {
+        if (perspective.focus > 0)
+            camera.focusDistance = perspective.focus;
+        const filmHeight = perspective.getFilmHeight();
+        if (filmHeight > 0)
+            camera.sensorHeight = filmHeight;
+    }
+    if (options.fStop !== undefined)
+        camera.fStop = options.fStop;
+    if (options.focusDistance !== undefined) {
+        camera.focusDistance = options.focusDistance;
+    }
+    if (options.metersPerUnit !== undefined) {
+        camera.metersPerUnit = options.metersPerUnit;
+    }
+    return camera;
+}
+//# sourceMappingURL=fromTHREE.js.map