@headless-three/renderer 0.1.7 → 0.1.8

package/dist/scene.js

@@ -1,46 +1,135 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSceneExtractionCache = createSceneExtractionCache;
 exports.flattenScene = flattenScene;
 const math_1 = require("./math");
 const attributes_1 = require("./attributes");
 const materials_1 = require("./materials");
 const skinning_1 = require("./skinning");
 const morphs_1 = require("./morphs");
-function flattenScene(scene) {
+const layers_1 = require("./layers");
+const objects_1 = require("./objects");
+const clipping_1 = require("./clipping");
+const SupportedInstancedBufferGeometryAttributes = new Set([
+    'color',
+    'normal',
+    'uv',
+    'uv1',
+    'uv2',
+    'uv3',
+    'instanceOffset',
+    'instancePosition',
+    'instanceScale',
+    'offset',
+    'scale',
+    'translate',
+    'translation',
+]);
+const NativeRenderOrderLimit = 1000000000;
+const MAX_POINT_SPRITE_SIZE = 64;
+function createSceneExtractionCache() {
+    return {
+        meshGeometry: new WeakMap(),
+        instancedMeshes: new WeakMap(),
+        instancedPositionExpansions: new WeakMap(),
+        instancedNormalExpansions: new WeakMap(),
+        instancedUvExpansions: new WeakMap(),
+        instancedColorExpansions: new WeakMap(),
+        batchedGeometryViews: new WeakMap(),
+        dashedLines: new WeakMap(),
+        instancedDashedLines: new WeakMap(),
+        texturePayloads: new WeakMap(),
+        materialColors: new WeakMap(),
+        textureStates: new WeakMap(),
+        materialRenderStates: new WeakMap(),
+        materialScalarFeatures: new WeakMap(),
+        pointBillboards: new WeakMap(),
+        spriteBillboards: new WeakMap(),
+    };
+}
+function flattenScene(scene, camera, viewportHeight = 512, globalClippingPlanes = [], localClippingEnabled = true, shadowMaterialMode, materialContext = {}, sortOptions = {}, overrideMaterial, cache, callbackContext) {
     const meshes = [];
-    visitObject(scene, true, meshes);
-    return meshes;
+    const clippingContext = {
+        unionPlanes: globalClippingPlanes,
+        intersectionPlanes: [],
+        clipShadows: false,
+    };
+    visitObject(scene, camera, meshes, 0, viewportHeight, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext);
+    return nativeMeshesFromSortedFlattened(sortFlattenedMeshes(meshes, sortOptions));
 }
-function visitObject(object, parentVisible, meshes) {
-    if (!object || !parentVisible || object.visible === false)
+function visitObject(object, camera, meshes, groupOrder, viewportHeight, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext) {
+    if (!object)
         return;
-    if (object.isMesh === true && object.geometry) {
-        appendMesh(object, meshes);
-    }
-    else if ((object.isLineSegments === true || object.isLineLoop === true || object.isLine === true) && object.geometry) {
-        appendLineOrPoints(object, meshes, 'lines');
+    if (optionalObjectBoolean(object.visible, 'object.visible') === false)
+        return;
+    const nextGroupOrder = object.isGroup === true
+        ? renderOrderNumber(object.renderOrder, 'object.renderOrder', 0)
+        : groupOrder;
+    const visibleToCamera = (0, layers_1.objectLayersMatchCamera)(object, camera);
+    const nextClippingContext = visibleToCamera
+        ? clippingContextForObject(clippingContext, object)
+        : clippingContext;
+    if (visibleToCamera) {
+        updateLodObject(object, camera);
+        if (object.isBatchedMesh === true && object.geometry) {
+            if (!renderableObjectOutsideFrustum(object, camera)) {
+                appendBatchedMesh(object, camera, meshes, nextGroupOrder, nextClippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext);
+            }
+        }
+        else if (object.isMesh === true && object.geometry) {
+            if (!renderableObjectOutsideFrustum(object, camera)) {
+                appendMesh(object, camera, meshes, nextGroupOrder, nextClippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, undefined, undefined, undefined, callbackContext);
+            }
+        }
+        else if ((object.isLineSegments === true || object.isLineLoop === true || object.isLine === true) && object.geometry) {
+            if (!renderableObjectOutsideFrustum(object, camera)) {
+                appendLineOrPoints(object, camera, meshes, 'lines', nextGroupOrder, viewportHeight, nextClippingContext, localClippingEnabled, materialContext, overrideMaterial, cache, callbackContext);
+            }
+        }
+        else if (object.isPoints === true && object.geometry) {
+            if (!renderableObjectOutsideFrustum(object, camera, viewportHeight, overrideMaterial)) {
+                appendPoints(object, camera, meshes, nextGroupOrder, viewportHeight, nextClippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext);
+            }
+        }
+        else if (object.isSprite === true) {
+            appendSprite(object, camera, meshes, nextGroupOrder, nextClippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext);
+        }
     }
-    else if (object.isPoints === true && object.geometry) {
-        appendLineOrPoints(object, meshes, 'points');
+    for (const child of (0, objects_1.objectChildren)(object)) {
+        visitObject(child, camera, meshes, nextGroupOrder, viewportHeight, nextClippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext);
     }
-    const children = Array.isArray(object.children) ? object.children : [];
-    for (const child of children) {
-        visitObject(child, true, meshes);
+}
+function appendBatchedMesh(object, camera, meshes, groupOrder, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext) {
+    const geometry = object.geometry;
+    const draws = batchedMeshDraws(object, camera, geometry);
+    if (draws.length === 0)
+        return;
+    const objectSortZ = camera ? projectedObjectZ(object, camera) : 0;
+    const sortIndexBase = unsignedSortKey(object.id, meshes.length);
+    for (let drawOrder = 0; drawOrder < draws.length; drawOrder += 1) {
+        const draw = draws[drawOrder];
+        const geometryView = batchedGeometryView(geometry, draw.range, cache);
+        const objectView = Object.create(object);
+        objectView.geometry = geometryView;
+        objectView.isInstancedMesh = false;
+        objectView.instanceMatrix = undefined;
+        objectView.instanceColor = undefined;
+        objectView.count = undefined;
+        const sortKeyOverride = {
+            sortZ: objectSortZ,
+            sortIndex: batchedDrawSortIndex(sortIndexBase, drawOrder),
+        };
+        appendMesh(objectView, camera, meshes, groupOrder, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, [draw.instance], sortKeyOverride, object, callbackContext, draw.z);
     }
 }
-function appendMesh(object, meshes) {
+function appendMesh(object, camera, meshes, groupOrder, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, instanceOverride, sortKeyOverride, sortItemObject, callbackContext, sortItemZOverride) {
     const geometry = object.geometry;
-    const position = (0, attributes_1.getAttribute)(geometry, 'position');
-    if (!position)
+    const geometryExtraction = meshGeometryExtraction(geometry, cache);
+    if (!geometryExtraction)
         return;
-    let positions = (0, attributes_1.readVec3Attribute)(position);
-    const uvAttribute = (0, attributes_1.getAttribute)(geometry, 'uv');
-    const uvs = uvAttribute ? (0, attributes_1.readVec2Attribute)(uvAttribute) : null;
-    const normalAttribute = (0, attributes_1.getAttribute)(geometry, 'normal');
-    let normals = normalAttribute ? (0, attributes_1.readVec3Attribute)(normalAttribute) : null;
-    const vertexColors = (0, attributes_1.getAttribute)(geometry, 'color');
-    const index = geometry.index ? (0, attributes_1.readIndexAttribute)(geometry.index) : null;
-    const groups = effectiveGroups(geometry, index, position.count);
+    const { position, uvChannels, uvs, normalAttribute, vertexColors, index, groups, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, } = geometryExtraction;
+    let positions = geometryExtraction.positions;
+    let normals = geometryExtraction.normals;
     // CPU-side morph targets (blend shapes / shape keys / VRM blendshapes)
     if (object.morphTargetInfluences && object.morphTargetInfluences.length > 0) {
         const morphed = (0, morphs_1.applyMorphTargets)(object, positions, normals);
@@ -55,140 +144,3625 @@ function appendMesh(object, meshes) {
     }
     // For skinned meshes, positions are already in world space after CPU skinning.
     const isSkinned = object.isSkinnedMesh === true && object.skeleton;
-    const meshTransform = isSkinned
+    const meshTransform = instanceOverride
         ? math_1.IDENTITY_4X4.slice()
-        : (0, math_1.matrixElements)(object.matrixWorld, 'mesh.matrixWorld');
+        : isSkinned
+            ? math_1.IDENTITY_4X4.slice()
+            : (0, math_1.matrixElements)(object.matrixWorld, 'mesh.matrixWorld');
+    const instances = instanceOverride ?? meshInstances(object, meshTransform, cache);
+    if (instances.length === 0)
+        return;
+    const objectCastsShadow = optionalObjectBoolean(object.castShadow, 'object.castShadow') === true;
+    const objectReceivesShadow = optionalObjectBoolean(object.receiveShadow, 'object.receiveShadow') === true;
+    const callbackObject = sortItemObject ?? object;
     for (const group of groups) {
-        const material = (0, materials_1.materialForGroup)(object.material, group.materialIndex);
+        const material = materialForObjectGroup(object, group.materialIndex, overrideMaterial);
         if (material?.visible === false)
             continue;
-        const color = (0, materials_1.materialColor)(material);
+        invokeObjectRenderCallback(callbackObject.onBeforeRender, 'onBeforeRender', callbackContext, callbackObject, camera, geometry, material, group);
+        const customShadowMaterial = customShadowMaterialForMode(object, shadowMaterialMode);
+        const usesCustomShadowMaterial = objectCastsShadow && customShadowMaterial != null;
+        const baseColor = (0, materials_1.materialColor)(material, materialContext);
         const useVertexColors = vertexColors && material?.vertexColors !== false;
-        const pbrProps = (0, materials_1.extractPbrProperties)(material);
-        const textureInfo = (0, materials_1.extractTextureData)(material);
-        const castShadow = object.castShadow === true ? true : undefined;
-        const receiveShadow = object.receiveShadow === true ? true : undefined;
+        const pbrProps = (0, materials_1.extractPbrProperties)(material, materialContext);
+        assertSupportedCustomFragmentInstancedAttributes(geometry, pbrProps);
+        const uvStreams = textureUvStreamsForMeshMaterial(uvChannels, material);
+        if (uvStreams.alphaMapUsesUv2 !== undefined) {
+            pbrProps.alphaMapUsesUv2 = uvStreams.alphaMapUsesUv2;
+        }
+        applyPbrUvStreamFlags(pbrProps, uvStreams);
+        const textureInfo = (0, materials_1.extractTextureData)(material, materialContext);
+        const castShadow = objectCastsShadow && !usesCustomShadowMaterial ? true : undefined;
+        const receiveShadow = objectReceivesShadow ? true : undefined;
+        const clipping = clippingState(clippingContext, material, localClippingEnabled);
+        const wireframe = isMeshWireframeMaterial(material);
         if (index) {
             const indices = index.slice(group.start, group.start + group.count);
             if (indices.length % 3 !== 0) {
                 throw new Error(`THREE.Mesh "${object.name || object.uuid || '<unnamed>'}" has a non-triangle index range`);
             }
-            meshes.push({
-                positions,
-                indices,
-                normals: normals ?? undefined,
-                color,
-                colors: useVertexColors ? (0, attributes_1.readColorAttribute)(vertexColors, color) : undefined,
-                uvs: uvs ?? undefined,
-                texture: textureInfo?.data,
-                textureWidth: textureInfo?.width ?? undefined,
-                textureHeight: textureInfo?.height ?? undefined,
-                textureWrapS: textureInfo?.wrapS,
-                textureWrapT: textureInfo?.wrapT,
-                transform: meshTransform,
-                castShadow,
-                receiveShadow,
-                ...pbrProps,
-            });
+            const renderIndices = wireframe ? wireframeIndicesForTriangles(indices) : indices;
+            const expandedIndices = expandIndicesForInstances(renderIndices, position.count, instancedGeometryCount);
+            const expandedPositions = expandVec3ValuesForInstancesWithCache(cache, geometry, position, positions, 0, position.count, instancedGeometryCount, instancedPositionOffset, instancedPositionScale);
+            const expandedNormals = normalAttribute && normals
+                ? expandNormalValuesForInstancesWithCache(cache, geometry, normalAttribute, normals, 0, position.count, instancedGeometryCount)
+                : undefined;
+            const expandedUvs = uvStreams.uvs
+                ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs, 0, position.count, instancedGeometryCount)
+                : undefined;
+            const expandedSecondaryUvs = uvStreams.uvs2
+                ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs2, 0, position.count, instancedGeometryCount)
+                : undefined;
+            for (const instance of instances) {
+                const color = instanceColor(baseColor, instance);
+                const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder, instance.transform, geometry, group, sortItemObject, sortItemZOverride);
+                const sortKeys = mergeSortKeys(sortInfo.keys, sortKeyOverride);
+                pushMesh(meshes, {
+                    positions: expandedPositions,
+                    indices: expandedIndices,
+                    normals: expandedNormals,
+                    color,
+                    colors: useVertexColors
+                        ? expandColorAttributeForInstancesWithCache(cache, geometry, vertexColors, color, 0, position.count, instancedGeometryCount)
+                        : undefined,
+                    uvs: expandedUvs,
+                    uvs2: expandedSecondaryUvs,
+                    texture: textureInfo?.data,
+                    textureWidth: textureInfo?.width ?? undefined,
+                    textureHeight: textureInfo?.height ?? undefined,
+                    textureWrapS: textureInfo?.wrapS,
+                    textureWrapT: textureInfo?.wrapT,
+                    textureMagFilter: textureInfo?.magFilter,
+                    textureMinFilter: textureInfo?.minFilter,
+                    textureAnisotropy: textureInfo?.anisotropy,
+                    textureTransform: textureInfo?.transform,
+                    textureColorSpace: textureInfo?.colorSpace,
+                    textureUsesUv2: uvStreams.textureUsesUv2 ?? textureInfo?.usesUv2,
+                    transform: instance.transform,
+                    topology: wireframe ? 'lines' : undefined,
+                    castShadow,
+                    receiveShadow,
+                    clipShadows: clipShadowsForMaterial(material, clippingContext),
+                    ...clipping,
+                    ...sortKeys,
+                    ...pbrProps,
+                }, sortInfo.item, needsTransparentDoubleSidePass(material, pbrProps, wireframe));
+            }
         }
         else {
             if (group.count % 3 !== 0) {
                 throw new Error(`THREE.Mesh "${object.name || object.uuid || '<unnamed>'}" has a non-triangle vertex range`);
             }
-            meshes.push({
-                positions: positions.slice(group.start * 3, (group.start + group.count) * 3),
-                normals: normals ? normals.slice(group.start * 3, (group.start + group.count) * 3) : undefined,
+            const expandedGroupPositions = expandVec3ValuesForInstancesWithCache(cache, geometry, position, positions, group.start, group.count, instancedGeometryCount, instancedPositionOffset, instancedPositionScale);
+            const expandedGroupNormals = normalAttribute && normals
+                ? expandNormalValuesForInstancesWithCache(cache, geometry, normalAttribute, normals, group.start, group.count, instancedGeometryCount)
+                : undefined;
+            const expandedGroupUvs = uvStreams.uvs
+                ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs, group.start, group.count, instancedGeometryCount)
+                : undefined;
+            const expandedGroupSecondaryUvs = uvStreams.uvs2
+                ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs2, group.start, group.count, instancedGeometryCount)
+                : undefined;
+            const expandedGroupIndices = wireframe
+                ? expandIndicesForInstances(wireframeIndicesForUnindexedTriangles(group.count), group.count, instancedGeometryCount)
+                : undefined;
+            for (const instance of instances) {
+                const color = instanceColor(baseColor, instance);
+                const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder, instance.transform, geometry, group, sortItemObject, sortItemZOverride);
+                const sortKeys = mergeSortKeys(sortInfo.keys, sortKeyOverride);
+                pushMesh(meshes, {
+                    positions: expandedGroupPositions,
+                    indices: expandedGroupIndices,
+                    normals: expandedGroupNormals,
+                    color,
+                    colors: useVertexColors
+                        ? expandColorAttributeForInstancesWithCache(cache, geometry, vertexColors, color, group.start, group.count, instancedGeometryCount)
+                        : undefined,
+                    uvs: expandedGroupUvs,
+                    uvs2: expandedGroupSecondaryUvs,
+                    texture: textureInfo?.data,
+                    textureWidth: textureInfo?.width ?? undefined,
+                    textureHeight: textureInfo?.height ?? undefined,
+                    textureWrapS: textureInfo?.wrapS,
+                    textureWrapT: textureInfo?.wrapT,
+                    textureMagFilter: textureInfo?.magFilter,
+                    textureMinFilter: textureInfo?.minFilter,
+                    textureAnisotropy: textureInfo?.anisotropy,
+                    textureTransform: textureInfo?.transform,
+                    textureColorSpace: textureInfo?.colorSpace,
+                    textureUsesUv2: uvStreams.textureUsesUv2 ?? textureInfo?.usesUv2,
+                    transform: instance.transform,
+                    topology: wireframe ? 'lines' : undefined,
+                    castShadow,
+                    receiveShadow,
+                    clipShadows: clipShadowsForMaterial(material, clippingContext),
+                    ...clipping,
+                    ...sortKeys,
+                    ...pbrProps,
+                }, sortInfo.item, needsTransparentDoubleSidePass(material, pbrProps, wireframe));
+            }
+        }
+        if (usesCustomShadowMaterial && customShadowMaterial?.visible !== false) {
+            appendShadowOnlyMeshGroup(object, camera, meshes, group, groupOrder, clippingContext, localClippingEnabled, customShadowMaterial, material, materialContext, positions, normals, normalAttribute, uvs, uvChannels, vertexColors, position.count, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, instances, cache);
+        }
+        invokeObjectRenderCallback(callbackObject.onAfterRender, 'onAfterRender', callbackContext, callbackObject, camera, geometry, material, group);
+    }
+}
+function meshGeometryExtraction(geometry, cache) {
+    const position = (0, attributes_1.getAttribute)(geometry, 'position');
+    if (!position)
+        return null;
+    const signature = meshGeometrySignature(geometry, position);
+    if (cache && signature.cacheable) {
+        const cached = cache.meshGeometry.get(geometry);
+        if (cached && sameMeshGeometrySignature(cached.signature, signature)) {
+            return cached.extraction;
+        }
+    }
+    const extraction = readMeshGeometryExtraction(geometry, position);
+    if (cache && signature.cacheable) {
+        cache.meshGeometry.set(geometry, { signature, extraction });
+    }
+    return extraction;
+}
+function readMeshGeometryExtraction(geometry, position) {
+    const positions = (0, attributes_1.readVec3Attribute)(position, 'geometry.attributes.position');
+    const uvChannels = readUvChannels(geometry);
+    const normalAttribute = (0, attributes_1.getAttribute)(geometry, 'normal');
+    const normals = normalAttribute ? (0, attributes_1.readVec3Attribute)(normalAttribute, 'geometry.attributes.normal') : null;
+    const vertexColors = (0, attributes_1.getAttribute)(geometry, 'color');
+    const index = geometry.index ? (0, attributes_1.readIndexAttribute)(geometry.index, 'geometry.index', position.count) : null;
+    const sourceIndex = index ?? rangeIndices(position.count);
+    const groups = effectiveGroups(geometry, index, position.count);
+    const instancedGeometryCount = instancedBufferGeometryCount(geometry);
+    const instancedPositionOffset = instancedOffsetAttribute(geometry);
+    const instancedPositionScale = instancedScaleAttribute(geometry);
+    return {
+        position,
+        positions,
+        uvChannels,
+        uvs: uvChannels[0]?.values ?? null,
+        normalAttribute,
+        normals,
+        vertexColors,
+        index,
+        sourceIndex,
+        groups,
+        instancedGeometryCount,
+        instancedPositionOffset,
+        instancedPositionScale,
+    };
+}
+function meshGeometrySignature(geometry, position) {
+    const attributes = (0, attributes_1.geometryAttributes)(geometry);
+    const instancedAttributes = Object.entries(attributes)
+        .filter((entry) => isInstancedAttribute(entry[1]))
+        .map(([name, attribute]) => ({ name, signature: attributeSignature(attribute) }));
+    const instancedPositionOffset = namedInstancedOffsetAttribute(geometry);
+    const instancedPositionScale = namedInstancedScaleAttribute(geometry);
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        isInstancedBufferGeometry: geometry.isInstancedBufferGeometry,
+        instanceCount: geometry.instanceCount,
+        drawRange: geometryDrawRangeSignature(geometry.drawRange),
+        drawRangeStart: geometry.drawRange?.start,
+        drawRangeCount: geometry.drawRange?.count,
+        groups: geometryGroupsSignature(geometry.groups),
+        position: attributeSignature(position),
+        normal: attributeSignature((0, attributes_1.getAttribute)(geometry, 'normal')),
+        color: attributeSignature((0, attributes_1.getAttribute)(geometry, 'color')),
+        index: attributeSignature(geometry.index),
+        uv: attributeSignature((0, attributes_1.getAttribute)(geometry, 'uv')),
+        uv1: attributeSignature((0, attributes_1.getAttribute)(geometry, 'uv1')),
+        uv2: attributeSignature((0, attributes_1.getAttribute)(geometry, 'uv2')),
+        uv3: attributeSignature((0, attributes_1.getAttribute)(geometry, 'uv3')),
+        instancedPositionOffsetName: instancedPositionOffset?.name,
+        instancedPositionOffset: attributeSignature(instancedPositionOffset?.attribute),
+        instancedPositionScaleName: instancedPositionScale?.name,
+        instancedPositionScale: attributeSignature(instancedPositionScale?.attribute),
+        instancedAttributes,
+    };
+    signature.cacheable = meshGeometrySignatureCacheable(signature);
+    return signature;
+}
+function meshGeometrySignatureCacheable(signature) {
+    return [
+        signature.position,
+        signature.normal,
+        signature.color,
+        signature.index,
+        signature.uv,
+        signature.uv1,
+        signature.uv2,
+        signature.uv3,
+        signature.instancedPositionOffset,
+        signature.instancedPositionScale,
+        ...signature.instancedAttributes.map(({ signature }) => signature),
+    ].every(attributeSignatureCacheable);
+}
+function attributeSignature(attribute) {
+    if (!attribute)
+        return {};
+    const data = attribute.data && typeof attribute.data === 'object' && !Array.isArray(attribute.data)
+        ? attribute.data
+        : undefined;
+    return {
+        ref: attribute,
+        version: attribute.version,
+        count: attribute.count,
+        itemSize: attribute.itemSize,
+        normalized: attribute.normalized,
+        array: attribute.array,
+        dataArray: data?.array,
+        dataStride: data?.stride,
+        offset: attribute.offset,
+        isInstancedBufferAttribute: attribute.isInstancedBufferAttribute,
+        meshPerAttribute: attribute.meshPerAttribute,
+    };
+}
+function attributeSignatureCacheable(signature) {
+    return signature.ref == null || typeof signature.version === 'number';
+}
+function namedInstancedOffsetAttribute(geometry) {
+    const names = ['instanceOffset', 'instancePosition', 'offset', 'translate', 'translation'];
+    for (const name of names) {
+        const attribute = (0, attributes_1.getAttribute)(geometry, name);
+        if (isInstancedAttribute(attribute))
+            return { name, attribute };
+    }
+    return null;
+}
+function namedInstancedScaleAttribute(geometry) {
+    const names = ['instanceScale', 'scale'];
+    for (const name of names) {
+        const attribute = (0, attributes_1.getAttribute)(geometry, name);
+        if (isInstancedAttribute(attribute))
+            return { name, attribute };
+    }
+    return null;
+}
+function geometryGroupsSignature(groups) {
+    if (groups == null)
+        return 'none';
+    if (!Array.isArray(groups))
+        return `invalid:${typeof groups}`;
+    return groups.map((group, index) => {
+        if (!group || typeof group !== 'object' || Array.isArray(group)) {
+            return `${index}:invalid:${typeof group}`;
+        }
+        return [
+            index,
+            typeof group.start,
+            String(group.start),
+            typeof group.count,
+            String(group.count),
+            typeof group.materialIndex,
+            String(group.materialIndex),
+        ].join(':');
+    }).join('|');
+}
+function geometryDrawRangeSignature(drawRange) {
+    if (drawRange == null)
+        return 'none';
+    if (typeof drawRange !== 'object' || Array.isArray(drawRange))
+        return `invalid:${typeof drawRange}`;
+    return [
+        typeof drawRange.start,
+        String(drawRange.start),
+        typeof drawRange.count,
+        String(drawRange.count),
+    ].join(':');
+}
+function sameMeshGeometrySignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && a.isInstancedBufferGeometry === b.isInstancedBufferGeometry
+        && a.instanceCount === b.instanceCount
+        && a.drawRange === b.drawRange
+        && Object.is(a.drawRangeStart, b.drawRangeStart)
+        && Object.is(a.drawRangeCount, b.drawRangeCount)
+        && a.groups === b.groups
+        && a.instancedPositionOffsetName === b.instancedPositionOffsetName
+        && a.instancedPositionScaleName === b.instancedPositionScaleName
+        && sameAttributeSignature(a.position, b.position)
+        && sameAttributeSignature(a.normal, b.normal)
+        && sameAttributeSignature(a.color, b.color)
+        && sameAttributeSignature(a.index, b.index)
+        && sameAttributeSignature(a.uv, b.uv)
+        && sameAttributeSignature(a.uv1, b.uv1)
+        && sameAttributeSignature(a.uv2, b.uv2)
+        && sameAttributeSignature(a.uv3, b.uv3)
+        && sameAttributeSignature(a.instancedPositionOffset, b.instancedPositionOffset)
+        && sameAttributeSignature(a.instancedPositionScale, b.instancedPositionScale)
+        && sameInstancedAttributeSignatures(a.instancedAttributes, b.instancedAttributes);
+}
+function sameInstancedAttributeSignatures(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i += 1) {
+        if (a[i].name !== b[i].name)
+            return false;
+        if (!sameAttributeSignature(a[i].signature, b[i].signature))
+            return false;
+    }
+    return true;
+}
+function sameAttributeSignature(a, b) {
+    return a.ref === b.ref
+        && a.version === b.version
+        && a.count === b.count
+        && a.itemSize === b.itemSize
+        && a.normalized === b.normalized
+        && a.array === b.array
+        && a.dataArray === b.dataArray
+        && a.dataStride === b.dataStride
+        && a.offset === b.offset
+        && a.isInstancedBufferAttribute === b.isInstancedBufferAttribute
+        && a.meshPerAttribute === b.meshPerAttribute;
+}
+function appendShadowOnlyMeshGroup(object, camera, meshes, group, groupOrder, clippingContext, localClippingEnabled, material, sourceMaterial, materialContext, positions, normals, normalAttribute, uvs, uvChannels, vertexColors, vertexCount, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, instances, cache) {
+    const shadowMaterial = shadowMaterialWithSourceShadowState(material, sourceMaterial);
+    const baseColor = (0, materials_1.materialColor)(shadowMaterial, materialContext);
+    const useVertexColors = vertexColors && material.vertexColors !== false;
+    const pbrProps = shadowPbrProperties(shadowMaterial, sourceMaterial, materialContext);
+    assertSupportedCustomFragmentInstancedAttributes(object.geometry, pbrProps);
+    const uvStreams = textureUvStreamsForMeshMaterial(uvChannels, shadowMaterial);
+    if (uvStreams.alphaMapUsesUv2 !== undefined) {
+        pbrProps.alphaMapUsesUv2 = uvStreams.alphaMapUsesUv2;
+    }
+    applyPbrUvStreamFlags(pbrProps, uvStreams);
+    const textureInfo = (0, materials_1.extractTextureData)(shadowMaterial, materialContext);
+    const clipping = clippingState(clippingContext, shadowMaterial, localClippingEnabled);
+    const wireframe = isDepthDistanceWireframeMaterial(shadowMaterial);
+    const hiddenMainPass = shadowOnlyMainPassState();
+    if (index) {
+        const indices = index.slice(group.start, group.start + group.count);
+        if (indices.length % 3 !== 0) {
+            throw new Error(`THREE.Mesh "${object.name || object.uuid || '<unnamed>'}" has a non-triangle index range`);
+        }
+        const renderIndices = wireframe ? wireframeIndicesForTriangles(indices) : indices;
+        const expandedIndices = expandIndicesForInstances(renderIndices, vertexCount, instancedGeometryCount);
+        const geometry = object.geometry;
+        const expandedPositions = expandVec3ValuesForInstancesWithCache(cache, geometry, (0, attributes_1.getAttribute)(geometry, 'position'), positions, 0, vertexCount, instancedGeometryCount, instancedPositionOffset, instancedPositionScale);
+        const expandedNormals = normalAttribute && normals
+            ? expandNormalValuesForInstancesWithCache(cache, geometry, normalAttribute, normals, 0, vertexCount, instancedGeometryCount)
+            : undefined;
+        const expandedUvs = uvStreams.uvs
+            ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs, 0, vertexCount, instancedGeometryCount)
+            : undefined;
+        const expandedSecondaryUvs = uvStreams.uvs2
+            ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs2, 0, vertexCount, instancedGeometryCount)
+            : undefined;
+        for (const instance of instances) {
+            const color = instanceColor(baseColor, instance);
+            const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder, instance.transform, object.geometry, group);
+            pushMesh(meshes, {
+                positions: expandedPositions,
+                indices: expandedIndices,
+                normals: expandedNormals,
                 color,
                 colors: useVertexColors
-                    ? (0, attributes_1.readColorAttribute)(vertexColors, color).slice(group.start * 4, (group.start + group.count) * 4)
+                    ? expandColorAttributeForInstancesWithCache(cache, geometry, vertexColors, color, 0, vertexCount, instancedGeometryCount)
                     : undefined,
-                uvs: uvs ? uvs.slice(group.start * 2, (group.start + group.count) * 2) : undefined,
+                uvs: expandedUvs,
+                uvs2: expandedSecondaryUvs,
                 texture: textureInfo?.data,
                 textureWidth: textureInfo?.width ?? undefined,
                 textureHeight: textureInfo?.height ?? undefined,
                 textureWrapS: textureInfo?.wrapS,
                 textureWrapT: textureInfo?.wrapT,
-                transform: meshTransform,
-                castShadow,
-                receiveShadow,
+                textureMagFilter: textureInfo?.magFilter,
+                textureMinFilter: textureInfo?.minFilter,
+                textureAnisotropy: textureInfo?.anisotropy,
+                textureTransform: textureInfo?.transform,
+                textureColorSpace: textureInfo?.colorSpace,
+                textureUsesUv2: uvStreams.textureUsesUv2 ?? textureInfo?.usesUv2,
+                transform: instance.transform,
+                topology: wireframe ? 'lines' : undefined,
+                castShadow: true,
+                receiveShadow: false,
+                clipShadows: clipShadowsForMaterial(shadowMaterial, clippingContext),
+                ...clipping,
+                ...sortInfo.keys,
                 ...pbrProps,
-            });
+                ...hiddenMainPass,
+            }, sortInfo.item);
+        }
+        return;
+    }
+    if (group.count % 3 !== 0) {
+        throw new Error(`THREE.Mesh "${object.name || object.uuid || '<unnamed>'}" has a non-triangle vertex range`);
+    }
+    const geometry = object.geometry;
+    const expandedGroupPositions = expandVec3ValuesForInstancesWithCache(cache, geometry, (0, attributes_1.getAttribute)(geometry, 'position'), positions, group.start, group.count, instancedGeometryCount, instancedPositionOffset, instancedPositionScale);
+    const expandedGroupNormals = normalAttribute && normals
+        ? expandNormalValuesForInstancesWithCache(cache, geometry, normalAttribute, normals, group.start, group.count, instancedGeometryCount)
+        : undefined;
+    const expandedGroupUvs = uvStreams.uvs
+        ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs, group.start, group.count, instancedGeometryCount)
+        : undefined;
+    const expandedGroupSecondaryUvs = uvStreams.uvs2
+        ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs2, group.start, group.count, instancedGeometryCount)
+        : undefined;
+    const expandedGroupIndices = wireframe
+        ? expandIndicesForInstances(wireframeIndicesForUnindexedTriangles(group.count), group.count, instancedGeometryCount)
+        : undefined;
+    for (const instance of instances) {
+        const color = instanceColor(baseColor, instance);
+        const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder, instance.transform, object.geometry, group);
+        pushMesh(meshes, {
+            positions: expandedGroupPositions,
+            indices: expandedGroupIndices,
+            normals: expandedGroupNormals,
+            color,
+            colors: useVertexColors
+                ? expandColorAttributeForInstancesWithCache(cache, geometry, vertexColors, color, group.start, group.count, instancedGeometryCount)
+                : undefined,
+            uvs: expandedGroupUvs,
+            uvs2: expandedGroupSecondaryUvs,
+            texture: textureInfo?.data,
+            textureWidth: textureInfo?.width ?? undefined,
+            textureHeight: textureInfo?.height ?? undefined,
+            textureWrapS: textureInfo?.wrapS,
+            textureWrapT: textureInfo?.wrapT,
+            textureMagFilter: textureInfo?.magFilter,
+            textureMinFilter: textureInfo?.minFilter,
+            textureAnisotropy: textureInfo?.anisotropy,
+            textureTransform: textureInfo?.transform,
+            textureColorSpace: textureInfo?.colorSpace,
+            textureUsesUv2: uvStreams.textureUsesUv2 ?? textureInfo?.usesUv2,
+            transform: instance.transform,
+            topology: wireframe ? 'lines' : undefined,
+            castShadow: true,
+            receiveShadow: false,
+            clipShadows: clipShadowsForMaterial(shadowMaterial, clippingContext),
+            ...clipping,
+            ...sortInfo.keys,
+            ...pbrProps,
+            ...hiddenMainPass,
+        }, sortInfo.item);
+    }
+}
+function customShadowMaterialForMode(object, mode) {
+    if (mode === 'depth') {
+        (0, materials_1.assertMaterialLike)(object.customDepthMaterial, 'Object3D.customDepthMaterial');
+        optionalSceneBoolean(object.customDepthMaterial?.visible, 'Object3D.customDepthMaterial.visible');
+        return object.customDepthMaterial;
+    }
+    if (mode === 'distance') {
+        (0, materials_1.assertMaterialLike)(object.customDistanceMaterial, 'Object3D.customDistanceMaterial');
+        optionalSceneBoolean(object.customDistanceMaterial?.visible, 'Object3D.customDistanceMaterial.visible');
+        return object.customDistanceMaterial;
+    }
+    return undefined;
+}
+function materialForObjectGroup(object, materialIndex, overrideMaterial) {
+    if (overrideMaterial !== undefined) {
+        (0, materials_1.assertMaterialLike)(overrideMaterial, 'scene.overrideMaterial');
+        return overrideMaterial;
+    }
+    return (0, materials_1.materialForGroup)(object.material, materialIndex);
+}
+function invokeObjectRenderCallback(callback, name, context, object, camera, geometry, material, group) {
+    if (callback == null)
+        return;
+    if (typeof callback !== 'function') {
+        throw new TypeError(`THREE.Object3D.${name} must be a function when provided.`);
+    }
+    if (isInternalBatchedMeshRenderCallback(object, callback, name))
+        return;
+    if (!context)
+        return;
+    callback.call(object, context.renderer, context.scene, camera, geometry, material, group);
+}
+function isInternalBatchedMeshRenderCallback(object, callback, name) {
+    if (name !== 'onBeforeRender' || object.isBatchedMesh !== true)
+        return false;
+    if (Object.prototype.hasOwnProperty.call(object, name))
+        return false;
+    let prototype = Object.getPrototypeOf(object);
+    while (prototype && prototype !== Object.prototype) {
+        if (prototype.constructor?.name === 'BatchedMesh' && typeof prototype[name] === 'function') {
+            return callback === prototype[name];
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return false;
+}
+function shadowOnlyMainPassState() {
+    return {
+        blending: 'none',
+        colorWrite: false,
+        depthTest: false,
+        depthWrite: false,
+        stencilWrite: false,
+        transparent: false,
+    };
+}
+function appendSprite(object, camera, meshes, groupOrder, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext) {
+    const objectCastsShadow = optionalObjectBoolean(object.castShadow, 'object.castShadow') === true;
+    optionalObjectBoolean(object.receiveShadow, 'object.receiveShadow');
+    const material = materialForObjectGroup(object, 0, overrideMaterial);
+    if (material?.visible === false)
+        return;
+    validateSpriteScale(object);
+    const matrix = (0, math_1.matrixElements)(object.matrixWorld, 'sprite.matrixWorld');
+    const center = [
+        finiteMaterialOrObjectNumber(object.center?.x, 'Sprite.center.x', 0.5),
+        finiteMaterialOrObjectNumber(object.center?.y, 'Sprite.center.y', 0.5),
+    ];
+    if (spriteOutsideFrustum(object, camera, matrix, center))
+        return;
+    invokeObjectRenderCallback(object.onBeforeRender, 'onBeforeRender', callbackContext, object, camera, object.geometry, material);
+    const worldPosition = [matrix[12], matrix[13], matrix[14]];
+    let scaleX = columnLength3(matrix, 0);
+    let scaleY = columnLength3(matrix, 4);
+    const sizeAttenuation = optionalSceneBoolean(material?.sizeAttenuation, 'material.sizeAttenuation');
+    if (sizeAttenuation === false && camera?.isPerspectiveCamera === true) {
+        const viewZ = viewSpaceZ(worldPosition, camera);
+        if (Number.isFinite(viewZ)) {
+            scaleX *= -viewZ;
+            scaleY *= -viewZ;
+        }
+    }
+    if (scaleX <= 0 || scaleY <= 0)
+        return;
+    const axes = cameraBillboardAxes(camera);
+    const rotation = finiteMaterialOrObjectNumber(material?.rotation, 'material.rotation', 0);
+    const billboard = spriteBillboardExpansion(object, matrix, worldPosition, center, scaleX, scaleY, rotation, sizeAttenuation, axes, camera, cache);
+    const positions = billboard.positions;
+    const indices = billboard.indices;
+    const uvs = billboard.uvs;
+    const textureInfo = (0, materials_1.extractTextureData)(material, materialContext);
+    const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder);
+    const pbrProps = (0, materials_1.extractPbrProperties)(material, materialContext);
+    pbrProps.alphaMapUsesUv2 = false;
+    const clipping = clippingState(clippingContext, material, localClippingEnabled);
+    const customShadowMaterial = customShadowMaterialForMode(object, shadowMaterialMode);
+    const usesCustomShadowMaterial = objectCastsShadow && customShadowMaterial != null;
+    pushMesh(meshes, {
+        positions,
+        indices,
+        uvs,
+        color: (0, materials_1.materialColor)(material, materialContext),
+        texture: textureInfo?.data,
+        textureWidth: textureInfo?.width ?? undefined,
+        textureHeight: textureInfo?.height ?? undefined,
+        textureWrapS: textureInfo?.wrapS,
+        textureWrapT: textureInfo?.wrapT,
+        textureMagFilter: textureInfo?.magFilter,
+        textureMinFilter: textureInfo?.minFilter,
+        textureAnisotropy: textureInfo?.anisotropy,
+        textureTransform: textureInfo?.transform,
+        textureColorSpace: textureInfo?.colorSpace,
+        textureUsesUv2: false,
+        transform: math_1.IDENTITY_4X4.slice(),
+        transparent: material?.transparent !== false,
+        castShadow: objectCastsShadow && !usesCustomShadowMaterial ? true : undefined,
+        receiveShadow: undefined,
+        clipShadows: clipShadowsForMaterial(material, clippingContext),
+        ...clipping,
+        ...sortInfo.keys,
+        ...pbrProps,
+    }, sortInfo.item);
+    if (usesCustomShadowMaterial && customShadowMaterial?.visible !== false) {
+        appendShadowOnlyBillboardMesh(object, camera, meshes, groupOrder, clippingContext, localClippingEnabled, customShadowMaterial, material, materialContext, positions, indices, uvs);
+    }
+    invokeObjectRenderCallback(object.onAfterRender, 'onAfterRender', callbackContext, object, camera, object.geometry, material);
+}
+function spriteBillboardExpansion(object, matrix, worldPosition, center, scaleX, scaleY, rotation, sizeAttenuation, axes, camera, cache) {
+    const signature = spriteBillboardSignature(matrix, center, scaleX, scaleY, rotation, sizeAttenuation, axes, camera);
+    if (cache) {
+        const cached = cache.spriteBillboards.get(object);
+        if (cached && sameSpriteBillboardSignature(cached.signature, signature)) {
+            return cached.expansion;
+        }
+    }
+    const expansion = readSpriteBillboardExpansion(worldPosition, center, scaleX, scaleY, rotation, axes);
+    if (cache) {
+        cache.spriteBillboards.set(object, { signature, expansion });
+    }
+    return expansion;
+}
+function readSpriteBillboardExpansion(worldPosition, center, scaleX, scaleY, rotation, axes) {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const corners = [
+        [-0.5, -0.5, 0, 0],
+        [0.5, -0.5, 1, 0],
+        [0.5, 0.5, 1, 1],
+        [-0.5, 0.5, 0, 1],
+    ];
+    const positions = [];
+    const uvs = [];
+    for (const [x, y, u, v] of corners) {
+        const alignedX = (x - (center[0] - 0.5)) * scaleX;
+        const alignedY = (y - (center[1] - 0.5)) * scaleY;
+        const rotatedX = cos * alignedX - sin * alignedY;
+        const rotatedY = sin * alignedX + cos * alignedY;
+        positions.push(worldPosition[0] + axes.right[0] * rotatedX + axes.up[0] * rotatedY, worldPosition[1] + axes.right[1] * rotatedX + axes.up[1] * rotatedY, worldPosition[2] + axes.right[2] * rotatedX + axes.up[2] * rotatedY);
+        uvs.push(u, v);
+    }
+    return {
+        positions,
+        indices: [0, 1, 2, 0, 2, 3],
+        uvs,
+    };
+}
+function spriteBillboardSignature(matrix, center, scaleX, scaleY, rotation, sizeAttenuation, axes, camera) {
+    return {
+        matrix: matrix.slice(0, 16),
+        center: center.slice(),
+        scaleX,
+        scaleY,
+        rotation,
+        sizeAttenuation,
+        cameraRight: axes.right.slice(),
+        cameraUp: axes.up.slice(),
+        cameraView: matrixValues(camera?.matrixWorldInverse?.elements),
+        cameraIsPerspective: camera?.isPerspectiveCamera,
+    };
+}
+function sameSpriteBillboardSignature(a, b) {
+    return sameNumberArray(a.matrix, b.matrix)
+        && sameNumberArray(a.center, b.center)
+        && a.scaleX === b.scaleX
+        && a.scaleY === b.scaleY
+        && a.rotation === b.rotation
+        && a.sizeAttenuation === b.sizeAttenuation
+        && sameNumberArray(a.cameraRight, b.cameraRight)
+        && sameNumberArray(a.cameraUp, b.cameraUp)
+        && sameOptionalNumberArray(a.cameraView, b.cameraView)
+        && a.cameraIsPerspective === b.cameraIsPerspective;
+}
+function validateSpriteScale(object) {
+    finiteMaterialOrObjectNumber(object.scale?.x, 'Sprite.scale.x', 1);
+    finiteMaterialOrObjectNumber(object.scale?.y, 'Sprite.scale.y', 1);
+    finiteMaterialOrObjectNumber(object.scale?.z, 'Sprite.scale.z', 1);
+}
+function appendPoints(object, camera, meshes, groupOrder, viewportHeight, clippingContext, localClippingEnabled, shadowMaterialMode, materialContext, overrideMaterial, cache, callbackContext) {
+    const objectCastsShadow = optionalObjectBoolean(object.castShadow, 'object.castShadow') === true;
+    optionalObjectBoolean(object.receiveShadow, 'object.receiveShadow');
+    const geometry = object.geometry;
+    const geometryExtraction = meshGeometryExtraction(geometry, cache);
+    if (!geometryExtraction)
+        return;
+    const { position, positions, vertexColors, index, sourceIndex, groups, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, } = geometryExtraction;
+    const pointUvChannels = geometryExtraction.uvChannels;
+    const transform = (0, math_1.matrixElements)(object.matrixWorld, 'points.matrixWorld');
+    const axes = cameraBillboardAxes(camera);
+    for (const group of groups) {
+        const material = materialForObjectGroup(object, group.materialIndex, overrideMaterial);
+        if (material?.visible === false)
+            continue;
+        invokeObjectRenderCallback(object.onBeforeRender, 'onBeforeRender', callbackContext, object, camera, geometry, material, group);
+        const pointUvStreams = material?.map || material?.alphaMap
+            ? textureUvStreamsForMapAlphaMaterial(pointUvChannels, {
+                map: material.map,
+                alphaMap: material.alphaMap,
+            })
+            : null;
+        const baseColor = (0, materials_1.materialColor)(material, materialContext);
+        const useVertexColors = vertexColors && material?.vertexColors !== false;
+        const pointSize = positiveMaterialOrObjectNumber(material?.size, 'material.size', 1);
+        const sizeAttenuation = optionalSceneBoolean(material?.sizeAttenuation, 'material.sizeAttenuation');
+        const billboard = pointBillboardExpansion(object, group, position, positions, index ?? sourceIndex, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, transform, axes, camera, viewportHeight, pointSize, sizeAttenuation, pointUvStreams, vertexColors, useVertexColors ? baseColor : undefined, cache);
+        if (billboard.positions.length === 0)
+            continue;
+        const outputPositions = billboard.positions;
+        const outputUvs = billboard.uvs;
+        const outputUvs2 = billboard.uvs2;
+        const outputColors = billboard.colors;
+        const outputIndices = billboard.indices;
+        const outputPointRefs = billboard.pointRefs;
+        const textureInfo = (0, materials_1.extractTextureData)(material, materialContext);
+        const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder, undefined, geometry, group);
+        const pbrProps = (0, materials_1.extractPbrProperties)(material, materialContext);
+        assertSupportedCustomFragmentInstancedAttributes(geometry, pbrProps);
+        pbrProps.alphaMapUsesUv2 = pointUvStreams?.alphaMapUsesUv2 ?? false;
+        const clipping = clippingState(clippingContext, material, localClippingEnabled);
+        const customShadowMaterial = customShadowMaterialForMode(object, shadowMaterialMode);
+        const usesCustomShadowMaterial = objectCastsShadow && customShadowMaterial != null;
+        const effectiveCustomShadowMaterial = usesCustomShadowMaterial
+            ? shadowMaterialWithSourceShadowState(customShadowMaterial, material)
+            : null;
+        const pointShadowUvStreams = effectiveCustomShadowMaterial && (effectiveCustomShadowMaterial.map ||
+            effectiveCustomShadowMaterial.alphaMap)
+            ? textureUvStreamsForMapAlphaMaterial(pointUvChannels, {
+                map: effectiveCustomShadowMaterial.map,
+                alphaMap: effectiveCustomShadowMaterial.alphaMap,
+            })
+            : null;
+        pushMesh(meshes, {
+            positions: outputPositions,
+            indices: outputIndices,
+            uvs: outputUvs,
+            uvs2: outputUvs2,
+            color: baseColor,
+            colors: outputColors,
+            texture: textureInfo?.data,
+            textureWidth: textureInfo?.width ?? undefined,
+            textureHeight: textureInfo?.height ?? undefined,
+            textureWrapS: textureInfo?.wrapS,
+            textureWrapT: textureInfo?.wrapT,
+            textureMagFilter: textureInfo?.magFilter,
+            textureMinFilter: textureInfo?.minFilter,
+            textureAnisotropy: textureInfo?.anisotropy,
+            textureTransform: textureInfo?.transform,
+            textureColorSpace: textureInfo?.colorSpace,
+            textureUsesUv2: pointUvStreams?.textureUsesUv2 ?? false,
+            transform: math_1.IDENTITY_4X4.slice(),
+            transparent: material?.transparent === true || (material?.opacity != null && material.opacity < 1),
+            topology: 'triangles',
+            castShadow: objectCastsShadow && !usesCustomShadowMaterial ? true : undefined,
+            receiveShadow: false,
+            clipShadows: clipShadowsForMaterial(material, clippingContext),
+            ...clipping,
+            ...sortInfo.keys,
+            ...pbrProps,
+            shadingModel: 'basic',
+        }, sortInfo.item);
+        if (usesCustomShadowMaterial && customShadowMaterial?.visible !== false) {
+            appendShadowOnlyBillboardMesh(object, camera, meshes, groupOrder, clippingContext, localClippingEnabled, customShadowMaterial, material, materialContext, outputPositions, outputIndices, pointShadowUvStreams?.uvs ? expandPointBillboardUvStream(pointShadowUvStreams.uvs, outputPointRefs) : outputUvs, pointShadowUvStreams?.uvs2 ? expandPointBillboardUvStream(pointShadowUvStreams.uvs2, outputPointRefs) : undefined, pointShadowUvStreams?.textureUsesUv2 ?? false, pointShadowUvStreams?.alphaMapUsesUv2 ?? false);
+        }
+        invokeObjectRenderCallback(object.onAfterRender, 'onAfterRender', callbackContext, object, camera, geometry, material, group);
+    }
+}
+function pointBillboardExpansion(object, group, position, positions, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, transform, axes, camera, viewportHeight, pointSize, sizeAttenuation, pointUvStreams, vertexColors, vertexColorBase, cache) {
+    const signature = pointBillboardSignature(group, position, positions, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, transform, axes, camera, viewportHeight, pointSize, sizeAttenuation, pointUvStreams, vertexColors, vertexColorBase);
+    const cacheKey = `${group.start}:${group.count}:${group.materialIndex ?? 0}`;
+    if (cache && signature.cacheable) {
+        const objectCache = cache.pointBillboards.get(object);
+        const cached = objectCache?.get(cacheKey);
+        if (cached && samePointBillboardSignature(cached.signature, signature)) {
+            return cached.expansion;
+        }
+    }
+    const expansion = readPointBillboardExpansion(group, position, positions, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, transform, axes, camera, viewportHeight, pointSize, sizeAttenuation, pointUvStreams, vertexColors, vertexColorBase);
+    if (cache && signature.cacheable) {
+        let objectCache = cache.pointBillboards.get(object);
+        if (!objectCache) {
+            objectCache = new Map();
+            cache.pointBillboards.set(object, objectCache);
+        }
+        objectCache.set(cacheKey, { signature, expansion });
+    }
+    return expansion;
+}
+function readPointBillboardExpansion(group, position, positions, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, transform, axes, camera, viewportHeight, pointSize, sizeAttenuation, pointUvStreams, vertexColors, vertexColorBase) {
+    const source = index ?? rangeIndices(position.count);
+    const points = source.slice(group.start, group.start + group.count);
+    const outputPositions = [];
+    const outputUvs = [];
+    const outputUvs2 = pointUvStreams?.uvs2 ? [] : undefined;
+    const outputColors = vertexColorBase ? [] : undefined;
+    const outputIndices = [];
+    const outputPointRefs = [];
+    const corners = [
+        [-0.5, -0.5, 0, 0],
+        [0.5, -0.5, 1, 0],
+        [0.5, 0.5, 1, 1],
+        [-0.5, 0.5, 0, 1],
+    ];
+    for (let instance = 0; instance < instancedGeometryCount; instance += 1) {
+        const offsetIndex = instancedPositionOffset
+            ? instancedAttributeIndex(instancedPositionOffset.attribute, instance, instancedPositionOffset.label)
+            : 0;
+        const offset = instancedPositionOffset
+            ? [
+                (0, attributes_1.attributeComponent)(instancedPositionOffset.attribute, offsetIndex, 0, instancedPositionOffset.label),
+                (0, attributes_1.attributeComponent)(instancedPositionOffset.attribute, offsetIndex, 1, instancedPositionOffset.label),
+                (0, attributes_1.attributeComponent)(instancedPositionOffset.attribute, offsetIndex, 2, instancedPositionOffset.label),
+            ]
+            : [0, 0, 0];
+        const scale = instanceScaleComponents(instancedPositionScale, instance);
+        for (let pointOffset = 0; pointOffset < points.length; pointOffset += 1) {
+            const pointIndex = points[pointOffset];
+            if (!Number.isInteger(pointIndex) || pointIndex < 0 || pointIndex >= position.count)
+                continue;
+            const center = transformPoint(transform, [
+                positions[pointIndex * 3] * scale[0] + offset[0],
+                positions[pointIndex * 3 + 1] * scale[1] + offset[1],
+                positions[pointIndex * 3 + 2] * scale[2] + offset[2],
+            ]);
+            const worldSize = pointWorldSize(pointSize, center, sizeAttenuation, camera, viewportHeight);
+            if (worldSize <= 0)
+                continue;
+            const vertexBase = outputPositions.length / 3;
+            outputPointRefs.push({ pointIndex, instance });
+            const pointColor = outputColors ? pointVertexColor(vertexColors, vertexColorBase, pointIndex, instance) : null;
+            for (const [x, y, u, v] of corners) {
+                outputPositions.push(center[0] + axes.right[0] * x * worldSize + axes.up[0] * y * worldSize, center[1] + axes.right[1] * x * worldSize + axes.up[1] * y * worldSize, center[2] + axes.right[2] * x * worldSize + axes.up[2] * y * worldSize);
+                if (pointUvStreams) {
+                    if (pointUvStreams.uvs) {
+                        appendUvForVertex(outputUvs, pointUvStreams.uvs, pointIndex, instance);
+                    }
+                    else {
+                        outputUvs.push(u, v);
+                    }
+                    if (outputUvs2 && pointUvStreams.uvs2) {
+                        appendUvForVertex(outputUvs2, pointUvStreams.uvs2, pointIndex, instance);
+                    }
+                }
+                else {
+                    outputUvs.push(u, v);
+                }
+                if (pointColor) {
+                    outputColors.push(pointColor[0], pointColor[1], pointColor[2], pointColor[3]);
+                }
+            }
+            outputIndices.push(vertexBase, vertexBase + 1, vertexBase + 2, vertexBase, vertexBase + 2, vertexBase + 3);
+        }
+    }
+    return {
+        positions: outputPositions,
+        indices: outputIndices,
+        uvs: outputUvs,
+        uvs2: outputUvs2,
+        colors: outputColors,
+        pointRefs: outputPointRefs,
+    };
+}
+function pointBillboardSignature(group, position, positions, index, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, transform, axes, camera, viewportHeight, pointSize, sizeAttenuation, pointUvStreams, vertexColors, vertexColorBase) {
+    const signature = {
+        cacheable: true,
+        positions,
+        positionCount: position.count,
+        index,
+        groupStart: group.start,
+        groupCount: group.count,
+        instancedGeometryCount,
+        instancedPositionOffset: attributeSignature(instancedPositionOffset?.attribute),
+        instancedPositionScale: attributeSignature(instancedPositionScale?.attribute),
+        transform: transform.slice(0, 16),
+        cameraRight: axes.right.slice(),
+        cameraUp: axes.up.slice(),
+        cameraProjection: matrixValues(camera?.projectionMatrix?.elements),
+        cameraView: matrixValues(camera?.matrixWorldInverse?.elements),
+        cameraIsPerspective: camera?.isPerspectiveCamera,
+        viewportHeight,
+        pointSize,
+        sizeAttenuation,
+        uvs: uvChannelSignature(pointUvStreams?.uvs),
+        uvs2: uvChannelSignature(pointUvStreams?.uvs2),
+        useVertexColors: !!vertexColorBase,
+        vertexColors: attributeSignature(vertexColorBase ? vertexColors : undefined),
+        baseColor: vertexColorBase ? vertexColorBase.slice() : undefined,
+    };
+    signature.cacheable = pointBillboardSignatureCacheable(signature);
+    return signature;
+}
+function pointBillboardSignatureCacheable(signature) {
+    return attributeSignatureCacheable(signature.instancedPositionOffset)
+        && attributeSignatureCacheable(signature.instancedPositionScale)
+        && attributeSignatureCacheable(signature.uvs.attribute)
+        && attributeSignatureCacheable(signature.uvs2.attribute)
+        && attributeSignatureCacheable(signature.vertexColors);
+}
+function uvChannelSignature(channel) {
+    if (!channel)
+        return { attribute: {} };
+    return {
+        attribute: attributeSignature(channel.attribute),
+        values: channel.values,
+        label: channel.label,
+    };
+}
+function matrixValues(matrix) {
+    if (!matrix || matrix.length < 16)
+        return null;
+    const out = new Array(16);
+    for (let i = 0; i < 16; i += 1)
+        out[i] = matrix[i];
+    return out;
+}
+function samePointBillboardSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.positions === b.positions
+        && a.positionCount === b.positionCount
+        && a.index === b.index
+        && a.groupStart === b.groupStart
+        && a.groupCount === b.groupCount
+        && a.instancedGeometryCount === b.instancedGeometryCount
+        && sameAttributeSignature(a.instancedPositionOffset, b.instancedPositionOffset)
+        && sameAttributeSignature(a.instancedPositionScale, b.instancedPositionScale)
+        && sameNumberArray(a.transform, b.transform)
+        && sameNumberArray(a.cameraRight, b.cameraRight)
+        && sameNumberArray(a.cameraUp, b.cameraUp)
+        && sameOptionalNumberArray(a.cameraProjection, b.cameraProjection)
+        && sameOptionalNumberArray(a.cameraView, b.cameraView)
+        && a.cameraIsPerspective === b.cameraIsPerspective
+        && a.viewportHeight === b.viewportHeight
+        && a.pointSize === b.pointSize
+        && a.sizeAttenuation === b.sizeAttenuation
+        && sameUvChannelSignature(a.uvs, b.uvs)
+        && sameUvChannelSignature(a.uvs2, b.uvs2)
+        && a.useVertexColors === b.useVertexColors
+        && sameAttributeSignature(a.vertexColors, b.vertexColors)
+        && sameOptionalNumberArray(a.baseColor, b.baseColor);
+}
+function sameUvChannelSignature(a, b) {
+    return sameAttributeSignature(a.attribute, b.attribute)
+        && a.values === b.values
+        && a.label === b.label;
+}
+function sameOptionalNumberArray(a, b) {
+    if (a == null || b == null)
+        return a == null && b == null;
+    return sameNumberArray(a, b);
+}
+function sameNumberArray(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i += 1) {
+        if (!Object.is(a[i], b[i]))
+            return false;
+    }
+    return true;
+}
+function expandPointBillboardUvStream(channel, pointRefs) {
+    const outputUvs = [];
+    for (const { pointIndex, instance } of pointRefs) {
+        for (let corner = 0; corner < 4; corner += 1) {
+            appendUvForVertex(outputUvs, channel, pointIndex, instance);
+        }
+    }
+    return outputUvs;
+}
+function appendShadowOnlyBillboardMesh(object, camera, meshes, groupOrder, clippingContext, localClippingEnabled, material, sourceMaterial, materialContext, positions, indices, uvs, uvs2 = undefined, textureUsesUv2 = false, alphaMapUsesUv2 = false) {
+    const shadowMaterial = shadowMaterialWithSourceShadowState(material, sourceMaterial);
+    const textureInfo = (0, materials_1.extractTextureData)(shadowMaterial, materialContext);
+    const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder);
+    const clipping = clippingState(clippingContext, shadowMaterial, localClippingEnabled);
+    const hiddenMainPass = shadowOnlyMainPassState();
+    const shadowProps = shadowPbrProperties(shadowMaterial, sourceMaterial, materialContext);
+    shadowProps.alphaMapUsesUv2 = alphaMapUsesUv2;
+    pushMesh(meshes, {
+        positions,
+        indices,
+        uvs,
+        uvs2,
+        color: (0, materials_1.materialColor)(shadowMaterial, materialContext),
+        texture: textureInfo?.data,
+        textureWidth: textureInfo?.width ?? undefined,
+        textureHeight: textureInfo?.height ?? undefined,
+        textureWrapS: textureInfo?.wrapS,
+        textureWrapT: textureInfo?.wrapT,
+        textureMagFilter: textureInfo?.magFilter,
+        textureMinFilter: textureInfo?.minFilter,
+        textureAnisotropy: textureInfo?.anisotropy,
+        textureTransform: textureInfo?.transform,
+        textureColorSpace: textureInfo?.colorSpace,
+        textureUsesUv2,
+        transform: math_1.IDENTITY_4X4.slice(),
+        topology: 'triangles',
+        castShadow: true,
+        receiveShadow: false,
+        clipShadows: clipShadowsForMaterial(shadowMaterial, clippingContext),
+        ...clipping,
+        ...sortInfo.keys,
+        ...shadowProps,
+        ...hiddenMainPass,
+    }, sortInfo.item);
+}
+function shadowMaterialWithSourceShadowState(material, sourceMaterial) {
+    if (!sourceMaterialHasShadowState(sourceMaterial))
+        return material;
+    const shadowMaterial = Object.create(material);
+    if (sourceMaterialHasShadowAlphaState(sourceMaterial)) {
+        shadowMaterial.map = sourceMaterial.map ?? null;
+        shadowMaterial.alphaMap = sourceMaterial.alphaMap ?? null;
+        shadowMaterial.alphaTest = sourceMaterial.alphaToCoverage === true ? 0.5 : sourceMaterial.alphaTest;
+        shadowMaterial.alphaToCoverage = sourceMaterial.alphaToCoverage;
+        if (sourceMaterial.alphaHash === true)
+            shadowMaterial.alphaHash = true;
+        if (sourceMaterial.alphaHash === true || sourceMaterial.alphaToCoverage === true) {
+            if (sourceMaterial.opacity != null) {
+                shadowMaterial.opacity = sourceMaterial.opacity;
+            }
         }
     }
+    if (sourceMaterialHasShadowDisplacementState(sourceMaterial)) {
+        shadowMaterial.displacementMap = sourceMaterial.displacementMap ?? null;
+        shadowMaterial.displacementScale = sourceMaterial.displacementScale;
+        shadowMaterial.displacementBias = sourceMaterial.displacementBias;
+    }
+    if (sourceMaterialHasShadowClippingState(sourceMaterial)) {
+        shadowMaterial.clipShadows = sourceMaterial.clipShadows;
+        shadowMaterial.clippingPlanes = sourceMaterial.clippingPlanes;
+        shadowMaterial.clipIntersection = sourceMaterial.clipIntersection;
+    }
+    if (sourceMaterialHasShadowWireframeState(sourceMaterial)) {
+        shadowMaterial.wireframe = sourceMaterial.wireframe;
+    }
+    return shadowMaterial;
+}
+function sourceMaterialHasShadowState(material) {
+    return sourceMaterialHasShadowAlphaState(material) ||
+        sourceMaterialHasShadowDisplacementState(material) ||
+        sourceMaterialHasShadowClippingState(material) ||
+        sourceMaterialHasShadowWireframeState(material);
+}
+function sourceMaterialHasShadowAlphaState(material) {
+    if (!material)
+        return false;
+    const hasAlphaTexture = !!(material.map || material.alphaMap);
+    const hasOpacityAlpha = typeof material.opacity === 'number' && Number.isFinite(material.opacity) && material.opacity < 1;
+    if (material.alphaHash === true && (hasAlphaTexture || hasOpacityAlpha))
+        return true;
+    if (material.alphaToCoverage === true && (hasAlphaTexture || hasOpacityAlpha))
+        return true;
+    if (!hasAlphaTexture)
+        return false;
+    if (material.alphaToCoverage === true)
+        return true;
+    return typeof material.alphaTest === 'number' && Number.isFinite(material.alphaTest) && material.alphaTest > 0;
+}
+function sourceMaterialHasShadowDisplacementState(material) {
+    return !!material?.displacementMap;
+}
+function sourceMaterialHasShadowClippingState(material) {
+    return !!material && ('clipShadows' in material ||
+        material.clippingPlanes != null ||
+        'clipIntersection' in material);
+}
+function sourceMaterialHasShadowWireframeState(material) {
+    return material?.wireframe === true;
+}
+function shadowPbrProperties(material, sourceMaterial, materialContext) {
+    const props = (0, materials_1.extractPbrProperties)(material, materialContext);
+    const sourceShadowSide = (0, materials_1.materialShadowSide)(sourceMaterial);
+    if (sourceShadowSide) {
+        props.shadowSide = sourceShadowSide;
+    }
+    return props;
+}
+function validateObjectShadowFlags(object) {
+    optionalObjectBoolean(object.castShadow, 'object.castShadow');
+    optionalObjectBoolean(object.receiveShadow, 'object.receiveShadow');
+}
+function optionalObjectBoolean(value, label) {
+    return optionalSceneBoolean(value, label);
+}
+function optionalSceneBoolean(value, label) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'boolean')
+        return value;
+    throw new TypeError(`${label} must be a boolean.`);
+}
+function pointVertexColor(attribute, materialColor, pointIndex, instanceIndex, label = 'geometry.attributes.color') {
+    const sourceIndex = isInstancedAttribute(attribute)
+        ? instancedAttributeIndex(attribute, instanceIndex, label)
+        : pointIndex;
+    return [
+        (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 0, label) * materialColor[0]),
+        (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 1, label) * materialColor[1]),
+        (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 2, label) * materialColor[2]),
+        (0, math_1.clamp01)((attribute.itemSize && attribute.itemSize >= 4 ? (0, attributes_1.attributeComponent)(attribute, sourceIndex, 3, label) : 1) * materialColor[3]),
+    ];
 }
 function effectiveGroups(geometry, index, vertexCount) {
     const range = geometry.drawRange ?? {};
+    if (range != null && (typeof range !== 'object' || Array.isArray(range))) {
+        throw new TypeError('geometry.drawRange must be an object.');
+    }
     const maxCount = index ? index.length : vertexCount;
-    const drawStart = (0, math_1.clampInteger)(range.start ?? 0, 0, maxCount);
-    const requestedCount = range.count == null || range.count === Infinity ? maxCount : range.count;
+    const drawStart = (0, math_1.clampInteger)(geometryDrawRangeStart(range.start), 0, maxCount);
+    const requestedCount = geometryDrawRangeCount(range.count, maxCount);
     const drawEnd = (0, math_1.clampInteger)(drawStart + requestedCount, drawStart, maxCount);
+    if (geometry.groups != null && !Array.isArray(geometry.groups)) {
+        throw new TypeError('geometry.groups must be an array.');
+    }
     const sourceGroups = Array.isArray(geometry.groups) && geometry.groups.length
         ? geometry.groups
-        : [{ start: drawStart, count: drawEnd - drawStart, materialIndex: 0 }];
+        : null;
+    if (!sourceGroups) {
+        return [{ start: drawStart, count: drawEnd - drawStart, materialIndex: 0 }];
+    }
     const groups = [];
-    for (const group of sourceGroups) {
-        const start = Math.max(drawStart, (0, math_1.clampInteger)(group.start ?? 0, 0, maxCount));
-        const end = Math.min(drawEnd, (0, math_1.clampInteger)((group.start ?? 0) + (group.count ?? 0), 0, maxCount));
+    for (let groupIndex = 0; groupIndex < sourceGroups.length; groupIndex += 1) {
+        const group = sourceGroups[groupIndex];
+        if (!group || typeof group !== 'object' || Array.isArray(group)) {
+            throw new TypeError(`geometry.groups[${groupIndex}] must be an object.`);
+        }
+        const groupStart = geometryGroupNonNegativeInteger(group.start, `geometry.groups[${groupIndex}].start`);
+        const groupCount = geometryGroupNonNegativeInteger(group.count, `geometry.groups[${groupIndex}].count`);
+        const groupMaterialIndex = group.materialIndex == null
+            ? 0
+            : geometryGroupNonNegativeInteger(group.materialIndex, `geometry.groups[${groupIndex}].materialIndex`);
+        const start = Math.max(drawStart, (0, math_1.clampInteger)(groupStart, 0, maxCount));
+        const end = Math.min(drawEnd, (0, math_1.clampInteger)(groupStart + groupCount, 0, maxCount));
         if (end > start) {
             groups.push({
                 start,
                 count: end - start,
-                materialIndex: group.materialIndex ?? 0,
+                materialIndex: groupMaterialIndex,
             });
         }
     }
     return groups;
 }
+function geometryDrawRangeStart(value) {
+    if (value == null)
+        return 0;
+    return geometryGroupNonNegativeInteger(value, 'geometry.drawRange.start');
+}
+function geometryDrawRangeCount(value, fallback) {
+    if (value == null || value === Infinity)
+        return fallback;
+    return geometryGroupNonNegativeInteger(value, 'geometry.drawRange.count');
+}
+function geometryGroupNonNegativeInteger(value, label) {
+    if (typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    throw new TypeError(`${label} must be a non-negative integer.`);
+}
 /**
  * Emit a `NativeSceneMesh` with `topology: 'lines'` or `'points'` for
  * `THREE.Line` / `THREE.LineSegments` / `THREE.LineLoop` / `THREE.Points`.
  * Lines are always expanded to a LineList (pairs of vertex indices) so the
  * Rust side only has to deal with one line topology.
  */
-function appendLineOrPoints(object, meshes, topology) {
+function appendLineOrPoints(object, camera, meshes, topology, groupOrder, viewportHeight, clippingContext, localClippingEnabled, materialContext, overrideMaterial, cache, callbackContext) {
+    validateObjectShadowFlags(object);
+    const objectCastsShadow = topology === 'lines' && optionalObjectBoolean(object.castShadow, 'object.castShadow') === true;
     const geometry = object.geometry;
-    const position = (0, attributes_1.getAttribute)(geometry, 'position');
-    if (!position)
-        return;
-    const material = (0, materials_1.materialForGroup)(object.material, 0);
-    if (material?.visible === false)
+    const geometryExtraction = meshGeometryExtraction(geometry, cache);
+    if (!geometryExtraction)
         return;
-    const positions = (0, attributes_1.readVec3Attribute)(position);
-    const vertexColors = (0, attributes_1.getAttribute)(geometry, 'color');
-    const indexAttr = geometry.index ? (0, attributes_1.readIndexAttribute)(geometry.index) : null;
+    const { position, positions, uvChannels, uvs, vertexColors, index, sourceIndex, groups, instancedGeometryCount, instancedPositionOffset, instancedPositionScale, } = geometryExtraction;
     const vertexCount = position.count;
-    const range = geometry.drawRange ?? {};
-    const sourceCount = indexAttr ? indexAttr.length : vertexCount;
-    const drawStart = (0, math_1.clampInteger)(range.start ?? 0, 0, sourceCount);
-    const requestedCount = range.count == null || range.count === Infinity ? sourceCount : range.count;
-    const drawEnd = (0, math_1.clampInteger)(drawStart + requestedCount, drawStart, sourceCount);
-    let indices = null;
-    if (topology === 'lines') {
-        const source = indexAttr ?? rangeIndices(vertexCount);
-        indices = expandLineIndices(source, drawStart, drawEnd, object);
-        if (indices.length < 2)
-            return;
-    }
-    else if (indexAttr) {
-        indices = indexAttr.slice(drawStart, drawEnd);
-        if (indices.length === 0)
-            return;
-    }
-    const color = (0, materials_1.materialColor)(material);
-    const useVertexColors = vertexColors && material?.vertexColors !== false;
-    const colors = useVertexColors ? (0, attributes_1.readColorAttribute)(vertexColors, color) : undefined;
+    const indexAttr = index;
+    for (const group of groups) {
+        const material = materialForObjectGroup(object, group.materialIndex, overrideMaterial);
+        if (material?.visible === false)
+            continue;
+        invokeObjectRenderCallback(object.onBeforeRender, 'onBeforeRender', callbackContext, object, camera, geometry, material, group);
+        const uvStreams = topology === 'lines'
+            ? textureUvStreamsForMapAlphaMaterial(uvChannels, material)
+            : { uvs: uvChannels[0], uvs2: secondaryUvsForMaterial(uvChannels, material) };
+        let indices = null;
+        let outputPositions = positions;
+        let outputUvs = topology === 'lines' ? uvStreams.uvs?.values : undefined;
+        let outputSecondaryUvs = topology === 'lines' ? uvStreams.uvs2?.values : undefined;
+        let outputColors;
+        let thickCenter;
+        const color = (0, materials_1.materialColor)(material, materialContext);
+        const useVertexColors = vertexColors && material?.vertexColors !== false;
+        const pbrProps = (0, materials_1.extractPbrProperties)(material, materialContext);
+        assertSupportedCustomFragmentInstancedAttributes(geometry, pbrProps);
+        if (topology === 'lines') {
+            pbrProps.alphaMapUsesUv2 = uvStreams.alphaMapUsesUv2;
+        }
+        const textureInfo = (0, materials_1.extractTextureData)(material, materialContext);
+        const drawStart = group.start;
+        const drawEnd = group.start + group.count;
+        if (topology === 'lines') {
+            validateLineMaterialCompatibilityHints(material);
+        }
+        const lineWidth = positiveMaterialOrObjectNumber(material?.linewidth, 'material.linewidth', 1);
+        const thickLine = topology === 'lines' && lineWidth > 1;
+        if (topology === 'lines') {
+            const source = sourceIndex;
+            if (material?.isLineDashedMaterial === true) {
+                const lineDistance = (0, attributes_1.getAttribute)(geometry, 'lineDistance');
+                const dashed = instancedGeometryCount > 1 || instancedPositionOffset || instancedPositionScale
+                    ? dashedLineAttributesForInstancesWithCache(cache, geometry, position, positions, uvStreams.uvs, uvStreams.uvs2, useVertexColors ? vertexColors : undefined, color, source, drawStart, drawEnd, object, lineDistance, material, instancedGeometryCount, instancedPositionOffset, instancedPositionScale)
+                    : dashedLineAttributesWithCache(cache, geometry, position, positions, uvStreams.uvs, uvStreams.uvs2, useVertexColors ? (0, attributes_1.readColorAttribute)(vertexColors, color, 'geometry.attributes.color') : undefined, source, drawStart, drawEnd, object, lineDistance, material);
+                if (dashed.positions.length < 6)
+                    continue;
+                outputPositions = dashed.positions;
+                outputUvs = dashed.uvs;
+                outputSecondaryUvs = dashed.uvs2;
+                outputColors = dashed.colors;
+                indices = rangeIndices(dashed.positions.length / 3);
+                if (thickLine) {
+                    const transform = (0, math_1.matrixElements)(object.matrixWorld, 'object.matrixWorld');
+                    const thick = thickLineAttributes(outputPositions, outputUvs, outputSecondaryUvs, outputColors, indices, transform, camera, viewportHeight, lineWidth);
+                    if (thick.positions.length < 12)
+                        continue;
+                    outputPositions = thick.positions;
+                    outputUvs = thick.uvs;
+                    outputSecondaryUvs = thick.uvs2;
+                    outputColors = thick.colors;
+                    indices = thick.indices;
+                    thickCenter = thick.center;
+                }
+                else {
+                    indices = null;
+                }
+            }
+            else {
+                indices = expandLineIndices(source, drawStart, drawEnd, object);
+                if (indices.length < 2)
+                    continue;
+                if (instancedGeometryCount > 1 || instancedPositionOffset || instancedPositionScale) {
+                    outputPositions = expandVec3ValuesForInstancesWithCache(cache, geometry, position, positions, 0, vertexCount, instancedGeometryCount, instancedPositionOffset, instancedPositionScale);
+                    outputUvs = uvStreams.uvs ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs, 0, vertexCount, instancedGeometryCount) : undefined;
+                    outputSecondaryUvs = uvStreams.uvs2 ? expandUvChannelForInstancesWithCache(cache, geometry, uvStreams.uvs2, 0, vertexCount, instancedGeometryCount) : undefined;
+                    indices = expandIndicesForInstances(indices, vertexCount, instancedGeometryCount);
+                }
+                if (thickLine) {
+                    const transform = (0, math_1.matrixElements)(object.matrixWorld, 'object.matrixWorld');
+                    const thick = thickLineAttributes(outputPositions, outputUvs, outputSecondaryUvs, useVertexColors ? outputColors ?? expandColorAttributeForInstancesWithCache(cache, geometry, vertexColors, color, 0, vertexCount, instancedGeometryCount) : undefined, indices, transform, camera, viewportHeight, lineWidth);
+                    if (thick.positions.length < 12)
+                        continue;
+                    outputPositions = thick.positions;
+                    outputUvs = thick.uvs;
+                    outputSecondaryUvs = thick.uvs2;
+                    outputColors = thick.colors;
+                    indices = thick.indices;
+                    thickCenter = thick.center;
+                }
+            }
+        }
+        else if (indexAttr) {
+            indices = indexAttr.slice(drawStart, drawEnd);
+            if (indices.length === 0)
+                continue;
+        }
+        if (useVertexColors && material?.isLineDashedMaterial !== true && !thickLine) {
+            outputColors = expandColorAttributeForInstancesWithCache(cache, geometry, vertexColors, color, 0, vertexCount, instancedGeometryCount);
+        }
+        const sortInfo = sortInfoForObject(object, material, camera, meshes.length, groupOrder, undefined, geometry, group);
+        if (thickCenter && camera) {
+            sortInfo.keys.sortZ = projectedWorldPointZ(thickCenter, camera);
+            sortInfo.item.z = sortInfo.keys.sortZ;
+        }
+        const clipping = clippingState(clippingContext, material, localClippingEnabled);
+        pushMesh(meshes, {
+            positions: outputPositions,
+            indices: indices ?? undefined,
+            uvs: topology === 'lines' ? outputUvs : undefined,
+            uvs2: topology === 'lines' ? outputSecondaryUvs : undefined,
+            color,
+            colors: outputColors,
+            texture: textureInfo?.data,
+            textureWidth: textureInfo?.width ?? undefined,
+            textureHeight: textureInfo?.height ?? undefined,
+            textureWrapS: textureInfo?.wrapS,
+            textureWrapT: textureInfo?.wrapT,
+            textureMagFilter: textureInfo?.magFilter,
+            textureMinFilter: textureInfo?.minFilter,
+            textureAnisotropy: textureInfo?.anisotropy,
+            textureTransform: textureInfo?.transform,
+            textureColorSpace: textureInfo?.colorSpace,
+            textureUsesUv2: topology === 'lines' ? uvStreams.textureUsesUv2 : textureInfo?.usesUv2,
+            transform: thickLine ? math_1.IDENTITY_4X4.slice() : (0, math_1.matrixElements)(object.matrixWorld, 'object.matrixWorld'),
+            transparent: material?.transparent === true || (material?.opacity != null && material.opacity < 1),
+            alphaTest: material && Number.isFinite(material.alphaTest) && material.alphaTest > 0 ? material.alphaTest : undefined,
+            clipShadows: clipShadowsForMaterial(material, clippingContext),
+            ...pbrProps,
+            ...(thickLine ? { side: 'double' } : {}),
+            shadingModel: 'basic',
+            topology: thickLine ? 'triangles' : topology,
+            castShadow: objectCastsShadow ? true : undefined,
+            ...clipping,
+            ...sortInfo.keys,
+        }, sortInfo.item);
+        invokeObjectRenderCallback(object.onAfterRender, 'onAfterRender', callbackContext, object, camera, geometry, material, group);
+    }
+}
+function thickLineAttributes(positions, uvs, uvs2, colors, lineIndices, transform, camera, viewportHeight, lineWidth) {
+    const axes = cameraBillboardAxes(camera);
+    const outputPositions = [];
+    const outputUvs = uvs ? [] : undefined;
+    const outputUvs2 = uvs2 ? [] : undefined;
+    const outputColors = colors ? [] : undefined;
+    const outputIndices = [];
+    for (let i = 0; i + 1 < lineIndices.length; i += 2) {
+        const aIndex = lineIndices[i];
+        const bIndex = lineIndices[i + 1];
+        if (!validPositionIndex(positions, aIndex) || !validPositionIndex(positions, bIndex))
+            continue;
+        const a = transformPoint(transform, [
+            positions[aIndex * 3],
+            positions[aIndex * 3 + 1],
+            positions[aIndex * 3 + 2],
+        ]);
+        const b = transformPoint(transform, [
+            positions[bIndex * 3],
+            positions[bIndex * 3 + 1],
+            positions[bIndex * 3 + 2],
+        ]);
+        const dx = b[0] - a[0];
+        const dy = b[1] - a[1];
+        const dz = b[2] - a[2];
+        if (Math.hypot(dx, dy, dz) <= 1e-8)
+            continue;
+        const screenDx = dx * axes.right[0] + dy * axes.right[1] + dz * axes.right[2];
+        const screenDy = dx * axes.up[0] + dy * axes.up[1] + dz * axes.up[2];
+        const side = normalizeVec3([
+            -screenDy * axes.right[0] + screenDx * axes.up[0],
+            -screenDy * axes.right[1] + screenDx * axes.up[1],
+            -screenDy * axes.right[2] + screenDx * axes.up[2],
+        ], axes.up);
+        const midpoint = [
+            (a[0] + b[0]) * 0.5,
+            (a[1] + b[1]) * 0.5,
+            (a[2] + b[2]) * 0.5,
+        ];
+        const halfWidth = linePixelWorldSize(lineWidth, midpoint, camera, viewportHeight) * 0.5;
+        if (halfWidth <= 0)
+            continue;
+        const vertexBase = outputPositions.length / 3;
+        pushThickLineVertex(outputPositions, a, side, -halfWidth);
+        pushThickLineVertex(outputPositions, a, side, halfWidth);
+        pushThickLineVertex(outputPositions, b, side, halfWidth);
+        pushThickLineVertex(outputPositions, b, side, -halfWidth);
+        outputIndices.push(vertexBase, vertexBase + 1, vertexBase + 2, vertexBase, vertexBase + 2, vertexBase + 3);
+        pushRepeatedVec2(outputUvs, uvs, aIndex);
+        pushRepeatedVec2(outputUvs, uvs, aIndex);
+        pushRepeatedVec2(outputUvs, uvs, bIndex);
+        pushRepeatedVec2(outputUvs, uvs, bIndex);
+        pushRepeatedVec2(outputUvs2, uvs2, aIndex);
+        pushRepeatedVec2(outputUvs2, uvs2, aIndex);
+        pushRepeatedVec2(outputUvs2, uvs2, bIndex);
+        pushRepeatedVec2(outputUvs2, uvs2, bIndex);
+        pushRepeatedColor(outputColors, colors, aIndex);
+        pushRepeatedColor(outputColors, colors, aIndex);
+        pushRepeatedColor(outputColors, colors, bIndex);
+        pushRepeatedColor(outputColors, colors, bIndex);
+    }
+    return {
+        center: thickLineCenter(outputPositions),
+        colors: outputColors,
+        indices: outputIndices,
+        positions: outputPositions,
+        uvs: outputUvs,
+        uvs2: outputUvs2,
+    };
+}
+function validPositionIndex(positions, index) {
+    return Number.isInteger(index) && index >= 0 && index * 3 + 2 < positions.length;
+}
+function pushThickLineVertex(positions, point, side, offset) {
+    positions.push(point[0] + side[0] * offset, point[1] + side[1] * offset, point[2] + side[2] * offset);
+}
+function pushRepeatedVec2(target, source, index) {
+    if (!target || !source || index * 2 + 1 >= source.length)
+        return;
+    target.push(source[index * 2], source[index * 2 + 1]);
+}
+function pushRepeatedColor(target, source, index) {
+    if (!target || !source || index * 4 + 3 >= source.length)
+        return;
+    target.push(source[index * 4], source[index * 4 + 1], source[index * 4 + 2], source[index * 4 + 3]);
+}
+function linePixelWorldSize(lineWidth, worldPosition, camera, viewportHeight) {
+    const projectionY = Math.abs(finiteOrDefault(camera?.projectionMatrix?.elements?.[5], 1));
+    if (projectionY <= 0)
+        return 0;
+    if (camera?.isPerspectiveCamera === true) {
+        const viewZ = viewSpaceZ(worldPosition, camera);
+        const depth = Number.isFinite(viewZ) ? Math.max(0.0001, Math.abs(viewZ)) : 1;
+        return lineWidth * 2 * depth / Math.max(1, viewportHeight) / projectionY;
+    }
+    return lineWidth * 2 / Math.max(1, viewportHeight) / projectionY;
+}
+function thickLineCenter(positions) {
+    if (positions.length < 3)
+        return [0, 0, 0];
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    let count = 0;
+    for (let i = 0; i + 2 < positions.length; i += 3) {
+        x += positions[i];
+        y += positions[i + 1];
+        z += positions[i + 2];
+        count += 1;
+    }
+    return count > 0 ? [x / count, y / count, z / count] : [0, 0, 0];
+}
+function clippingState(clippingContext, material, localClippingEnabled) {
+    const inheritedUnionPlanes = clippingContext.unionPlanes.slice(0, clipping_1.MAX_CLIPPING_PLANES);
+    const inheritedIntersectionPlanes = clippingContext.intersectionPlanes.slice(0, Math.max(0, clipping_1.MAX_CLIPPING_PLANES - inheritedUnionPlanes.length));
+    const localBudget = Math.max(0, clipping_1.MAX_CLIPPING_PLANES - inheritedUnionPlanes.length - inheritedIntersectionPlanes.length);
+    const localPlanes = localClippingEnabled
+        ? (0, clipping_1.extractClippingPlanes)(material?.clippingPlanes, 'material.clippingPlanes', localBudget)
+        : [];
+    const clipIntersection = optionalObjectBoolean(material?.clipIntersection, 'material.clipIntersection') === true;
+    const localUnionPlanes = clipIntersection ? [] : localPlanes;
+    const localIntersectionPlanes = clipIntersection ? localPlanes : [];
+    const unionPlanes = [...inheritedUnionPlanes, ...localUnionPlanes];
+    const intersectionPlanes = [...inheritedIntersectionPlanes, ...localIntersectionPlanes];
+    const planes = [...unionPlanes, ...intersectionPlanes];
+    if (planes.length === 0)
+        return {};
+    return {
+        clippingPlanes: (0, clipping_1.flattenClippingPlanes)(planes),
+        clippingUnionCount: unionPlanes.length,
+    };
+}
+function clippingContextForObject(parent, object) {
+    if (object.isClippingGroup !== true)
+        return parent;
+    if (optionalObjectBoolean(object.enabled, 'ClippingGroup.enabled') === false)
+        return parent;
+    const clipIntersection = optionalObjectBoolean(object.clipIntersection, 'ClippingGroup.clipIntersection') === true;
+    const clipShadows = parent.clipShadows || optionalObjectBoolean(object.clipShadows, 'ClippingGroup.clipShadows') === true;
+    const currentCount = parent.unionPlanes.length + parent.intersectionPlanes.length;
+    const remainingBudget = Math.max(0, clipping_1.MAX_CLIPPING_PLANES - currentCount);
+    const planes = (0, clipping_1.extractClippingPlanes)(object.clippingPlanes, 'ClippingGroup.clippingPlanes', remainingBudget);
+    if (planes.length === 0)
+        return parent;
+    return clipIntersection
+        ? {
+            unionPlanes: parent.unionPlanes,
+            intersectionPlanes: [...parent.intersectionPlanes, ...planes],
+            clipShadows,
+        }
+        : {
+            unionPlanes: [...parent.unionPlanes, ...planes],
+            intersectionPlanes: parent.intersectionPlanes,
+            clipShadows,
+        };
+}
+function clipShadowsForMaterial(material, clippingContext) {
+    return optionalObjectBoolean(material?.clipShadows, 'material.clipShadows') === true || clippingContext.clipShadows ? true : undefined;
+}
+function pushMesh(meshes, mesh, sortItem, transparentDoubleSidePass = false) {
+    const groupOrder = mesh.groupOrder ?? 0;
+    const renderOrder = mesh.renderOrder ?? 0;
     meshes.push({
-        positions,
-        indices: indices ?? undefined,
-        color,
-        colors,
-        transform: (0, math_1.matrixElements)(object.matrixWorld, 'object.matrixWorld'),
-        transparent: material?.transparent === true || (material?.opacity != null && material.opacity < 1),
-        alphaTest: material && Number.isFinite(material.alphaTest) && material.alphaTest > 0 ? material.alphaTest : undefined,
-        shadingModel: 'basic',
-        topology,
+        mesh: {
+            ...mesh,
+            groupOrder: nativeRenderOrderKey(groupOrder),
+            renderOrder: nativeRenderOrderKey(renderOrder),
+        },
+        sortItem,
+        groupOrder,
+        renderOrder,
+        sortZ: mesh.sortZ ?? 0,
+        materialSortKey: mesh.materialSortKey ?? 0,
+        materialVariant: mesh.materialVariant ?? 0,
+        sortIndex: mesh.sortIndex ?? meshes.length,
+        transparentDoubleSidePass,
+    });
+}
+function needsTransparentDoubleSidePass(material, props, wireframe) {
+    return !wireframe
+        && material?.transparent === true
+        && material.forceSinglePass === false
+        && props.side === 'double';
+}
+function nativeMeshesFromSortedFlattened(meshes) {
+    const nativeMeshes = [];
+    for (const { mesh, transparentDoubleSidePass } of meshes) {
+        if (transparentDoubleSidePass) {
+            nativeMeshes.push({ ...mesh, side: 'back' });
+            nativeMeshes.push({ ...mesh, side: 'front' });
+        }
+        else {
+            nativeMeshes.push(mesh);
+        }
+    }
+    return nativeMeshes;
+}
+function sortInfoForObject(object, material, camera, sortIndex, groupOrder, transform, geometry, group, sortItemObject, sortItemZOverride) {
+    const renderOrder = renderOrderNumber(object.renderOrder, 'object.renderOrder', 0);
+    const z = camera ? projectedObjectZ(object, camera, transform) : 0;
+    const itemZ = sortItemZOverride ?? z;
+    const id = unsignedSortKey(object.id, sortIndex);
+    const materialSortKey = finiteOrDefault(material?.id, 0);
+    const materialVariant = materialVariantForObject(object);
+    return {
+        keys: {
+            groupOrder,
+            renderOrder,
+            sortZ: z,
+            sortIndex: id,
+            materialSortKey,
+            materialVariant,
+        },
+        item: {
+            id,
+            object: sortItemObject ?? object,
+            geometry,
+            material,
+            group,
+            groupOrder,
+            renderOrder,
+            z: itemZ,
+            materialVariant,
+        },
+    };
+}
+function mergeSortKeys(keys, override) {
+    return override ? { ...keys, ...override } : keys;
+}
+function sortFlattenedMeshes(meshes, options) {
+    const sortObjects = options.sortObjects !== false;
+    const buckets = partitionFlattenedMeshes(meshes);
+    if (options.opaque === false)
+        buckets.opaque.length = 0;
+    if (options.transparent === false) {
+        buckets.transmissive.length = 0;
+        buckets.transparent.length = 0;
+    }
+    if (!sortObjects) {
+        normalizeSortKeys(buckets.opaque);
+        normalizeSortKeys(buckets.transmissive);
+        normalizeSortKeys(buckets.transparent);
+        return [...buckets.opaque, ...buckets.transmissive, ...buckets.transparent];
+    }
+    if (options.opaqueSort) {
+        buckets.opaque.sort(compareWithSort(options.opaqueSort));
+        normalizeSortKeys(buckets.opaque);
+    }
+    else {
+        buckets.opaque.sort(compareFlattenedMeshes);
+    }
+    if (options.transparentSort) {
+        const transparentSort = compareWithSort(options.transparentSort);
+        buckets.transmissive.sort(transparentSort);
+        buckets.transparent.sort(transparentSort);
+        normalizeSortKeys(buckets.transmissive);
+        normalizeSortKeys(buckets.transparent);
+    }
+    else {
+        buckets.transmissive.sort(compareTransparentFlattenedMeshes);
+        buckets.transparent.sort(compareTransparentFlattenedMeshes);
+    }
+    return [...buckets.opaque, ...buckets.transmissive, ...buckets.transparent];
+}
+function partitionFlattenedMeshes(meshes) {
+    const opaque = [];
+    const transmissive = [];
+    const transparent = [];
+    for (const mesh of meshes) {
+        if (finitePositive(mesh.mesh.transmission)) {
+            transmissive.push(mesh);
+        }
+        else if (meshDefaultsTransparent(mesh.mesh)) {
+            transparent.push(mesh);
+        }
+        else {
+            opaque.push(mesh);
+        }
+    }
+    return { opaque, transmissive, transparent };
+}
+function compareWithSort(sort) {
+    return (a, b) => {
+        const result = Number(sort(a.sortItem, b.sortItem));
+        return Number.isFinite(result) ? result : 0;
+    };
+}
+function normalizeSortKeys(meshes) {
+    meshes.forEach((entry, index) => {
+        entry.mesh.groupOrder = 0;
+        entry.mesh.renderOrder = 0;
+        entry.mesh.materialSortKey = 0;
+        entry.mesh.materialVariant = 0;
+        entry.mesh.sortZ = 0;
+        entry.mesh.sortIndex = index;
     });
 }
+function compareFlattenedMeshes(a, b) {
+    return a.groupOrder - b.groupOrder
+        || a.renderOrder - b.renderOrder
+        || a.materialSortKey - b.materialSortKey
+        || a.materialVariant - b.materialVariant
+        || a.sortZ - b.sortZ
+        || a.sortIndex - b.sortIndex;
+}
+function compareTransparentFlattenedMeshes(a, b) {
+    return a.groupOrder - b.groupOrder
+        || a.renderOrder - b.renderOrder
+        || b.sortZ - a.sortZ
+        || a.sortIndex - b.sortIndex;
+}
+function meshDefaultsTransparent(mesh) {
+    if (mesh.alphaHash === true)
+        return false;
+    if (mesh.transparent === true)
+        return true;
+    if (mesh.transparent === false)
+        return false;
+    return materialAlpha(mesh) < 0.999;
+}
+function materialAlpha(mesh) {
+    return mesh.color && mesh.color.length >= 4 ? finiteOrDefault(mesh.color[3], 1) : 1;
+}
+function finitePositive(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0.0001;
+}
+function materialVariantForObject(object) {
+    return (object.isInstancedMesh === true ? 2 : 0) + (object.isSkinnedMesh === true ? 1 : 0);
+}
+function projectedObjectZ(object, camera, transform) {
+    const world = transform ?? object.matrixWorld?.elements;
+    if (!world || world.length < 16)
+        return 0;
+    const view = camera.matrixWorldInverse?.elements;
+    const projection = camera.projectionMatrix?.elements;
+    if (!view || view.length < 16 || !projection || projection.length < 16)
+        return 0;
+    const center = objectSortCenter(object);
+    const x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
+    const y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
+    const z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
+    const vx = view[0] * x + view[4] * y + view[8] * z + view[12];
+    const vy = view[1] * x + view[5] * y + view[9] * z + view[13];
+    const vz = view[2] * x + view[6] * y + view[10] * z + view[14];
+    const vw = view[3] * x + view[7] * y + view[11] * z + view[15];
+    const clipZ = projection[2] * vx + projection[6] * vy + projection[10] * vz + projection[14] * vw;
+    const clipW = projection[3] * vx + projection[7] * vy + projection[11] * vz + projection[15] * vw;
+    return clipW === 0 ? clipZ : clipZ / clipW;
+}
+function projectedWorldPointZ(worldPoint, camera) {
+    const view = camera.matrixWorldInverse?.elements;
+    const projection = camera.projectionMatrix?.elements;
+    if (!view || view.length < 16 || !projection || projection.length < 16)
+        return 0;
+    const x = worldPoint[0];
+    const y = worldPoint[1];
+    const z = worldPoint[2];
+    const vx = view[0] * x + view[4] * y + view[8] * z + view[12];
+    const vy = view[1] * x + view[5] * y + view[9] * z + view[13];
+    const vz = view[2] * x + view[6] * y + view[10] * z + view[14];
+    const vw = view[3] * x + view[7] * y + view[11] * z + view[15];
+    const clipZ = projection[2] * vx + projection[6] * vy + projection[10] * vz + projection[14] * vw;
+    const clipW = projection[3] * vx + projection[7] * vy + projection[11] * vz + projection[15] * vw;
+    return clipW === 0 ? clipZ : clipZ / clipW;
+}
+function objectSortCenter(object) {
+    if (object.boundingSphere !== undefined) {
+        if (object.boundingSphere == null && typeof object.computeBoundingSphere === 'function') {
+            try {
+                object.computeBoundingSphere();
+            }
+            catch {
+                return [0, 0, 0];
+            }
+        }
+        if (object.boundingSphere == null)
+            return [0, 0, 0];
+        if (!object.boundingSphere || typeof object.boundingSphere !== 'object') {
+            throw new TypeError('object.boundingSphere must be a THREE.Sphere-like object.');
+        }
+        return requiredVec3Like(object.boundingSphere.center, 'object.boundingSphere.center');
+    }
+    const geometry = object.geometry;
+    if (!geometry)
+        return [0, 0, 0];
+    if (geometry.boundingSphere == null && typeof geometry.computeBoundingSphere === 'function') {
+        try {
+            geometry.computeBoundingSphere();
+        }
+        catch {
+            return [0, 0, 0];
+        }
+    }
+    const sphere = geometry.boundingSphere;
+    if (sphere == null)
+        return [0, 0, 0];
+    if (!sphere || typeof sphere !== 'object') {
+        throw new TypeError('geometry.boundingSphere must be a THREE.Sphere-like object.');
+    }
+    return requiredVec3Like(sphere.center, 'geometry.boundingSphere.center');
+}
+function renderableObjectOutsideFrustum(object, camera, viewportHeight = 512, overrideMaterial) {
+    if (!camera)
+        return false;
+    const frustumCulled = optionalObjectBoolean(object.frustumCulled, 'object.frustumCulled');
+    if (frustumCulled === false)
+        return false;
+    const sphere = objectBoundingSphere(object);
+    if (!sphere)
+        return false;
+    const transform = (0, math_1.matrixElements)(object.matrixWorld, renderableMatrixWorldLabel(object));
+    const extraRadius = object.isPoints === true
+        ? pointBillboardCullRadius(object, camera, transform, sphere, viewportHeight, overrideMaterial)
+        : 0;
+    return transformedSphereOutsideFrustum(camera, transform, sphere, extraRadius);
+}
+function validateInstancedMeshMatrices(object) {
+    const instanceMatrix = object.instanceMatrix;
+    if (!instanceMatrix || instanceMatrix.count == null)
+        return;
+    const instanceMatrixCount = (0, attributes_1.attributeCount)(instanceMatrix, 'InstancedMesh.instanceMatrix');
+    const count = (0, math_1.clampInteger)(integerCountOrDefault(object.count, 'InstancedMesh.count', instanceMatrixCount), 0, instanceMatrixCount);
+    for (let i = 0; i < count; i += 1) {
+        readMat4Attribute(instanceMatrix, i);
+    }
+}
+function renderableMatrixWorldLabel(object) {
+    if (object.isBatchedMesh === true)
+        return 'batchedMesh.matrixWorld';
+    if (object.isMesh === true)
+        return 'mesh.matrixWorld';
+    if (object.isPoints === true)
+        return 'points.matrixWorld';
+    return 'object.matrixWorld';
+}
+function objectBoundingSphere(object) {
+    if (object.isBatchedMesh === true) {
+        if (object.boundingSphere != null)
+            return sphereLike(object.boundingSphere, 'object.boundingSphere');
+        return batchedMeshBoundingSphere(object);
+    }
+    if (object.boundingSphere !== undefined) {
+        const hadBoundingSphere = object.boundingSphere != null;
+        if (object.boundingSphere == null && typeof object.computeBoundingSphere === 'function') {
+            if (object.isInstancedMesh === true) {
+                validateInstancedMeshMatrices(object);
+            }
+            try {
+                object.computeBoundingSphere();
+            }
+            catch {
+                return null;
+            }
+        }
+        if (object.boundingSphere == null)
+            return null;
+        try {
+            return object.isInstancedMesh === true
+                ? instancedMeshBoundingSphere(object)
+                : sphereLike(object.boundingSphere, 'object.boundingSphere');
+        }
+        catch (error) {
+            if (!hadBoundingSphere)
+                return null;
+            throw error;
+        }
+    }
+    const geometry = object.geometry;
+    if (!geometry)
+        return null;
+    const hadBoundingSphere = geometry.boundingSphere != null;
+    if (geometry.boundingSphere == null && typeof geometry.computeBoundingSphere === 'function') {
+        try {
+            geometry.computeBoundingSphere();
+        }
+        catch {
+            return null;
+        }
+    }
+    if (geometry.boundingSphere == null)
+        return null;
+    try {
+        return sphereLike(geometry.boundingSphere, 'geometry.boundingSphere');
+    }
+    catch (error) {
+        if (!hadBoundingSphere)
+            return null;
+        throw error;
+    }
+}
+function batchedMeshBoundingSphere(object) {
+    const geometry = object.geometry;
+    if (!geometry)
+        return null;
+    const instanceInfo = object._instanceInfo;
+    if (!Array.isArray(instanceInfo)) {
+        throw new Error('THREE.BatchedMesh instance table is not readable. Use a real THREE.BatchedMesh or expand the batch to ordinary Mesh or InstancedMesh objects before rendering.');
+    }
+    let bounds = null;
+    for (let instanceId = 0; instanceId < instanceInfo.length; instanceId += 1) {
+        const info = instanceInfo[instanceId];
+        if (!info || typeof info !== 'object') {
+            throw new TypeError(`THREE.BatchedMesh._instanceInfo[${instanceId}] must be an object.`);
+        }
+        if (!batchedOptionalBoolean(info.active, `THREE.BatchedMesh._instanceInfo[${instanceId}].active`, true))
+            continue;
+        batchedOptionalBoolean(info.visible, `THREE.BatchedMesh._instanceInfo[${instanceId}].visible`, true);
+        const geometryId = batchedNonNegativeInteger(info.geometryIndex, `THREE.BatchedMesh._instanceInfo[${instanceId}].geometryIndex`);
+        const range = batchedGeometryRange(object, geometry, geometryId);
+        if (range.count === 0)
+            continue;
+        const sphere = batchedGeometryBoundingSphere(object, geometry, geometryId, range);
+        if (!sphere)
+            continue;
+        bounds = unionSpheres(bounds, transformSphere(sphere, batchedInstanceMatrix(object, instanceId)));
+    }
+    return bounds;
+}
+function transformSphere(sphere, transform) {
+    const center = transformPoint(transform, sphere.center);
+    const scale = Math.max(columnLength3(transform, 0), columnLength3(transform, 4), columnLength3(transform, 8));
+    return { center, radius: sphere.radius * scale };
+}
+function unionSpheres(a, b) {
+    if (!a)
+        return { center: [...b.center], radius: b.radius };
+    const dx = b.center[0] - a.center[0];
+    const dy = b.center[1] - a.center[1];
+    const dz = b.center[2] - a.center[2];
+    const distance = Math.hypot(dx, dy, dz);
+    if (distance <= Math.abs(a.radius - b.radius)) {
+        return a.radius >= b.radius ? a : { center: [...b.center], radius: b.radius };
+    }
+    if (distance === 0)
+        return { center: [...a.center], radius: Math.max(a.radius, b.radius) };
+    const radius = (distance + a.radius + b.radius) * 0.5;
+    const centerShift = (radius - a.radius) / distance;
+    return {
+        center: [
+            a.center[0] + dx * centerShift,
+            a.center[1] + dy * centerShift,
+            a.center[2] + dz * centerShift,
+        ],
+        radius,
+    };
+}
+function instancedMeshBoundingSphere(object) {
+    try {
+        return sphereLike(object.boundingSphere, 'object.boundingSphere');
+    }
+    catch (error) {
+        validateInstancedMeshMatrices(object);
+        throw error;
+    }
+}
+function pointBillboardCullRadius(object, camera, transform, sphere, viewportHeight, overrideMaterial) {
+    const center = transformPoint(transform, sphere.center);
+    let radius = 0;
+    for (const material of pointCullMaterials(object, overrideMaterial)) {
+        const pointSize = safePositiveNumber(material?.size, 1);
+        const sizeAttenuation = typeof material?.sizeAttenuation === 'boolean'
+            ? material.sizeAttenuation
+            : undefined;
+        const worldSize = pointWorldSize(pointSize, center, sizeAttenuation, camera, viewportHeight);
+        radius = Math.max(radius, worldSize * Math.SQRT1_2);
+    }
+    return radius;
+}
+function pointCullMaterials(object, overrideMaterial) {
+    if (overrideMaterial !== undefined)
+        return [overrideMaterial];
+    if (Array.isArray(object.material)) {
+        return object.material.filter((material) => material != null && typeof material === 'object' && !Array.isArray(material));
+    }
+    return object.material != null && typeof object.material === 'object' && !Array.isArray(object.material)
+        ? [object.material]
+        : [undefined];
+}
+function spriteOutsideFrustum(object, camera, transform, center) {
+    if (!camera)
+        return false;
+    const frustumCulled = optionalObjectBoolean(object.frustumCulled, 'object.frustumCulled');
+    if (frustumCulled === false)
+        return false;
+    const offset = Math.hypot(center[0] - 0.5, center[1] - 0.5);
+    return transformedSphereOutsideFrustum(camera, transform, {
+        center: [0, 0, 0],
+        radius: 0.7071067811865476 + offset,
+    });
+}
+function transformedSphereOutsideFrustum(camera, transform, sphere, extraRadius = 0) {
+    const center = transformPoint(transform, sphere.center);
+    const scale = Math.max(columnLength3(transform, 0), columnLength3(transform, 4), columnLength3(transform, 8));
+    const radius = sphere.radius * scale + extraRadius;
+    if (!Number.isFinite(radius) || radius < 0)
+        return false;
+    return !cameraFrustumIntersectsSphere(camera, center, radius);
+}
+function vec3Like(value) {
+    if (!value)
+        return null;
+    const objectValue = value;
+    const x = typeof objectValue.x === 'number' ? objectValue.x : value[0];
+    const y = typeof objectValue.y === 'number' ? objectValue.y : value[1];
+    const z = typeof objectValue.z === 'number' ? objectValue.z : value[2];
+    return typeof x === 'number' && Number.isFinite(x)
+        && typeof y === 'number' && Number.isFinite(y)
+        && typeof z === 'number' && Number.isFinite(z)
+        ? [x, y, z]
+        : null;
+}
+function requiredVec3Like(value, label) {
+    const vector = vec3Like(value);
+    if (vector)
+        return vector;
+    throw new TypeError(`${label} must be a finite Vector3-like value.`);
+}
+function columnLength3(matrix, start) {
+    const x = matrix[start];
+    const y = matrix[start + 1];
+    const z = matrix[start + 2];
+    return Math.hypot(x, y, z);
+}
+function cameraBillboardAxes(camera) {
+    const matrix = camera?.matrixWorld?.elements;
+    if (!matrix || matrix.length < 16) {
+        return { right: [1, 0, 0], up: [0, 1, 0] };
+    }
+    return {
+        right: normalizeVec3([matrix[0], matrix[1], matrix[2]], [1, 0, 0]),
+        up: normalizeVec3([matrix[4], matrix[5], matrix[6]], [0, 1, 0]),
+    };
+}
+function normalizeVec3(value, fallback) {
+    const length = Math.hypot(value[0], value[1], value[2]);
+    if (!Number.isFinite(length) || length <= 1e-8)
+        return fallback;
+    return [value[0] / length, value[1] / length, value[2] / length];
+}
+function viewSpaceZ(worldPosition, camera) {
+    const view = camera.matrixWorldInverse?.elements;
+    if (!view || view.length < 16)
+        return Number.NaN;
+    return view[2] * worldPosition[0] + view[6] * worldPosition[1] + view[10] * worldPosition[2] + view[14];
+}
+function transformPoint(matrix, point) {
+    const x = point[0];
+    const y = point[1];
+    const z = point[2];
+    return [
+        matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12],
+        matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13],
+        matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14],
+    ];
+}
+function pointWorldSize(pointSize, worldPosition, sizeAttenuation, camera, viewportHeight) {
+    const projectionY = Math.abs(finiteOrDefault(camera?.projectionMatrix?.elements?.[5], 1));
+    if (projectionY <= 0)
+        return 0;
+    if (camera?.isPerspectiveCamera === true && sizeAttenuation !== false) {
+        const viewZ = viewSpaceZ(worldPosition, camera);
+        const depth = Number.isFinite(viewZ) ? Math.max(0.0001, Math.abs(viewZ)) : 1;
+        const pixelSize = clampPointSpriteSize(pointSize * Math.max(1, viewportHeight) / (2 * depth));
+        return pixelSize * 2 * depth / Math.max(1, viewportHeight) / projectionY;
+    }
+    const cappedPointSize = clampPointSpriteSize(pointSize);
+    if (camera?.isPerspectiveCamera !== true) {
+        return cappedPointSize * 2 / Math.max(1, viewportHeight) / projectionY;
+    }
+    const viewZ = camera ? viewSpaceZ(worldPosition, camera) : -1;
+    const depth = Number.isFinite(viewZ) ? Math.max(0.0001, Math.abs(viewZ)) : 1;
+    return cappedPointSize * 2 * depth / Math.max(1, viewportHeight) / projectionY;
+}
+function clampPointSpriteSize(pixelSize) {
+    return Math.min(pixelSize, MAX_POINT_SPRITE_SIZE);
+}
+function finiteOrDefault(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function safePositiveNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function finiteMaterialOrObjectNumber(value, label, fallback) {
+    if (value == null)
+        return fallback;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    throw new TypeError(`${label} must be a finite number.`);
+}
+function renderOrderNumber(value, label, fallback) {
+    if (value == null)
+        return fallback;
+    if (typeof value === 'number' && (Number.isFinite(value) || value === Infinity || value === -Infinity)) {
+        return value;
+    }
+    throw new TypeError(`${label} must be a finite number or +/-Infinity.`);
+}
+function nativeRenderOrderKey(value) {
+    if (value === Infinity)
+        return NativeRenderOrderLimit;
+    if (value === -Infinity)
+        return -NativeRenderOrderLimit;
+    return value;
+}
+function nonNegativeMaterialOrObjectNumber(value, label, fallback) {
+    const number = finiteMaterialOrObjectNumber(value, label, fallback);
+    if (number < 0) {
+        throw new TypeError(`${label} must be non-negative.`);
+    }
+    return number;
+}
+function positiveMaterialOrObjectNumber(value, label, fallback) {
+    const number = finiteMaterialOrObjectNumber(value, label, fallback);
+    if (number <= 0) {
+        throw new TypeError(`${label} must be positive.`);
+    }
+    return number;
+}
+function validateLineMaterialCompatibilityHints(material) {
+    if (!material)
+        return;
+    optionalLineCap(material.linecap);
+    optionalLineJoin(material.linejoin);
+}
+function optionalLineCap(value) {
+    if (value == null)
+        return;
+    if (typeof value !== 'string') {
+        throw new TypeError('material.linecap must be a string.');
+    }
+    if (value !== 'butt' && value !== 'round' && value !== 'square') {
+        throw new Error(`material.linecap ${JSON.stringify(value)} is not supported by @headless-three/renderer. Use "butt", "round", "square", null, or undefined.`);
+    }
+}
+function optionalLineJoin(value) {
+    if (value == null)
+        return;
+    if (typeof value !== 'string') {
+        throw new TypeError('material.linejoin must be a string.');
+    }
+    if (value !== 'round' && value !== 'bevel' && value !== 'miter') {
+        throw new Error(`material.linejoin ${JSON.stringify(value)} is not supported by @headless-three/renderer. Use "round", "bevel", "miter", null, or undefined.`);
+    }
+}
+function normalizedMaterialOrObjectNumber(value, label, fallback) {
+    const number = finiteMaterialOrObjectNumber(value, label, fallback);
+    if (number < 0 || number > 1) {
+        throw new TypeError(`${label} must be between 0 and 1.`);
+    }
+    return number;
+}
+function cameraZoomOrDefault(value) {
+    if (value == null)
+        return 1;
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new TypeError('camera.zoom must be a finite number.');
+    }
+    if (value <= 0) {
+        throw new TypeError('camera.zoom must be positive.');
+    }
+    return value;
+}
+function finiteCountOrDefault(value, label, fallback, allowInfinity = false) {
+    if (value == null)
+        return fallback;
+    if (allowInfinity && value === Infinity)
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    throw new TypeError(`${label} must be a finite number.`);
+}
+function integerCountOrDefault(value, label, fallback, allowInfinity = false) {
+    const number = finiteCountOrDefault(value, label, fallback, allowInfinity);
+    if (number === Infinity)
+        return number;
+    if (!Number.isInteger(number)) {
+        throw new TypeError(`${label} must be an integer.`);
+    }
+    if (number < 0) {
+        throw new TypeError(`${label} must be non-negative.`);
+    }
+    return number;
+}
+function unsignedSortKey(value, fallback) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+}
+function instancedBufferGeometryCount(geometry) {
+    const attributes = Object.entries((0, attributes_1.geometryAttributes)(geometry));
+    const instancedAttributes = attributes.filter((entry) => isInstancedAttribute(entry[1]));
+    if (geometry.isInstancedBufferGeometry !== true && instancedAttributes.length === 0)
+        return 1;
+    let maxCount = Infinity;
+    for (const [name, attribute] of instancedAttributes) {
+        const label = `geometry.attributes.${name}`;
+        maxCount = Math.min(maxCount, (0, attributes_1.attributeCount)(attribute, label) * meshPerAttribute(attribute, `${label}.meshPerAttribute`));
+    }
+    const requested = integerCountOrDefault(geometry.instanceCount, 'geometry.instanceCount', Infinity, true);
+    const effectiveCount = Math.min(requested, maxCount);
+    if (effectiveCount === Infinity)
+        return 1;
+    return (0, math_1.clampInteger)(effectiveCount, 0, Math.max(0, Math.floor(maxCount)));
+}
+function assertSupportedCustomFragmentInstancedAttributes(geometry, pbrProps) {
+    if (!pbrProps.customFragmentShader)
+        return;
+    const unsupported = [];
+    for (const [name, attribute] of Object.entries((0, attributes_1.geometryAttributes)(geometry))) {
+        if (!isInstancedAttribute(attribute))
+            continue;
+        if (!SupportedInstancedBufferGeometryAttributes.has(name))
+            unsupported.push(`geometry.attributes.${name}`);
+    }
+    if (unsupported.length === 0)
+        return;
+    throw new Error(`Custom WGSL fragment materials cannot bind arbitrary InstancedBufferGeometry vertex attributes (${unsupported.join(', ')}) in @headless-three/renderer yet. Use supported instanced offset, color, normal, or UV attributes, expand the geometry on the CPU, or render separate draws until custom vertex-attribute shader integration is implemented.`);
+}
+function isInstancedAttribute(attribute) {
+    return attribute?.isInstancedBufferAttribute === true;
+}
+function meshPerAttribute(attribute, label = 'InstancedBufferAttribute.meshPerAttribute') {
+    const value = attribute.meshPerAttribute;
+    if (value == null)
+        return 1;
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        if (value <= 0) {
+            throw new TypeError(`${label} must be a positive finite number.`);
+        }
+        if (!Number.isInteger(value)) {
+            throw new TypeError(`${label} must be a positive integer.`);
+        }
+        return value;
+    }
+    throw new TypeError(`${label} must be a positive finite number.`);
+}
+function instancedAttributeIndex(attribute, instanceIndex, label = 'InstancedBufferAttribute') {
+    return Math.min((0, attributes_1.attributeCount)(attribute, label) - 1, Math.floor(instanceIndex / meshPerAttribute(attribute, `${label}.meshPerAttribute`)));
+}
+function instancedOffsetAttribute(geometry) {
+    const names = ['instanceOffset', 'instancePosition', 'offset', 'translate', 'translation'];
+    for (const name of names) {
+        const attribute = (0, attributes_1.getAttribute)(geometry, name);
+        if (isInstancedAttribute(attribute))
+            return { attribute, label: `geometry.attributes.${name}` };
+    }
+    return null;
+}
+function instancedScaleAttribute(geometry) {
+    const names = ['instanceScale', 'scale'];
+    for (const name of names) {
+        const attribute = (0, attributes_1.getAttribute)(geometry, name);
+        if (isInstancedAttribute(attribute))
+            return { attribute, label: `geometry.attributes.${name}` };
+    }
+    return null;
+}
+function expandVec3ValuesForInstances(values, start, count, instanceCount, offsetAttribute, scaleAttribute) {
+    if (instanceCount <= 1 && !offsetAttribute && !scaleAttribute) {
+        return values.slice(start * 3, (start + count) * 3);
+    }
+    const out = new Array(count * instanceCount * 3);
+    let dst = 0;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        const offsetIndex = offsetAttribute
+            ? instancedAttributeIndex(offsetAttribute.attribute, instance, offsetAttribute.label)
+            : 0;
+        const ox = offsetAttribute ? (0, attributes_1.attributeComponent)(offsetAttribute.attribute, offsetIndex, 0, offsetAttribute.label) : 0;
+        const oy = offsetAttribute ? (0, attributes_1.attributeComponent)(offsetAttribute.attribute, offsetIndex, 1, offsetAttribute.label) : 0;
+        const oz = offsetAttribute ? (0, attributes_1.attributeComponent)(offsetAttribute.attribute, offsetIndex, 2, offsetAttribute.label) : 0;
+        const scale = instanceScaleComponents(scaleAttribute, instance);
+        for (let vertex = start; vertex < start + count; vertex += 1) {
+            out[dst++] = values[vertex * 3] * scale[0] + ox;
+            out[dst++] = values[vertex * 3 + 1] * scale[1] + oy;
+            out[dst++] = values[vertex * 3 + 2] * scale[2] + oz;
+        }
+    }
+    return out;
+}
+function expandVec3ValuesForInstancesWithCache(cache, geometry, position, values, start, count, instanceCount, offsetAttribute, scaleAttribute) {
+    if (instanceCount <= 1 && !offsetAttribute && !scaleAttribute) {
+        return expandVec3ValuesForInstances(values, start, count, instanceCount, offsetAttribute, scaleAttribute);
+    }
+    const signature = instancedPositionExpansionSignature(geometry, position, values, start, count, instanceCount, offsetAttribute, scaleAttribute);
+    if (!cache || !signature.cacheable) {
+        return expandVec3ValuesForInstances(values, start, count, instanceCount, offsetAttribute, scaleAttribute);
+    }
+    const key = `${start}:${count}:${instanceCount}`;
+    let geometryCache = cache.instancedPositionExpansions.get(geometry);
+    const cached = geometryCache?.get(key);
+    if (cached && sameInstancedPositionExpansionSignature(cached.signature, signature)) {
+        return cached.positions;
+    }
+    const positions = expandVec3ValuesForInstances(values, start, count, instanceCount, offsetAttribute, scaleAttribute);
+    if (!geometryCache) {
+        geometryCache = new Map();
+        cache.instancedPositionExpansions.set(geometry, geometryCache);
+    }
+    geometryCache.set(key, { signature, positions });
+    return positions;
+}
+function instancedPositionExpansionSignature(geometry, position, values, start, count, instanceCount, offsetAttribute, scaleAttribute) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        sourcePositions: values,
+        start,
+        count,
+        instanceCount,
+        position: attributeSignature(position),
+        instancedPositionOffset: attributeSignature(offsetAttribute?.attribute),
+        instancedPositionScale: attributeSignature(scaleAttribute?.attribute),
+    };
+    signature.cacheable = attributeSignatureCacheable(signature.position)
+        && attributeSignatureCacheable(signature.instancedPositionOffset)
+        && attributeSignatureCacheable(signature.instancedPositionScale);
+    return signature;
+}
+function sameInstancedPositionExpansionSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && a.sourcePositions === b.sourcePositions
+        && a.start === b.start
+        && a.count === b.count
+        && a.instanceCount === b.instanceCount
+        && sameAttributeSignature(a.position, b.position)
+        && sameAttributeSignature(a.instancedPositionOffset, b.instancedPositionOffset)
+        && sameAttributeSignature(a.instancedPositionScale, b.instancedPositionScale);
+}
+function instanceScaleComponents(scaleAttribute, instance) {
+    if (!scaleAttribute)
+        return [1, 1, 1];
+    const sourceIndex = instancedAttributeIndex(scaleAttribute.attribute, instance, scaleAttribute.label);
+    const itemSize = scaleAttribute.attribute.itemSize ?? 1;
+    const sx = (0, attributes_1.attributeComponent)(scaleAttribute.attribute, sourceIndex, 0, scaleAttribute.label);
+    const sy = itemSize >= 2
+        ? (0, attributes_1.attributeComponent)(scaleAttribute.attribute, sourceIndex, 1, scaleAttribute.label)
+        : sx;
+    const sz = itemSize >= 3
+        ? (0, attributes_1.attributeComponent)(scaleAttribute.attribute, sourceIndex, 2, scaleAttribute.label)
+        : sx;
+    return [sx, sy, sz];
+}
+function expandVec2ValuesForInstances(values, start, count, instanceCount) {
+    if (instanceCount <= 1)
+        return values.slice(start * 2, (start + count) * 2);
+    const out = new Array(count * instanceCount * 2);
+    let dst = 0;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        for (let vertex = start; vertex < start + count; vertex += 1) {
+            out[dst++] = values[vertex * 2];
+            out[dst++] = values[vertex * 2 + 1];
+        }
+    }
+    return out;
+}
+function expandNormalValuesForInstances(attribute, values, start, count, instanceCount, label = 'geometry.attributes.normal') {
+    if (!isInstancedAttribute(attribute)) {
+        return expandVec3ValuesForInstances(values, start, count, instanceCount);
+    }
+    const out = new Array(count * instanceCount * 3);
+    let dst = 0;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        const sourceIndex = instancedAttributeIndex(attribute, instance, label);
+        const nx = (0, attributes_1.attributeComponent)(attribute, sourceIndex, 0, label);
+        const ny = (0, attributes_1.attributeComponent)(attribute, sourceIndex, 1, label);
+        const nz = (0, attributes_1.attributeComponent)(attribute, sourceIndex, 2, label);
+        for (let vertex = 0; vertex < count; vertex += 1) {
+            out[dst++] = nx;
+            out[dst++] = ny;
+            out[dst++] = nz;
+        }
+    }
+    return out;
+}
+function expandNormalValuesForInstancesWithCache(cache, geometry, attribute, values, start, count, instanceCount, label = 'geometry.attributes.normal') {
+    if (instanceCount <= 1 && !isInstancedAttribute(attribute)) {
+        return expandNormalValuesForInstances(attribute, values, start, count, instanceCount, label);
+    }
+    const signature = instancedNormalExpansionSignature(geometry, attribute, values, start, count, instanceCount, label);
+    if (!cache || !signature.cacheable) {
+        return expandNormalValuesForInstances(attribute, values, start, count, instanceCount, label);
+    }
+    const key = `${label}:${start}:${count}:${instanceCount}`;
+    let geometryCache = cache.instancedNormalExpansions.get(geometry);
+    const cached = geometryCache?.get(key);
+    if (cached && sameInstancedNormalExpansionSignature(cached.signature, signature)) {
+        return cached.normals;
+    }
+    const normals = expandNormalValuesForInstances(attribute, values, start, count, instanceCount, label);
+    if (!geometryCache) {
+        geometryCache = new Map();
+        cache.instancedNormalExpansions.set(geometry, geometryCache);
+    }
+    geometryCache.set(key, { signature, normals });
+    return normals;
+}
+function instancedNormalExpansionSignature(geometry, attribute, values, start, count, instanceCount, label) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        sourceNormals: values,
+        start,
+        count,
+        instanceCount,
+        normal: attributeSignature(attribute),
+        label,
+    };
+    signature.cacheable = attributeSignatureCacheable(signature.normal);
+    return signature;
+}
+function sameInstancedNormalExpansionSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && a.sourceNormals === b.sourceNormals
+        && a.start === b.start
+        && a.count === b.count
+        && a.instanceCount === b.instanceCount
+        && sameAttributeSignature(a.normal, b.normal)
+        && a.label === b.label;
+}
+function expandUvChannelForInstances(channel, start, count, instanceCount) {
+    if (!isInstancedAttribute(channel.attribute)) {
+        return expandVec2ValuesForInstances(channel.values, start, count, instanceCount);
+    }
+    const out = new Array(count * instanceCount * 2);
+    let dst = 0;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        const sourceIndex = instancedAttributeIndex(channel.attribute, instance, labelForMeshPerAttribute(channel));
+        const u = (0, attributes_1.attributeComponent)(channel.attribute, sourceIndex, 0, channel.label);
+        const v = (0, attributes_1.attributeComponent)(channel.attribute, sourceIndex, 1, channel.label);
+        for (let vertex = 0; vertex < count; vertex += 1) {
+            out[dst++] = u;
+            out[dst++] = v;
+        }
+    }
+    return out;
+}
+function expandUvChannelForInstancesWithCache(cache, geometry, channel, start, count, instanceCount) {
+    if (instanceCount <= 1 && !isInstancedAttribute(channel.attribute)) {
+        return expandUvChannelForInstances(channel, start, count, instanceCount);
+    }
+    const signature = instancedUvExpansionSignature(geometry, channel, start, count, instanceCount);
+    if (!cache || !signature.cacheable) {
+        return expandUvChannelForInstances(channel, start, count, instanceCount);
+    }
+    const key = `${channel.label}:${start}:${count}:${instanceCount}`;
+    let geometryCache = cache.instancedUvExpansions.get(geometry);
+    const cached = geometryCache?.get(key);
+    if (cached && sameInstancedUvExpansionSignature(cached.signature, signature)) {
+        return cached.uvs;
+    }
+    const uvs = expandUvChannelForInstances(channel, start, count, instanceCount);
+    if (!geometryCache) {
+        geometryCache = new Map();
+        cache.instancedUvExpansions.set(geometry, geometryCache);
+    }
+    geometryCache.set(key, { signature, uvs });
+    return uvs;
+}
+function instancedUvExpansionSignature(geometry, channel, start, count, instanceCount) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        channel: uvChannelSignature(channel),
+        start,
+        count,
+        instanceCount,
+    };
+    signature.cacheable = attributeSignatureCacheable(signature.channel.attribute);
+    return signature;
+}
+function sameInstancedUvExpansionSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && sameUvChannelSignature(a.channel, b.channel)
+        && a.start === b.start
+        && a.count === b.count
+        && a.instanceCount === b.instanceCount;
+}
+function appendUvForVertex(out, channel, vertexIndex, instanceIndex) {
+    const sourceIndex = isInstancedAttribute(channel.attribute)
+        ? instancedAttributeIndex(channel.attribute, instanceIndex, labelForMeshPerAttribute(channel))
+        : vertexIndex;
+    out.push((0, attributes_1.attributeComponent)(channel.attribute, sourceIndex, 0, channel.label), (0, attributes_1.attributeComponent)(channel.attribute, sourceIndex, 1, channel.label));
+}
+function uvValuesForInstance(channel, vertexCount, instanceIndex) {
+    if (!channel)
+        return null;
+    if (!isInstancedAttribute(channel.attribute))
+        return channel.values;
+    const out = new Array(vertexCount * 2);
+    let dst = 0;
+    const sourceIndex = instancedAttributeIndex(channel.attribute, instanceIndex, labelForMeshPerAttribute(channel));
+    const u = (0, attributes_1.attributeComponent)(channel.attribute, sourceIndex, 0, channel.label);
+    const v = (0, attributes_1.attributeComponent)(channel.attribute, sourceIndex, 1, channel.label);
+    for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+        out[dst++] = u;
+        out[dst++] = v;
+    }
+    return out;
+}
+function labelForMeshPerAttribute(channel) {
+    return `${channel.label}.meshPerAttribute`;
+}
+function expandColorAttributeForInstances(attribute, materialColor, start, count, instanceCount, label = 'geometry.attributes.color') {
+    if (!isInstancedAttribute(attribute)) {
+        const colors = (0, attributes_1.readColorAttribute)(attribute, materialColor, label);
+        if (instanceCount <= 1)
+            return colors.slice(start * 4, (start + count) * 4);
+        const out = new Array(count * instanceCount * 4);
+        let dst = 0;
+        for (let instance = 0; instance < instanceCount; instance += 1) {
+            for (let vertex = start; vertex < start + count; vertex += 1) {
+                out[dst++] = colors[vertex * 4];
+                out[dst++] = colors[vertex * 4 + 1];
+                out[dst++] = colors[vertex * 4 + 2];
+                out[dst++] = colors[vertex * 4 + 3];
+            }
+        }
+        return out;
+    }
+    const itemSize = attribute.itemSize ?? 3;
+    const out = new Array(count * instanceCount * 4);
+    let dst = 0;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        const sourceIndex = instancedAttributeIndex(attribute, instance, label);
+        const r = (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 0, label) * materialColor[0]);
+        const g = (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 1, label) * materialColor[1]);
+        const b = (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 2, label) * materialColor[2]);
+        const a = (0, math_1.clamp01)((itemSize >= 4 ? (0, attributes_1.attributeComponent)(attribute, sourceIndex, 3, label) : 1) * materialColor[3]);
+        for (let vertex = 0; vertex < count; vertex += 1) {
+            out[dst++] = r;
+            out[dst++] = g;
+            out[dst++] = b;
+            out[dst++] = a;
+        }
+    }
+    return out;
+}
+function expandColorAttributeForInstancesWithCache(cache, geometry, attribute, materialColor, start, count, instanceCount, label = 'geometry.attributes.color') {
+    if (instanceCount <= 1 && !isInstancedAttribute(attribute)) {
+        return expandColorAttributeForInstances(attribute, materialColor, start, count, instanceCount, label);
+    }
+    const signature = instancedColorExpansionSignature(geometry, attribute, materialColor, start, count, instanceCount, label);
+    if (!cache || !signature.cacheable) {
+        return expandColorAttributeForInstances(attribute, materialColor, start, count, instanceCount, label);
+    }
+    const key = `${label}:${start}:${count}:${instanceCount}`;
+    let geometryCache = cache.instancedColorExpansions.get(geometry);
+    const cached = geometryCache?.get(key);
+    if (cached && sameInstancedColorExpansionSignature(cached.signature, signature)) {
+        return cached.colors;
+    }
+    const colors = expandColorAttributeForInstances(attribute, materialColor, start, count, instanceCount, label);
+    if (!geometryCache) {
+        geometryCache = new Map();
+        cache.instancedColorExpansions.set(geometry, geometryCache);
+    }
+    geometryCache.set(key, { signature, colors });
+    return colors;
+}
+function instancedColorExpansionSignature(geometry, attribute, materialColor, start, count, instanceCount, label) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        materialColor: materialColor.slice(),
+        start,
+        count,
+        instanceCount,
+        color: attributeSignature(attribute),
+        label,
+    };
+    signature.cacheable = attributeSignatureCacheable(signature.color);
+    return signature;
+}
+function sameInstancedColorExpansionSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && sameNumberArray(a.materialColor, b.materialColor)
+        && a.start === b.start
+        && a.count === b.count
+        && a.instanceCount === b.instanceCount
+        && sameAttributeSignature(a.color, b.color)
+        && a.label === b.label;
+}
+function expandIndicesForInstances(indices, vertexCount, instanceCount) {
+    if (instanceCount <= 1)
+        return indices;
+    const out = new Array(indices.length * instanceCount);
+    let dst = 0;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        const offset = instance * vertexCount;
+        for (const index of indices) {
+            out[dst++] = index + offset;
+        }
+    }
+    return out;
+}
+function wireframeIndicesForTriangles(indices) {
+    const out = new Array(indices.length * 2);
+    let dst = 0;
+    for (let i = 0; i < indices.length; i += 3) {
+        const a = indices[i];
+        const b = indices[i + 1];
+        const c = indices[i + 2];
+        out[dst++] = a;
+        out[dst++] = b;
+        out[dst++] = b;
+        out[dst++] = c;
+        out[dst++] = c;
+        out[dst++] = a;
+    }
+    return out;
+}
+function wireframeIndicesForUnindexedTriangles(vertexCount) {
+    const out = new Array(vertexCount * 2);
+    let dst = 0;
+    for (let i = 0; i < vertexCount; i += 3) {
+        out[dst++] = i;
+        out[dst++] = i + 1;
+        out[dst++] = i + 1;
+        out[dst++] = i + 2;
+        out[dst++] = i + 2;
+        out[dst++] = i;
+    }
+    return out;
+}
+function isDepthDistanceWireframeMaterial(material) {
+    return material?.wireframe === true
+        && (material.isMeshDepthMaterial === true || material.isMeshDistanceMaterial === true);
+}
+function isMeshWireframeMaterial(material) {
+    return material?.wireframe === true;
+}
+function readUvChannels(geometry) {
+    const primaryUvs = readOptionalUvAttribute(geometry, 'uv');
+    return [
+        primaryUvs,
+        readOptionalUvAttribute(geometry, 'uv1') ?? readOptionalUvAttribute(geometry, 'uv2') ?? primaryUvs,
+        readOptionalUvAttribute(geometry, 'uv2') ?? readOptionalUvAttribute(geometry, 'uv1') ?? primaryUvs,
+        readOptionalUvAttribute(geometry, 'uv3') ?? primaryUvs,
+    ];
+}
+function readOptionalUvAttribute(geometry, name) {
+    const attribute = (0, attributes_1.getAttribute)(geometry, name);
+    if (!attribute)
+        return null;
+    const label = `geometry.attributes.${name}`;
+    return {
+        attribute,
+        label,
+        values: (0, attributes_1.readVec2Attribute)(attribute, label),
+    };
+}
+function textureUvStreamsForMapAlphaMaterial(channels, material) {
+    const mapChannel = material?.map ? (0, materials_1.textureUvChannel)(material.map) : undefined;
+    const alphaChannel = material?.alphaMap ? (0, materials_1.textureUvChannel)(material.alphaMap) : undefined;
+    const requestedChannels = [mapChannel, alphaChannel]
+        .filter((channel) => channel !== undefined);
+    const distinctChannels = [...new Set(requestedChannels)];
+    let primaryChannel = 0;
+    let secondaryChannel;
+    if (mapChannel !== undefined
+        && alphaChannel !== undefined
+        && mapChannel !== alphaChannel
+        && mapChannel > 0
+        && alphaChannel > 0) {
+        primaryChannel = mapChannel;
+        secondaryChannel = alphaChannel;
+    }
+    else {
+        secondaryChannel = distinctChannels.find((channel) => channel > 0);
+    }
+    return {
+        uvs: channels[primaryChannel] ?? channels[0],
+        uvs2: secondaryChannel !== undefined
+            ? channels[secondaryChannel] ?? channels[0]
+            : null,
+        textureUsesUv2: mapChannel !== undefined ? mapChannel !== primaryChannel : undefined,
+        alphaMapUsesUv2: alphaChannel !== undefined ? alphaChannel !== primaryChannel : undefined,
+    };
+}
+function textureUvStreamsForMeshMaterial(channels, material) {
+    return textureUvStreamsForMaterialSlots(channels, meshTextureUvSlots(material));
+}
+function meshTextureUvSlots(material) {
+    if (!material)
+        return [];
+    const slots = material.isMeshMatcapMaterial === true
+        ? [{ texture: material.map, pbrFlag: 'matcapMapUsesUv2' }]
+        : [{ texture: material.map, textureFlag: 'textureUsesUv2' }];
+    slots.push({ texture: material.clearcoatMap, pbrFlag: 'clearcoatMapUsesUv2' }, { texture: material.clearcoatRoughnessMap, pbrFlag: 'clearcoatRoughnessMapUsesUv2' }, { texture: material.clearcoatNormalMap, pbrFlag: 'clearcoatNormalMapUsesUv2' }, { texture: material.sheenColorMap, pbrFlag: 'sheenColorMapUsesUv2' }, { texture: material.sheenRoughnessMap, pbrFlag: 'sheenRoughnessMapUsesUv2' }, { texture: material.anisotropyMap, pbrFlag: 'anisotropyMapUsesUv2' }, { texture: material.iridescenceMap, pbrFlag: 'iridescenceMapUsesUv2' }, { texture: material.iridescenceThicknessMap, pbrFlag: 'iridescenceThicknessMapUsesUv2' }, { texture: material.normalMap, pbrFlag: 'normalMapUsesUv2' }, { texture: material.bumpMap, pbrFlag: 'bumpMapUsesUv2' }, { texture: material.transmissionMap, pbrFlag: 'transmissionMapUsesUv2' }, { texture: material.thicknessMap, pbrFlag: 'thicknessMapUsesUv2' }, { texture: material.specularColorMap, pbrFlag: 'specularColorMapUsesUv2' }, { texture: material.specularIntensityMap, pbrFlag: 'specularIntensityMapUsesUv2' }, { texture: material.displacementMap, pbrFlag: 'displacementMapUsesUv2' }, { texture: material.metalnessMap ?? material.roughnessMap, pbrFlag: 'metallicRoughnessTextureUsesUv2' }, { texture: material.emissiveMap, pbrFlag: 'emissiveMapUsesUv2' }, { texture: material.lightMap, pbrFlag: 'lightMapUsesUv2' }, { texture: material.aoMap, pbrFlag: 'aoMapUsesUv2' }, { texture: material.specularMap, pbrFlag: 'specularMapUsesUv2' }, { texture: material.alphaMap, textureFlag: 'alphaMapUsesUv2' });
+    return slots;
+}
+function textureUvStreamsForMaterialSlots(channels, slots) {
+    const activeSlots = slots.filter((slot) => slot.texture != null);
+    const requestedChannels = [];
+    for (const slot of activeSlots) {
+        const channel = (0, materials_1.textureUvChannel)(slot.texture);
+        if (!requestedChannels.includes(channel))
+            requestedChannels.push(channel);
+    }
+    if (requestedChannels.length > 2) {
+        const channelList = [...requestedChannels].sort((a, b) => a - b).join(', ');
+        throw new Error(`Material uses texture.channel values ${channelList}, but @headless-three/renderer can bind only two UV attributes per draw. Use at most two texture channels or render separate passes.`);
+    }
+    const preferredPrimary = preferredPrimaryTextureChannel(activeSlots);
+    const primaryChannel = requestedChannels.includes(0)
+        ? 0
+        : preferredPrimary !== undefined && requestedChannels.includes(preferredPrimary)
+            ? preferredPrimary
+            : requestedChannels[0] ?? 0;
+    const secondaryChannel = requestedChannels.find((channel) => channel !== primaryChannel);
+    const out = {
+        uvs: channels[primaryChannel] ?? channels[0],
+        uvs2: secondaryChannel !== undefined
+            ? channels[secondaryChannel] ?? channels[0]
+            : null,
+    };
+    for (const slot of activeSlots) {
+        const usesUv2 = secondaryChannel !== undefined
+            && (0, materials_1.textureUvChannel)(slot.texture) === secondaryChannel;
+        if (slot.textureFlag === 'textureUsesUv2') {
+            out.textureUsesUv2 = usesUv2;
+        }
+        else if (slot.textureFlag === 'alphaMapUsesUv2') {
+            out.alphaMapUsesUv2 = usesUv2;
+        }
+        else if (slot.pbrFlag) {
+            out.pbrUsesUv2 ?? (out.pbrUsesUv2 = {});
+            out.pbrUsesUv2[slot.pbrFlag] = usesUv2;
+        }
+    }
+    return out;
+}
+function preferredPrimaryTextureChannel(slots) {
+    for (const flag of ['textureUsesUv2', 'alphaMapUsesUv2']) {
+        const slot = slots.find((candidate) => candidate.textureFlag === flag);
+        if (slot?.texture != null)
+            return (0, materials_1.textureUvChannel)(slot.texture);
+    }
+    return slots[0]?.texture ? (0, materials_1.textureUvChannel)(slots[0].texture) : undefined;
+}
+function applyPbrUvStreamFlags(props, uvStreams) {
+    if (!uvStreams.pbrUsesUv2)
+        return;
+    for (const [flag, usesUv2] of Object.entries(uvStreams.pbrUsesUv2)) {
+        props[flag] = usesUv2;
+    }
+}
+function secondaryUvsForMaterial(channels, material) {
+    const textures = [
+        material?.clearcoatMap,
+        material?.clearcoatRoughnessMap,
+        material?.clearcoatNormalMap,
+        material?.sheenColorMap,
+        material?.sheenRoughnessMap,
+        material?.anisotropyMap,
+        material?.iridescenceMap,
+        material?.iridescenceThicknessMap,
+        material?.normalMap,
+        material?.bumpMap,
+        material?.transmissionMap,
+        material?.thicknessMap,
+        material?.specularColorMap,
+        material?.specularIntensityMap,
+        material?.displacementMap,
+        material?.map,
+        material?.metalnessMap,
+        material?.roughnessMap,
+        material?.emissiveMap,
+        material?.lightMap,
+        material?.aoMap,
+        material?.specularMap,
+        material?.alphaMap,
+    ];
+    let channel = 0;
+    for (const texture of textures) {
+        const textureChannel = (0, materials_1.textureUvChannel)(texture);
+        if (textureChannel === 0)
+            continue;
+        if (channel === 0) {
+            channel = textureChannel;
+            continue;
+        }
+        if (channel !== textureChannel) {
+            throw new Error(`Material uses multiple non-primary texture.channel values (${channel} and ${textureChannel}), but @headless-three/renderer can bind one secondary UV attribute per draw. Use one shared non-primary channel or render separate passes.`);
+        }
+    }
+    return channels[channel] ?? channels[0];
+}
+function updateLodObject(object, camera) {
+    if (object.isLOD !== true || !camera)
+        return;
+    if (optionalObjectBoolean(object.autoUpdate, 'LOD.autoUpdate') === false)
+        return;
+    const levels = object.levels;
+    const normalizedLevels = normalizeLodLevels(levels);
+    const cameraZoom = cameraZoomOrDefault(camera.zoom);
+    if (typeof object.update === 'function') {
+        object.update(camera);
+        return;
+    }
+    if (normalizedLevels.length <= 1)
+        return;
+    const distance = distanceBetweenMatrices(camera.matrixWorld, object.matrixWorld) / cameraZoom;
+    normalizedLevels[0].object.visible = true;
+    let i = 1;
+    for (; i < normalizedLevels.length; i += 1) {
+        const level = normalizedLevels[i];
+        let levelDistance = level.distance;
+        if (level.object.visible) {
+            levelDistance -= levelDistance * level.hysteresis;
+        }
+        if (distance >= levelDistance) {
+            normalizedLevels[i - 1].object.visible = false;
+            level.object.visible = true;
+        }
+        else {
+            break;
+        }
+    }
+    ;
+    object._currentLevel = i - 1;
+    for (; i < normalizedLevels.length; i += 1) {
+        normalizedLevels[i].object.visible = false;
+    }
+}
+function normalizeLodLevels(levels) {
+    if (levels == null)
+        return [];
+    if (!Array.isArray(levels)) {
+        throw new TypeError('LOD.levels must be an array.');
+    }
+    return levels.map((level, index) => {
+        if (!level || typeof level !== 'object' || Array.isArray(level)) {
+            throw new TypeError(`LOD.levels[${index}] must be an object.`);
+        }
+        const object = level.object;
+        if (!object || typeof object !== 'object' || Array.isArray(object)) {
+            throw new TypeError(`LOD.levels[${index}].object must be a THREE.Object3D-like object.`);
+        }
+        return {
+            object: object,
+            distance: nonNegativeMaterialOrObjectNumber(level.distance, `LOD.levels[${index}].distance`, 0),
+            hysteresis: normalizedMaterialOrObjectNumber(level.hysteresis, `LOD.levels[${index}].hysteresis`, 0),
+        };
+    });
+}
+function distanceBetweenMatrices(a, b) {
+    const ae = a?.elements;
+    const be = b?.elements;
+    if (!ae || ae.length < 16 || !be || be.length < 16)
+        return 0;
+    const dx = ae[12] - be[12];
+    const dy = ae[13] - be[13];
+    const dz = ae[14] - be[14];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function dashedLineAttributes(positions, uvs, uvs2, colors, source, start, end, object, lineDistance, material) {
+    const dashSize = positiveMaterialOrObjectNumber(material.dashSize, 'material.dashSize', 3);
+    const gapSize = nonNegativeMaterialOrObjectNumber(material.gapSize, 'material.gapSize', 1);
+    const scale = nonNegativeMaterialOrObjectNumber(material.scale, 'material.scale', 1);
+    const segments = lineSegmentsWithDistances(positions, source, start, end, object, lineDistance);
+    const out = createDashedLineExpansion(uvs, uvs2, colors);
+    if (!lineDistance || gapSize <= 0 || scale === 0) {
+        for (const segment of segments) {
+            appendInterpolatedLine(out, positions, uvs, uvs2, colors, segment.a, segment.b, 0, 1);
+        }
+        return out;
+    }
+    const totalSize = dashSize + gapSize;
+    for (const segment of segments) {
+        appendDashedSegment(out, positions, uvs, uvs2, colors, segment, scale, dashSize, totalSize);
+    }
+    return out;
+}
+function dashedLineAttributesWithCache(cache, geometry, position, positions, uvChannel, uvChannel2, colors, source, start, end, object, lineDistance, material) {
+    const dashSize = positiveMaterialOrObjectNumber(material.dashSize, 'material.dashSize', 3);
+    const gapSize = nonNegativeMaterialOrObjectNumber(material.gapSize, 'material.gapSize', 1);
+    const scale = nonNegativeMaterialOrObjectNumber(material.scale, 'material.scale', 1);
+    const uvs = uvChannel?.values ?? null;
+    const uvs2 = uvChannel2?.values ?? null;
+    if (!cache || colors) {
+        return dashedLineAttributes(positions, uvs, uvs2, colors, source, start, end, object, lineDistance, material);
+    }
+    const signature = dashedLineSignature(geometry, position, uvChannel, uvChannel2, lineDistance, start, end, source.length, object, dashSize, gapSize, scale);
+    if (!signature.cacheable) {
+        return dashedLineAttributes(positions, uvs, uvs2, colors, source, start, end, object, lineDistance, material);
+    }
+    const cacheKey = dashedLineCacheKey(signature);
+    const geometryCache = cache.dashedLines.get(geometry);
+    const cached = geometryCache?.get(cacheKey);
+    if (cached && sameDashedLineSignature(cached.signature, signature)) {
+        return cached.expansion;
+    }
+    const expansion = dashedLineAttributes(positions, uvs, uvs2, colors, source, start, end, object, lineDistance, material);
+    let writableGeometryCache = geometryCache;
+    if (!writableGeometryCache) {
+        writableGeometryCache = new Map();
+        cache.dashedLines.set(geometry, writableGeometryCache);
+    }
+    writableGeometryCache.set(cacheKey, { signature, expansion });
+    return expansion;
+}
+function dashedLineSignature(geometry, position, uvChannel, uvChannel2, lineDistance, start, end, sourceLength, object, dashSize, gapSize, scale) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        position: attributeSignature(position),
+        index: attributeSignature(geometry.index),
+        uv: uvChannelSignature(uvChannel),
+        uv2: uvChannelSignature(uvChannel2),
+        lineDistance: attributeSignature(lineDistance),
+        start,
+        end,
+        sourceLength,
+        isLineSegments: object.isLineSegments,
+        isLineLoop: object.isLineLoop,
+        isLine: object.isLine,
+        dashSize,
+        gapSize,
+        scale,
+    };
+    signature.cacheable = dashedLineSignatureCacheable(signature);
+    return signature;
+}
+function dashedLineSignatureCacheable(signature) {
+    return attributeSignatureCacheable(signature.position)
+        && attributeSignatureCacheable(signature.index)
+        && attributeSignatureCacheable(signature.uv.attribute)
+        && attributeSignatureCacheable(signature.uv2.attribute)
+        && attributeSignatureCacheable(signature.lineDistance);
+}
+function dashedLineCacheKey(signature) {
+    return [
+        signature.start,
+        signature.end,
+        signature.sourceLength,
+        signature.isLineSegments ? 1 : 0,
+        signature.isLineLoop ? 1 : 0,
+        signature.isLine ? 1 : 0,
+        signature.uv.attribute.ref ? 1 : 0,
+        signature.uv2.attribute.ref ? 1 : 0,
+        signature.dashSize,
+        signature.gapSize,
+        signature.scale,
+    ].join(':');
+}
+function sameDashedLineSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && sameAttributeSignature(a.position, b.position)
+        && sameAttributeSignature(a.index, b.index)
+        && sameUvChannelSignature(a.uv, b.uv)
+        && sameUvChannelSignature(a.uv2, b.uv2)
+        && sameAttributeSignature(a.lineDistance, b.lineDistance)
+        && a.start === b.start
+        && a.end === b.end
+        && a.sourceLength === b.sourceLength
+        && a.isLineSegments === b.isLineSegments
+        && a.isLineLoop === b.isLineLoop
+        && a.isLine === b.isLine
+        && Object.is(a.dashSize, b.dashSize)
+        && Object.is(a.gapSize, b.gapSize)
+        && Object.is(a.scale, b.scale);
+}
+function dashedLineAttributesForInstancesWithCache(cache, geometry, position, positions, uvChannel, uvChannel2, vertexColors, materialColor, source, start, end, object, lineDistance, material, instanceCount, offsetAttribute, scaleAttribute) {
+    const dashSize = positiveMaterialOrObjectNumber(material.dashSize, 'material.dashSize', 3);
+    const gapSize = nonNegativeMaterialOrObjectNumber(material.gapSize, 'material.gapSize', 1);
+    const scale = nonNegativeMaterialOrObjectNumber(material.scale, 'material.scale', 1);
+    if (!cache) {
+        return dashedLineAttributesForInstances(positions, uvChannel, uvChannel2, vertexColors, materialColor, source, start, end, object, lineDistance, material, instanceCount, offsetAttribute, scaleAttribute);
+    }
+    const signature = instancedDashedLineSignature(geometry, position, uvChannel, uvChannel2, vertexColors, materialColor, lineDistance, start, end, source.length, object, dashSize, gapSize, scale, instanceCount, offsetAttribute, scaleAttribute);
+    if (!signature.cacheable) {
+        return dashedLineAttributesForInstances(positions, uvChannel, uvChannel2, vertexColors, materialColor, source, start, end, object, lineDistance, material, instanceCount, offsetAttribute, scaleAttribute);
+    }
+    const cacheKey = instancedDashedLineCacheKey(signature);
+    let geometryCache = cache.instancedDashedLines.get(geometry);
+    const cached = geometryCache?.get(cacheKey);
+    if (cached && sameInstancedDashedLineSignature(cached.signature, signature)) {
+        return cached.expansion;
+    }
+    const expansion = dashedLineAttributesForInstances(positions, uvChannel, uvChannel2, vertexColors, materialColor, source, start, end, object, lineDistance, material, instanceCount, offsetAttribute, scaleAttribute);
+    if (!geometryCache) {
+        geometryCache = new Map();
+        cache.instancedDashedLines.set(geometry, geometryCache);
+    }
+    geometryCache.set(cacheKey, { signature, expansion });
+    return expansion;
+}
+function instancedDashedLineSignature(geometry, position, uvChannel, uvChannel2, vertexColors, materialColor, lineDistance, start, end, sourceLength, object, dashSize, gapSize, scale, instanceCount, offsetAttribute, scaleAttribute) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        position: attributeSignature(position),
+        index: attributeSignature(geometry.index),
+        uv: uvChannelSignature(uvChannel),
+        uv2: uvChannelSignature(uvChannel2),
+        lineDistance: attributeSignature(lineDistance),
+        vertexColors: attributeSignature(vertexColors),
+        instancedPositionOffset: attributeSignature(offsetAttribute?.attribute),
+        instancedPositionScale: attributeSignature(scaleAttribute?.attribute),
+        materialColor: vertexColors ? materialColor.slice() : undefined,
+        start,
+        end,
+        sourceLength,
+        instanceCount,
+        isLineSegments: object.isLineSegments,
+        isLineLoop: object.isLineLoop,
+        isLine: object.isLine,
+        dashSize,
+        gapSize,
+        scale,
+    };
+    signature.cacheable = instancedDashedLineSignatureCacheable(signature);
+    return signature;
+}
+function instancedDashedLineSignatureCacheable(signature) {
+    return attributeSignatureCacheable(signature.position)
+        && attributeSignatureCacheable(signature.index)
+        && attributeSignatureCacheable(signature.uv.attribute)
+        && attributeSignatureCacheable(signature.uv2.attribute)
+        && attributeSignatureCacheable(signature.lineDistance)
+        && attributeSignatureCacheable(signature.vertexColors)
+        && attributeSignatureCacheable(signature.instancedPositionOffset)
+        && attributeSignatureCacheable(signature.instancedPositionScale);
+}
+function instancedDashedLineCacheKey(signature) {
+    return [
+        'instanced',
+        signature.start,
+        signature.end,
+        signature.sourceLength,
+        signature.instanceCount,
+        signature.isLineSegments ? 1 : 0,
+        signature.isLineLoop ? 1 : 0,
+        signature.isLine ? 1 : 0,
+        signature.uv.attribute.ref ? 1 : 0,
+        signature.uv2.attribute.ref ? 1 : 0,
+        signature.vertexColors.ref ? 1 : 0,
+        signature.instancedPositionOffset.ref ? 1 : 0,
+        signature.instancedPositionScale.ref ? 1 : 0,
+        signature.dashSize,
+        signature.gapSize,
+        signature.scale,
+    ].join(':');
+}
+function sameInstancedDashedLineSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && sameAttributeSignature(a.position, b.position)
+        && sameAttributeSignature(a.index, b.index)
+        && sameUvChannelSignature(a.uv, b.uv)
+        && sameUvChannelSignature(a.uv2, b.uv2)
+        && sameAttributeSignature(a.lineDistance, b.lineDistance)
+        && sameAttributeSignature(a.vertexColors, b.vertexColors)
+        && sameAttributeSignature(a.instancedPositionOffset, b.instancedPositionOffset)
+        && sameAttributeSignature(a.instancedPositionScale, b.instancedPositionScale)
+        && sameOptionalNumberArray(a.materialColor, b.materialColor)
+        && a.start === b.start
+        && a.end === b.end
+        && a.sourceLength === b.sourceLength
+        && a.instanceCount === b.instanceCount
+        && a.isLineSegments === b.isLineSegments
+        && a.isLineLoop === b.isLineLoop
+        && a.isLine === b.isLine
+        && Object.is(a.dashSize, b.dashSize)
+        && Object.is(a.gapSize, b.gapSize)
+        && Object.is(a.scale, b.scale);
+}
+function dashedLineAttributesForInstances(positions, uvChannel, uvChannel2, vertexColors, materialColor, source, start, end, object, lineDistance, material, instanceCount, offsetAttribute, scaleAttribute) {
+    const out = {
+        positions: [],
+        uvs: uvChannel ? [] : undefined,
+        uvs2: uvChannel2 ? [] : undefined,
+        colors: vertexColors ? [] : undefined,
+    };
+    const baseColors = vertexColors && !isInstancedAttribute(vertexColors)
+        ? (0, attributes_1.readColorAttribute)(vertexColors, materialColor, 'geometry.attributes.color')
+        : undefined;
+    const vertexCount = positions.length / 3;
+    for (let instance = 0; instance < instanceCount; instance += 1) {
+        const instancePositions = offsetAttribute
+            ? transformVec3ValuesForInstance(positions, offsetAttribute, scaleAttribute, instance)
+            : scaleAttribute
+                ? transformVec3ValuesForInstance(positions, null, scaleAttribute, instance)
+                : positions;
+        const instanceUvs = uvValuesForInstance(uvChannel, vertexCount, instance);
+        const instanceUvs2 = uvValuesForInstance(uvChannel2, vertexCount, instance);
+        const instanceColors = vertexColors
+            ? baseColors ?? repeatedInstancedColorValues(vertexColors, materialColor, positions.length / 3, instance)
+            : undefined;
+        const dashed = dashedLineAttributes(instancePositions, instanceUvs, instanceUvs2, instanceColors, source, start, end, object, lineDistance, material);
+        appendDashedLineExpansion(out, dashed);
+    }
+    return out;
+}
+function transformVec3ValuesForInstance(values, offsetAttribute, scaleAttribute, instance) {
+    const offsetIndex = offsetAttribute
+        ? instancedAttributeIndex(offsetAttribute.attribute, instance, offsetAttribute.label)
+        : 0;
+    const ox = offsetAttribute ? (0, attributes_1.attributeComponent)(offsetAttribute.attribute, offsetIndex, 0, offsetAttribute.label) : 0;
+    const oy = offsetAttribute ? (0, attributes_1.attributeComponent)(offsetAttribute.attribute, offsetIndex, 1, offsetAttribute.label) : 0;
+    const oz = offsetAttribute ? (0, attributes_1.attributeComponent)(offsetAttribute.attribute, offsetIndex, 2, offsetAttribute.label) : 0;
+    const scale = instanceScaleComponents(scaleAttribute, instance);
+    const out = new Array(values.length);
+    for (let i = 0; i < values.length; i += 3) {
+        out[i] = values[i] * scale[0] + ox;
+        out[i + 1] = values[i + 1] * scale[1] + oy;
+        out[i + 2] = values[i + 2] * scale[2] + oz;
+    }
+    return out;
+}
+function repeatedInstancedColorValues(attribute, materialColor, vertexCount, instance, label = 'geometry.attributes.color') {
+    const sourceIndex = instancedAttributeIndex(attribute, instance, label);
+    const itemSize = attribute.itemSize ?? 3;
+    const color = [
+        (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 0, label) * materialColor[0]),
+        (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 1, label) * materialColor[1]),
+        (0, math_1.clamp01)((0, attributes_1.attributeComponent)(attribute, sourceIndex, 2, label) * materialColor[2]),
+        (0, math_1.clamp01)((itemSize >= 4 ? (0, attributes_1.attributeComponent)(attribute, sourceIndex, 3, label) : 1) * materialColor[3]),
+    ];
+    const out = new Array(vertexCount * 4);
+    let dst = 0;
+    for (let i = 0; i < vertexCount; i += 1) {
+        out[dst++] = color[0];
+        out[dst++] = color[1];
+        out[dst++] = color[2];
+        out[dst++] = color[3];
+    }
+    return out;
+}
+function appendDashedLineExpansion(out, value) {
+    appendNumberArray(out.positions, value.positions);
+    if (out.uvs && value.uvs)
+        appendNumberArray(out.uvs, value.uvs);
+    if (out.uvs2 && value.uvs2)
+        appendNumberArray(out.uvs2, value.uvs2);
+    if (out.colors && value.colors)
+        appendNumberArray(out.colors, value.colors);
+}
+function batchedMeshDraws(object, camera, geometry) {
+    const instanceInfo = object._instanceInfo;
+    if (!Array.isArray(instanceInfo)) {
+        throw new Error('THREE.BatchedMesh instance table is not readable. Use a real THREE.BatchedMesh or expand the batch to ordinary Mesh or InstancedMesh objects before rendering.');
+    }
+    const baseTransform = (0, math_1.matrixElements)(object.matrixWorld, 'batchedMesh.matrixWorld');
+    const cullPerObject = batchedPerObjectFrustumCulled(object, camera);
+    const sortObjects = batchedSortObjects(object);
+    const customSort = batchedCustomSort(object);
+    const draws = [];
+    for (let instanceId = 0; instanceId < instanceInfo.length; instanceId += 1) {
+        const info = instanceInfo[instanceId];
+        if (!info || typeof info !== 'object') {
+            throw new TypeError(`THREE.BatchedMesh._instanceInfo[${instanceId}] must be an object.`);
+        }
+        if (!batchedOptionalBoolean(info.active, `THREE.BatchedMesh._instanceInfo[${instanceId}].active`, true))
+            continue;
+        if (!batchedOptionalBoolean(info.visible, `THREE.BatchedMesh._instanceInfo[${instanceId}].visible`, true))
+            continue;
+        const geometryId = batchedNonNegativeInteger(info.geometryIndex, `THREE.BatchedMesh._instanceInfo[${instanceId}].geometryIndex`);
+        const range = batchedGeometryRange(object, geometry, geometryId);
+        if (range.count === 0)
+            continue;
+        const transform = multiplyMat4(baseTransform, batchedInstanceMatrix(object, instanceId));
+        if (cullPerObject && batchedDrawOutsideFrustum(object, geometry, geometryId, range, transform, camera)) {
+            continue;
+        }
+        draws.push({
+            range,
+            instanceId,
+            instance: {
+                transform,
+                color: batchedInstanceColor(object, instanceId),
+            },
+            z: sortObjects ? batchedDrawDistanceZ(object, geometry, geometryId, range, transform, camera) : 0,
+        });
+    }
+    if (!sortObjects || draws.length < 2)
+        return draws;
+    if (customSort) {
+        return customSortedBatchedMeshDraws(object, draws, customSort, camera);
+    }
+    return draws
+        .slice()
+        .sort(batchedMeshUsesTransparentSort(object) ? compareBatchedDrawsTransparent : compareBatchedDrawsOpaque);
+}
+function batchedPerObjectFrustumCulled(object, camera) {
+    if (!camera || camera.isArrayCamera === true)
+        return false;
+    return batchedOptionalBoolean(object.perObjectFrustumCulled, 'THREE.BatchedMesh.perObjectFrustumCulled', true);
+}
+function batchedSortObjects(object) {
+    return batchedOptionalBoolean(object.sortObjects, 'THREE.BatchedMesh.sortObjects', true);
+}
+function batchedCustomSort(object) {
+    if (object.customSort == null)
+        return null;
+    if (typeof object.customSort === 'function')
+        return object.customSort;
+    throw new TypeError('THREE.BatchedMesh.customSort must be a function or null.');
+}
+function customSortedBatchedMeshDraws(object, draws, customSort, camera) {
+    const drawByInstance = new Map(draws.map((draw) => [draw.instanceId, draw]));
+    const list = draws.map((draw) => ({
+        start: draw.range.start,
+        count: draw.range.count,
+        z: draw.z,
+        index: draw.instanceId,
+    }));
+    customSort.call(object, list, camera);
+    if (list.length !== draws.length) {
+        throw new Error(`THREE.BatchedMesh.customSort must keep ${draws.length} draw items; received ${list.length}.`);
+    }
+    const seenInstances = new Set();
+    return list.map((item, itemIndex) => {
+        if (!item || typeof item !== 'object') {
+            throw new TypeError(`THREE.BatchedMesh.customSort list[${itemIndex}] must be an object.`);
+        }
+        const instanceId = batchedNonNegativeInteger(item.index, `THREE.BatchedMesh.customSort list[${itemIndex}].index`);
+        if (seenInstances.has(instanceId)) {
+            throw new Error(`THREE.BatchedMesh.customSort returned duplicate instance index ${instanceId}.`);
+        }
+        seenInstances.add(instanceId);
+        const draw = drawByInstance.get(instanceId);
+        if (!draw) {
+            throw new Error(`THREE.BatchedMesh.customSort returned unknown instance index ${instanceId}.`);
+        }
+        return draw;
+    });
+}
+function compareBatchedDrawsOpaque(a, b) {
+    return a.z - b.z || a.instanceId - b.instanceId;
+}
+function compareBatchedDrawsTransparent(a, b) {
+    return b.z - a.z || a.instanceId - b.instanceId;
+}
+function batchedMeshUsesTransparentSort(object) {
+    const materials = Array.isArray(object.material)
+        ? object.material
+        : [object.material];
+    return materials.some((material) => material?.transparent === true || finitePositive(material?.transmission));
+}
+function batchedDrawDistanceZ(object, geometry, geometryId, range, transform, camera) {
+    if (!camera)
+        return 0;
+    const sphere = batchedGeometryBoundingSphere(object, geometry, geometryId, range);
+    if (!sphere)
+        return 0;
+    const center = transformPoint(transform, sphere.center);
+    const viewZ = viewSpaceZ(center, camera);
+    return Number.isFinite(viewZ) ? -viewZ : 0;
+}
+function batchedDrawSortIndex(base, drawOrder) {
+    return Math.max(0, Math.min(0xffffffff, base + drawOrder));
+}
+function batchedDrawOutsideFrustum(object, geometry, geometryId, range, transform, camera) {
+    const sphere = batchedGeometryBoundingSphere(object, geometry, geometryId, range);
+    if (!sphere)
+        return false;
+    return transformedSphereOutsideFrustum(camera, transform, sphere);
+}
+function batchedGeometryRange(object, geometry, geometryId) {
+    const cachedRange = object._geometryInfo?.[geometryId];
+    const cachedActive = cachedRange && typeof cachedRange === 'object' && !Array.isArray(cachedRange)
+        ? cachedRange.active
+        : null;
+    if (cachedActive != null && !batchedOptionalBoolean(cachedActive, `THREE.BatchedMesh._geometryInfo[${geometryId}].active`, true)) {
+        return { start: 0, count: 0 };
+    }
+    const range = typeof object.getGeometryRangeAt === 'function'
+        ? object.getGeometryRangeAt(geometryId, {})
+        : cachedRange ?? null;
+    if (!range || typeof range !== 'object') {
+        throw new Error(`THREE.BatchedMesh geometry range ${geometryId} is not readable. Use a real THREE.BatchedMesh or expand the batch before rendering.`);
+    }
+    const rawActive = range.active;
+    if (rawActive != null && !batchedOptionalBoolean(rawActive, `THREE.BatchedMesh._geometryInfo[${geometryId}].active`, true)) {
+        return { start: 0, count: 0 };
+    }
+    const startLabel = `THREE.BatchedMesh._geometryInfo[${geometryId}].start`;
+    const countLabel = `THREE.BatchedMesh._geometryInfo[${geometryId}].count`;
+    const start = batchedNonNegativeInteger(range.start, startLabel);
+    const count = batchedNonNegativeInteger(range.count, countLabel);
+    const limit = batchedGeometryRangeLimit(geometry);
+    if (start > limit) {
+        throw new RangeError(`${startLabel} must be less than or equal to packed geometry count (${limit}).`);
+    }
+    if (count > limit - start) {
+        throw new RangeError(`${countLabel} must fit within packed geometry count (${limit}) from start ${start}.`);
+    }
+    return { start, count };
+}
+function batchedGeometryRangeLimit(geometry) {
+    if (geometry.index)
+        return (0, attributes_1.attributeCount)(geometry.index, 'geometry.index');
+    const position = (0, attributes_1.getAttribute)(geometry, 'position');
+    return position ? (0, attributes_1.attributeCount)(position, 'geometry.attributes.position') : 0;
+}
+function batchedGeometryBoundingSphere(object, geometry, geometryId, range) {
+    const cached = object._geometryInfo?.[geometryId]?.boundingSphere;
+    if (cached != null) {
+        return batchedSphereLike(cached, `THREE.BatchedMesh._geometryInfo[${geometryId}].boundingSphere`);
+    }
+    const computed = batchedGeometryRangeBoundingSphere(geometry, range);
+    return computed ? batchedSphereLike(computed, `THREE.BatchedMesh._geometryInfo[${geometryId}].computedBoundingSphere`) : null;
+}
+function batchedSphereLike(sphere, label) {
+    return sphereLike(sphere, label);
+}
+function sphereLike(sphere, label) {
+    if (!sphere || typeof sphere !== 'object') {
+        throw new TypeError(`${label} must be a THREE.Sphere-like object.`);
+    }
+    const center = vec3Like(sphere.center);
+    if (!center) {
+        throw new TypeError(`${label}.center must be a finite Vector3-like value.`);
+    }
+    const radius = nonNegativeMaterialOrObjectNumber(sphere.radius, `${label}.radius`, 0);
+    return { center, radius };
+}
+function batchedGeometryView(geometry, range, cache) {
+    const signature = batchedGeometryViewSignature(geometry, range);
+    if (cache && signature.cacheable) {
+        let views = cache.batchedGeometryViews.get(geometry);
+        if (!views) {
+            views = new Map();
+            cache.batchedGeometryViews.set(geometry, views);
+        }
+        const key = batchedGeometryViewKey(range);
+        const cached = views.get(key);
+        if (cached && sameBatchedGeometryViewSignature(cached.signature, signature)) {
+            return cached.view;
+        }
+        const view = cached?.view ?? createBatchedGeometryView(geometry);
+        updateBatchedGeometryView(view, geometry, range);
+        views.set(key, { signature, view });
+        return view;
+    }
+    const view = createBatchedGeometryView(geometry);
+    updateBatchedGeometryView(view, geometry, range);
+    return view;
+}
+function createBatchedGeometryView(geometry) {
+    return Object.create(geometry);
+}
+function updateBatchedGeometryView(view, geometry, range) {
+    view.drawRange = { start: range.start, count: range.count };
+    view.boundingSphere = batchedGeometryRangeBoundingSphere(geometry, range);
+}
+function batchedGeometryViewSignature(geometry, range) {
+    const signature = {
+        cacheable: true,
+        geometryVersion: geometry.version,
+        rangeStart: range.start,
+        rangeCount: range.count,
+        position: attributeSignature((0, attributes_1.getAttribute)(geometry, 'position')),
+        index: attributeSignature(geometry.index),
+    };
+    signature.cacheable = attributeSignatureCacheable(signature.position)
+        && attributeSignatureCacheable(signature.index);
+    return signature;
+}
+function sameBatchedGeometryViewSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.geometryVersion === b.geometryVersion
+        && a.rangeStart === b.rangeStart
+        && a.rangeCount === b.rangeCount
+        && sameAttributeSignature(a.position, b.position)
+        && sameAttributeSignature(a.index, b.index);
+}
+function batchedGeometryViewKey(range) {
+    return `${range.start}:${range.count}`;
+}
+function batchedGeometryRangeBoundingSphere(geometry, range) {
+    const position = (0, attributes_1.getAttribute)(geometry, 'position');
+    if (!position || range.count <= 0)
+        return undefined;
+    const index = geometry.index ? (0, attributes_1.readIndexAttribute)(geometry.index, 'geometry.index', position.count) : null;
+    const start = Math.max(0, range.start);
+    const end = Math.max(start, range.start + range.count);
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    const vertexIndices = [];
+    for (let offset = start; offset < end; offset += 1) {
+        const vertexIndex = index ? index[offset] : offset;
+        if (!Number.isInteger(vertexIndex) || vertexIndex < 0 || vertexIndex >= position.count)
+            continue;
+        vertexIndices.push(vertexIndex);
+        const x = (0, attributes_1.attributeComponent)(position, vertexIndex, 0, 'geometry.attributes.position');
+        const y = (0, attributes_1.attributeComponent)(position, vertexIndex, 1, 'geometry.attributes.position');
+        const z = (0, attributes_1.attributeComponent)(position, vertexIndex, 2, 'geometry.attributes.position');
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        minZ = Math.min(minZ, z);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+        maxZ = Math.max(maxZ, z);
+    }
+    if (vertexIndices.length === 0)
+        return undefined;
+    const center = {
+        x: (minX + maxX) * 0.5,
+        y: (minY + maxY) * 0.5,
+        z: (minZ + maxZ) * 0.5,
+    };
+    let radiusSq = 0;
+    for (const vertexIndex of vertexIndices) {
+        const dx = (0, attributes_1.attributeComponent)(position, vertexIndex, 0, 'geometry.attributes.position') - center.x;
+        const dy = (0, attributes_1.attributeComponent)(position, vertexIndex, 1, 'geometry.attributes.position') - center.y;
+        const dz = (0, attributes_1.attributeComponent)(position, vertexIndex, 2, 'geometry.attributes.position') - center.z;
+        radiusSq = Math.max(radiusSq, dx * dx + dy * dy + dz * dz);
+    }
+    return { center, radius: Math.sqrt(radiusSq) };
+}
+function batchedInstanceMatrix(object, instanceId) {
+    const data = batchedTextureImageData(object._matricesTexture, 'THREE.BatchedMesh._matricesTexture', instanceId);
+    const offset = instanceId * 16;
+    if (typeof data.length !== 'number' || data.length < offset + 16) {
+        throw new Error(`THREE.BatchedMesh matrix texture is not readable for instance ${instanceId}. Use a real THREE.BatchedMesh or expand the batch before rendering.`);
+    }
+    const matrix = new Array(16);
+    for (let component = 0; component < 16; component += 1) {
+        matrix[component] = finiteArrayValue(data, offset + component, 'THREE.BatchedMesh._matricesTexture.image.data');
+    }
+    return matrix;
+}
+function batchedInstanceColor(object, instanceId) {
+    const texture = object._colorsTexture;
+    if (texture == null)
+        return undefined;
+    const data = batchedTextureImageData(texture, 'THREE.BatchedMesh._colorsTexture', instanceId);
+    const offset = instanceId * 4;
+    if (typeof data.length !== 'number' || data.length < offset + 4) {
+        throw new Error(`THREE.BatchedMesh color texture is not readable for instance ${instanceId}. Use a real THREE.BatchedMesh or expand the batch before rendering.`);
+    }
+    return [
+        finiteArrayValue(data, offset, 'THREE.BatchedMesh._colorsTexture.image.data'),
+        finiteArrayValue(data, offset + 1, 'THREE.BatchedMesh._colorsTexture.image.data'),
+        finiteArrayValue(data, offset + 2, 'THREE.BatchedMesh._colorsTexture.image.data'),
+        finiteArrayValue(data, offset + 3, 'THREE.BatchedMesh._colorsTexture.image.data'),
+    ];
+}
+function batchedTextureImageData(texture, label, instanceId) {
+    if (!texture || typeof texture !== 'object') {
+        throw new TypeError(`${label} must be a texture-like object for instance ${instanceId}.`);
+    }
+    const image = texture.image;
+    if (!image || typeof image !== 'object') {
+        throw new TypeError(`${label}.image must be an image-like object for instance ${instanceId}.`);
+    }
+    const data = image.data;
+    if (!data || typeof data !== 'object') {
+        throw new TypeError(`${label}.image.data must be an array-like object for instance ${instanceId}.`);
+    }
+    return data;
+}
+function batchedOptionalBoolean(value, label, fallback) {
+    if (value == null)
+        return fallback;
+    if (typeof value === 'boolean')
+        return value;
+    throw new TypeError(`${label} must be a boolean.`);
+}
+function batchedNonNegativeInteger(value, label) {
+    if (typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    throw new TypeError(`${label} must be a non-negative integer.`);
+}
+function finiteArrayValue(values, index, label) {
+    const value = values[index];
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    throw new TypeError(`${label}[${index}] must be a finite number.`);
+}
+function appendNumberArray(out, values) {
+    for (const value of values)
+        out.push(value);
+}
+function createDashedLineExpansion(uvs, uvs2, colors) {
+    return {
+        positions: [],
+        uvs: uvs ? [] : undefined,
+        uvs2: uvs2 ? [] : undefined,
+        colors: colors ? [] : undefined,
+    };
+}
+function cameraFrustumIntersectsSphere(camera, center, radius) {
+    const view = camera.matrixWorldInverse?.elements;
+    const projection = camera.projectionMatrix?.elements;
+    if (!view || view.length < 16 || !projection || projection.length < 16)
+        return true;
+    const viewProjection = multiplyMat4(projection, view);
+    const planes = [
+        [viewProjection[3] + viewProjection[0], viewProjection[7] + viewProjection[4], viewProjection[11] + viewProjection[8], viewProjection[15] + viewProjection[12]],
+        [viewProjection[3] - viewProjection[0], viewProjection[7] - viewProjection[4], viewProjection[11] - viewProjection[8], viewProjection[15] - viewProjection[12]],
+        [viewProjection[3] + viewProjection[1], viewProjection[7] + viewProjection[5], viewProjection[11] + viewProjection[9], viewProjection[15] + viewProjection[13]],
+        [viewProjection[3] - viewProjection[1], viewProjection[7] - viewProjection[5], viewProjection[11] - viewProjection[9], viewProjection[15] - viewProjection[13]],
+        [viewProjection[3] + viewProjection[2], viewProjection[7] + viewProjection[6], viewProjection[11] + viewProjection[10], viewProjection[15] + viewProjection[14]],
+        [viewProjection[3] - viewProjection[2], viewProjection[7] - viewProjection[6], viewProjection[11] - viewProjection[10], viewProjection[15] - viewProjection[14]],
+    ];
+    for (const [a, b, c, d] of planes) {
+        const length = Math.hypot(a, b, c);
+        if (!Number.isFinite(length) || length <= 1e-8)
+            continue;
+        const distance = (a * center[0] + b * center[1] + c * center[2] + d) / length;
+        if (distance < -radius)
+            return false;
+    }
+    return true;
+}
+function lineSegmentsWithDistances(positions, source, start, end, object, lineDistance) {
+    const count = end - start;
+    const segments = [];
+    if (count < 2)
+        return segments;
+    if (object.isLineSegments === true) {
+        let cumulative = 0;
+        const aligned = count - (count % 2);
+        for (let i = 0; i < aligned; i += 2) {
+            const a = source[start + i];
+            const b = source[start + i + 1];
+            const length = vertexDistance(positions, a, b);
+            const d0 = lineDistance ? (0, attributes_1.attributeComponent)(lineDistance, a, 0, 'geometry.attributes.lineDistance') : cumulative;
+            const d1 = lineDistance ? (0, attributes_1.attributeComponent)(lineDistance, b, 0, 'geometry.attributes.lineDistance') : d0 + length;
+            segments.push({ a, b, d0, d1 });
+            cumulative = d1;
+        }
+        return segments;
+    }
+    let previous = source[start];
+    let previousDistance = lineDistance ? (0, attributes_1.attributeComponent)(lineDistance, previous, 0, 'geometry.attributes.lineDistance') : 0;
+    for (let i = 1; i < count; i += 1) {
+        const current = source[start + i];
+        const length = vertexDistance(positions, previous, current);
+        const currentDistance = lineDistance ? (0, attributes_1.attributeComponent)(lineDistance, current, 0, 'geometry.attributes.lineDistance') : previousDistance + length;
+        segments.push({ a: previous, b: current, d0: previousDistance, d1: currentDistance });
+        previous = current;
+        previousDistance = currentDistance;
+    }
+    if (object.isLineLoop === true && count >= 2) {
+        const first = source[start];
+        segments.push({
+            a: previous,
+            b: first,
+            d0: previousDistance,
+            d1: lineDistance
+                ? (0, attributes_1.attributeComponent)(lineDistance, first, 0, 'geometry.attributes.lineDistance')
+                : previousDistance + vertexDistance(positions, previous, first),
+        });
+    }
+    return segments;
+}
+function appendDashedSegment(out, positions, uvs, uvs2, colors, segment, scale, dashSize, totalSize) {
+    const s0 = segment.d0 * scale;
+    const s1 = segment.d1 * scale;
+    const span = s1 - s0;
+    const direction = Math.sign(span);
+    if (Math.abs(span) <= 1e-6 || direction === 0)
+        return;
+    let cursor = s0;
+    let guard = 0;
+    while ((direction > 0 ? cursor < s1 - 1e-6 : cursor > s1 + 1e-6) && guard < 10000) {
+        guard += 1;
+        const cycle = Math.floor(cursor / totalSize);
+        const cycleStart = cycle * totalSize;
+        const inCycle = cursor - cycleStart;
+        const visible = inCycle <= dashSize;
+        const boundary = direction > 0
+            ? cycleStart + (visible ? dashSize : totalSize)
+            : cycleStart + (visible ? 0 : dashSize);
+        const next = direction > 0
+            ? Math.min(s1, boundary <= cursor + 1e-6 ? cursor + 1e-6 : boundary)
+            : Math.max(s1, boundary >= cursor - 1e-6 ? cursor - 1e-6 : boundary);
+        const hasVisibleSpan = direction > 0 ? next > cursor + 1e-6 : next < cursor - 1e-6;
+        if (visible && hasVisibleSpan) {
+            const t0 = (cursor - s0) / span;
+            const t1 = (next - s0) / span;
+            appendInterpolatedLine(out, positions, uvs, uvs2, colors, segment.a, segment.b, t0, t1);
+        }
+        cursor = next;
+    }
+}
+function appendInterpolatedLine(out, positions, uvs, uvs2, colors, a, b, t0, t1) {
+    appendInterpolatedAttribute(out.positions, positions, 3, a, b, t0);
+    appendInterpolatedAttribute(out.positions, positions, 3, a, b, t1);
+    if (out.uvs && uvs) {
+        appendInterpolatedAttribute(out.uvs, uvs, 2, a, b, t0);
+        appendInterpolatedAttribute(out.uvs, uvs, 2, a, b, t1);
+    }
+    if (out.uvs2 && uvs2) {
+        appendInterpolatedAttribute(out.uvs2, uvs2, 2, a, b, t0);
+        appendInterpolatedAttribute(out.uvs2, uvs2, 2, a, b, t1);
+    }
+    if (out.colors && colors) {
+        appendInterpolatedAttribute(out.colors, colors, 4, a, b, t0);
+        appendInterpolatedAttribute(out.colors, colors, 4, a, b, t1);
+    }
+}
+function appendInterpolatedAttribute(out, values, itemSize, a, b, t) {
+    const aBase = a * itemSize;
+    const bBase = b * itemSize;
+    for (let component = 0; component < itemSize; component += 1) {
+        const av = values[aBase + component];
+        const bv = values[bBase + component];
+        out.push(av + (bv - av) * t);
+    }
+}
+function vertexDistance(positions, a, b) {
+    const dx = positions[a * 3] - positions[b * 3];
+    const dy = positions[a * 3 + 1] - positions[b * 3 + 1];
+    const dz = positions[a * 3 + 2] - positions[b * 3 + 2];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function meshInstances(object, baseTransform, cache) {
+    if (object.isInstancedMesh !== true) {
+        return [{ transform: baseTransform }];
+    }
+    const instanceMatrix = object.instanceMatrix;
+    if (!instanceMatrix || instanceMatrix.count == null)
+        return [];
+    const instanceMatrixCount = (0, attributes_1.attributeCount)(instanceMatrix, 'InstancedMesh.instanceMatrix');
+    const count = (0, math_1.clampInteger)(integerCountOrDefault(object.count, 'InstancedMesh.count', instanceMatrixCount), 0, instanceMatrixCount);
+    const signature = instancedMeshSignature(object, instanceMatrix, count);
+    let localInstances;
+    if (cache && signature.cacheable) {
+        const cached = cache.instancedMeshes.get(object);
+        if (cached && sameInstancedMeshSignature(cached.signature, signature)) {
+            localInstances = cached.localInstances;
+        }
+    }
+    if (!localInstances) {
+        localInstances = readLocalInstancedMeshInstances(object, instanceMatrix, count);
+        if (cache && signature.cacheable) {
+            cache.instancedMeshes.set(object, { signature, localInstances });
+        }
+    }
+    return localInstances.map((instance) => ({
+        transform: multiplyMat4(baseTransform, instance.transform),
+        color: instance.color,
+    }));
+}
+function instancedMeshSignature(object, instanceMatrix, count) {
+    const signature = {
+        cacheable: true,
+        count,
+        instanceMatrix: attributeSignature(instanceMatrix),
+        instanceColor: attributeSignature(object.instanceColor),
+    };
+    signature.cacheable = attributeSignatureCacheable(signature.instanceMatrix)
+        && attributeSignatureCacheable(signature.instanceColor);
+    return signature;
+}
+function sameInstancedMeshSignature(a, b) {
+    return a.cacheable === b.cacheable
+        && a.count === b.count
+        && sameAttributeSignature(a.instanceMatrix, b.instanceMatrix)
+        && sameAttributeSignature(a.instanceColor, b.instanceColor);
+}
+function readLocalInstancedMeshInstances(object, instanceMatrix, count) {
+    const instances = new Array(count);
+    for (let i = 0; i < count; i += 1) {
+        instances[i] = {
+            transform: readMat4Attribute(instanceMatrix, i),
+            color: readInstanceColor(object.instanceColor, i),
+        };
+    }
+    return instances;
+}
+function readMat4Attribute(attribute, index) {
+    if (!attribute)
+        return math_1.IDENTITY_4X4.slice();
+    const matrix = new Array(16);
+    for (let component = 0; component < 16; component += 1) {
+        matrix[component] = (0, attributes_1.attributeComponent)(attribute, index, component, 'InstancedMesh.instanceMatrix');
+    }
+    return matrix;
+}
+function readInstanceColor(attribute, index) {
+    if (!attribute || index >= (0, attributes_1.attributeCount)(attribute, 'InstancedMesh.instanceColor'))
+        return undefined;
+    return [
+        (0, attributes_1.attributeComponent)(attribute, index, 0, 'InstancedMesh.instanceColor'),
+        (0, attributes_1.attributeComponent)(attribute, index, 1, 'InstancedMesh.instanceColor'),
+        (0, attributes_1.attributeComponent)(attribute, index, 2, 'InstancedMesh.instanceColor'),
+        attribute.itemSize && attribute.itemSize >= 4 ? (0, attributes_1.attributeComponent)(attribute, index, 3, 'InstancedMesh.instanceColor') : 1,
+    ];
+}
+function instanceColor(baseColor, instance) {
+    if (!instance.color)
+        return baseColor;
+    return [
+        baseColor[0] * instance.color[0],
+        baseColor[1] * instance.color[1],
+        baseColor[2] * instance.color[2],
+        baseColor[3] * instance.color[3],
+    ];
+}
+function multiplyMat4(a, b) {
+    const out = new Array(16);
+    for (let col = 0; col < 4; col += 1) {
+        for (let row = 0; row < 4; row += 1) {
+            out[col * 4 + row] =
+                a[row] * b[col * 4]
+                    + a[4 + row] * b[col * 4 + 1]
+                    + a[8 + row] * b[col * 4 + 2]
+                    + a[12 + row] * b[col * 4 + 3];
+        }
+    }
+    return out;
+}
 function rangeIndices(count) {
     const out = new Array(count);
     for (let i = 0; i < count; i++)