@expofp/renderer 0.0.0-experimental.2d6c681

package/dist/core/SquareDataTexture.js

@@ -0,0 +1,476 @@
+import { ColorManagement, DataTexture, FloatType, IntType, NoColorSpace, RedFormat, RedIntegerFormat, RGBAFormat, RGBAIntegerFormat, RGFormat, RGIntegerFormat, Source, UnsignedIntType, WebGLUtils, } from 'three';
+import { createLogger } from '../utils/logging';
+import { resizeTypedArray } from './typed-array';
+const logger = createLogger('square-data-texture');
+/**
+ * Calculates the square texture size based on the capacity and pixels per instance, so the texture
+ * is large enough to store every instance in a square layout.
+ * @param capacity - The maximum number of instances allowed in the texture.
+ * @param pixelsPerInstance - The number of pixels required for each instance.
+ * @returns The size of the square texture needed to store all the instances.
+ */
+export function getSquareTextureSize(capacity, pixelsPerInstance) {
+    return Math.max(pixelsPerInstance, Math.ceil(Math.sqrt(capacity / pixelsPerInstance)) * pixelsPerInstance);
+}
+/**
+ * Generates texture information (size, format, type) for a square texture.
+ * @param arrayType - The constructor for the TypedArray.
+ * @param channels - The number of channels in the texture.
+ * @param pixelsPerInstance - The number of pixels required for each instance.
+ * @param capacity - The maximum number of instances allowed in the texture.
+ * @returns An object containing the texture's array, size, format, and data type.
+ */
+export function getSquareTextureInfo(arrayType, channels, pixelsPerInstance, capacity) {
+    if (channels === 3) {
+        logger.warn('"channels" cannot be 3. Set to 4. More info: https://github.com/mrdoob/three.js/pull/23228');
+        channels = 4;
+    }
+    const size = getSquareTextureSize(capacity, pixelsPerInstance);
+    const array = new arrayType(size * size * channels);
+    const isFloat = arrayType.name.includes('Float');
+    const isUnsignedInt = arrayType.name.includes('Uint');
+    const type = isFloat ? FloatType : isUnsignedInt ? UnsignedIntType : IntType;
+    let format;
+    switch (channels) {
+        case 1:
+            format = isFloat ? RedFormat : RedIntegerFormat;
+            break;
+        case 2:
+            format = isFloat ? RGFormat : RGIntegerFormat;
+            break;
+        default:
+            format = isFloat ? RGBAFormat : RGBAIntegerFormat;
+            break;
+    }
+    return { array, size, type, format };
+}
+/**
+ * A `DataTexture` laid out as a square grid of per-instance records, with partial row uploads and
+ * per-instance uniforms addressed by instance id.
+ *
+ * Vendored from three.ez, which ships two near-identical copies of this file — one per package —
+ * and we would otherwise bundle both:
+ * - {@link https://github.com/agargaro/batched-mesh-extensions/blob/master/src/core/SquareDataTexture.ts | batched-mesh-extensions}
+ * - {@link https://github.com/agargaro/instanced-mesh/blob/master/src/core/utils/SquareDataTexture.ts | instanced-mesh}
+ *
+ * This is the batched-mesh-extensions version, the later of the two: its `update` hands whole-texture
+ * uploads back to three instead of hand-binding a texture unit, which drops `bindToProgram`,
+ * `getSlot`, `updateFull` and `updatePartial` along with the `?? maxTextures - 1` slot guess the
+ * instanced-mesh copy still carries.
+ *
+ * Three deliberate departures from both originals:
+ *
+ * 1. **No `flat` on the varyings.** With flat shading a fragment takes its value from the
+ *    primitive's *provoking* vertex, and WebGL's default last-vertex convention is the expensive one
+ *    for drivers — which is why upstream wants `WEBGL_provoking_vertex` enabled. Every value here is
+ *    per-instance and therefore identical across a primitive's vertices, so interpolating instead of
+ *    flat-shading yields the same result and needs no extension.
+ * 2. **The index varying is always `float`**, so `getUniformsGLSL` no longer takes an index type.
+ *    It follows from the first: GLSL ES 3.00 requires integer varyings to be `flat`, so an index
+ *    that is not float could not have the qualifier removed. **Callers must therefore hand it a float
+ *    index** — `BatchedMeshImpl` does, from three's own `getIndirectIndex( gl_DrawID )`, and
+ *    `InstancedMeshImpl` does, from the float index texture that replaced upstream's `uint` attribute.
+ * 3. **`clone` and `copy` produce an independent texture.** See each method.
+ */
+export class SquareDataTexture extends DataTexture {
+    /**
+     * Whether to enable partial texture updates by row. If `false`, the entire texture is updated.
+     * @default true
+     */
+    partialUpdate = true;
+    /**
+     * The maximum number of update calls per frame. Past it, the whole texture is re-uploaded instead.
+     * @default Infinity
+     */
+    maxUpdateCalls = Infinity;
+    /** Format/type conversion helper, built on first upload. */
+    _utils = null;
+    /** Whether any row has been marked since the last upload. */
+    _needsUpdate = false;
+    /** Width at the last upload, used to notice a resize; `null` until the first one. */
+    _lastWidth = null;
+    /** The typed array backing the texture. */
+    _data;
+    /** Elements per pixel. */
+    _channels;
+    /** Pixels each instance occupies. */
+    _pixelsPerInstance;
+    /** Elements each instance occupies. */
+    _stride;
+    /** Rows marked dirty for the next partial upload. */
+    _rowToUpdate;
+    /** Reused pool of dirty-row ranges, refilled each upload so a frame allocates nothing. */
+    _rowRanges = [];
+    /** Uniform layout, shared with whoever built the schema. */
+    _uniformMap;
+    /** Whether uniforms are fetched in the fragment shader rather than passed as varyings. */
+    _fetchUniformsInFragmentShader;
+    /**
+     * The backing typed array. An instanced mesh reads and writes its matrix and color data through
+     * it directly, the way three's own `InstancedMesh` writes its instance attributes — a per-instance
+     * accessor would be pure overhead on that hot path. Pair a write with {@link enqueueUpdate} so the
+     * row is re-uploaded.
+     * @returns The array.
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * @param arrayType - The constructor for the TypedArray.
+     * @param channels - The number of channels in the texture.
+     * @param pixelsPerInstance - The number of pixels required for each instance.
+     * @param capacity - The total number of instances.
+     * @param uniformMap - Optional map for handling uniform values.
+     * @param fetchInFragmentShader - Optional flag that determines if uniform values should be fetched
+     *   in the fragment shader instead of the vertex shader.
+     */
+    constructor(arrayType, channels, pixelsPerInstance, capacity, uniformMap, fetchInFragmentShader) {
+        if (channels === 3)
+            channels = 4;
+        const { array, format, size, type } = getSquareTextureInfo(arrayType, channels, pixelsPerInstance, capacity);
+        super(array, size, size, format, type);
+        this._data = array;
+        this._channels = channels;
+        this._pixelsPerInstance = pixelsPerInstance;
+        this._stride = pixelsPerInstance * channels;
+        this._rowToUpdate = new Array(size);
+        this._uniformMap = uniformMap;
+        this._fetchUniformsInFragmentShader = fetchInFragmentShader;
+        this.needsUpdate = true; // necessary to init texture
+    }
+    /**
+     * Resizes the texture to accommodate a new number of instances.
+     * @param count - The new total number of instances.
+     */
+    resize(count) {
+        const size = getSquareTextureSize(count, this._pixelsPerInstance);
+        if (size === this.image.width)
+            return;
+        this._rowToUpdate.length = size;
+        const data = resizeTypedArray(this._data, size * size * this._channels);
+        this.dispose();
+        this.image = { data, height: size, width: size };
+        this._data = data;
+    }
+    /**
+     * Marks a row of the texture for update during the next render cycle, so only rows that changed
+     * are re-uploaded.
+     * @param index - The index of the instance to update.
+     */
+    enqueueUpdate(index) {
+        this._needsUpdate = true;
+        if (!this.partialUpdate)
+            return;
+        const elementsPerRow = this.image.width / this._pixelsPerInstance;
+        const rowIndex = Math.floor(index / elementsPerRow);
+        this._rowToUpdate[rowIndex] = true;
+    }
+    /**
+     * Uploads whatever changed since the last frame, a row range at a time.
+     *
+     * Defers to three's own full upload whenever it is going to happen anyway — before the texture
+     * exists, after a resize, or when the version moved — and whenever the dirty rows are so scattered
+     * that `maxUpdateCalls` would be exceeded.
+     * @param renderer - The renderer to upload through.
+     */
+    update(renderer) {
+        const textureProperties = renderer.properties.get(this);
+        const versionChanged = this.version > 0 && textureProperties.__version !== this.version;
+        const sizeChanged = this._lastWidth !== null && this._lastWidth !== this.image.width;
+        if (!this._needsUpdate || !textureProperties.__webglTexture || versionChanged || sizeChanged) {
+            this._lastWidth = this.image.width;
+            this._needsUpdate = false;
+            return;
+        }
+        this._needsUpdate = false;
+        if (!this.partialUpdate) {
+            this.needsUpdate = true; // three.js will update the whole texture
+            return;
+        }
+        const rangeCount = this.collectDirtyRanges();
+        if (rangeCount === 0)
+            return;
+        if (rangeCount > this.maxUpdateCalls) {
+            this.needsUpdate = true; // three.js will update the whole texture
+        }
+        else {
+            this.updateRows(textureProperties.__webglTexture, renderer, rangeCount);
+        }
+        this._rowToUpdate.fill(false);
+    }
+    /**
+     * Sets a uniform value at the specified instance ID in the texture.
+     * @param id - The instance ID to set the uniform for.
+     * @param name - The name of the uniform.
+     * @param value - The value to set for the uniform.
+     */
+    setUniformAt(id, name, value) {
+        const { offset, size } = this._uniformMap.get(name);
+        const stride = this._stride;
+        if (size === 1) {
+            this._data[id * stride + offset] = value;
+        }
+        else {
+            value.toArray(this._data, id * stride + offset);
+        }
+    }
+    /**
+     * Retrieves a uniform value at the specified instance ID from the texture.
+     * @param id - The instance ID to retrieve the uniform from.
+     * @param name - The name of the uniform.
+     * @param target - Optional target object to store the uniform value.
+     * @returns The uniform value for the specified instance.
+     */
+    getUniformAt(id, name, target) {
+        const { offset, size } = this._uniformMap.get(name);
+        const stride = this._stride;
+        if (size === 1)
+            return this._data[id * stride + offset];
+        return target.fromArray(this._data, id * stride + offset);
+    }
+    /**
+     * Generates the GLSL for reading this texture's uniforms.
+     *
+     * The index varying is `float` and has no index-type parameter, because these varyings carry no
+     * `flat` qualifier — see the class docs. `indexName` must name a float in the shader.
+     * @param textureName - The name of the texture in the GLSL shader.
+     * @param indexName - The name of the index in the GLSL shader.
+     * @returns What each stage declares and what it runs first; see {@link UniformsStageGLSL}.
+     */
+    getUniformsGLSL(textureName, indexName) {
+        return {
+            vertex: this.getUniformsVertexGLSL(textureName, indexName),
+            fragment: this.getUniformsFragmentGLSL(textureName, indexName),
+        };
+    }
+    /**
+     * Copies another texture's pixels and layout, leaving nothing shared between the two.
+     *
+     * Both originals assign `_rowToUpdate` by reference and inherit `Texture.copy`'s by-reference
+     * `source`, so a copy and its original wrote through into each other's pixels and marked each
+     * other's rows dirty. Only `_uniformMap` stays shared, which is safe: it is the layout descriptor
+     * built once from the schema and never mutated.
+     * @param source - The texture to copy.
+     * @returns `this`.
+     */
+    copy(source) {
+        super.copy(source);
+        this.partialUpdate = source.partialUpdate;
+        this.maxUpdateCalls = source.maxUpdateCalls;
+        this._channels = source._channels;
+        this._pixelsPerInstance = source._pixelsPerInstance;
+        this._stride = source._stride;
+        this._rowToUpdate = [...source._rowToUpdate];
+        this._uniformMap = source._uniformMap;
+        this._fetchUniformsInFragmentShader = source._fetchUniformsInFragmentShader;
+        const data = source._data.slice();
+        const { width, height } = source.image;
+        this.source = new Source({ data, width, height });
+        this._data = data;
+        this.needsUpdate = true;
+        return this;
+    }
+    /**
+     * Duplicates the texture.
+     *
+     * Neither original overrides this, so three's `Texture.clone` ran `new this.constructor()` with no
+     * arguments — and this constructor derives its size, format and typed array from those arguments,
+     * so the inherited clone always threw, taking every `copy` of an owning mesh down with it.
+     * @returns The independent copy.
+     */
+    clone() {
+        // Reconstructed from the layout rather than the arguments, which are not retained. Capacity is
+        // recoverable because `getSquareTextureSize` rounds the edge up to a multiple of
+        // `pixelsPerInstance`, making `size² / pixelsPerInstance` the capacity that reproduces this size.
+        const size = this.image.width;
+        const Constructor = this.constructor;
+        const clone = new Constructor(this._data.constructor, this._channels, this._pixelsPerInstance, (size * size) / this._pixelsPerInstance, this._uniformMap, this._fetchUniformsInFragmentShader);
+        return clone.copy(this);
+    }
+    /**
+     * Groups the dirty rows into contiguous ranges, so neighbors upload in one call. Fills the reused
+     * {@link _rowRanges} pool — growing it only when a frame has more ranges than ever before — rather
+     * than allocating a fresh array and range objects every frame.
+     * @returns How many ranges were written to the pool.
+     */
+    collectDirtyRanges() {
+        const rowsToUpdate = this._rowToUpdate;
+        const ranges = this._rowRanges;
+        let rangeCount = 0;
+        for (let i = 0, l = rowsToUpdate.length; i < l; i++) {
+            if (!rowsToUpdate[i])
+                continue;
+            const row = i;
+            while (i < l && rowsToUpdate[i])
+                i++;
+            const range = (ranges[rangeCount] ??= { row: 0, count: 0 });
+            range.row = row;
+            range.count = i - row;
+            rangeCount++;
+        }
+        return rangeCount;
+    }
+    /**
+     * Uploads the given row ranges with `texSubImage2D`.
+     * @param webglTexture - The uploaded texture to write into.
+     * @param renderer - The renderer to upload through.
+     * @param rangeCount - How many of the pooled {@link _rowRanges} to upload.
+     */
+    updateRows(webglTexture, renderer, rangeCount) {
+        const state = renderer.state;
+        const gl = renderer.getContext();
+        this._utils ??= new WebGLUtils(gl, renderer.extensions);
+        const glFormat = this._utils.convert(this.format);
+        const glType = this._utils.convert(this.type);
+        const { data, width } = this.image;
+        const channels = this._channels;
+        state.bindTexture(gl.TEXTURE_2D, webglTexture);
+        const workingPrimaries = ColorManagement.getPrimaries(ColorManagement.workingColorSpace);
+        const texturePrimaries = this.colorSpace === NoColorSpace ? null : ColorManagement.getPrimaries(this.colorSpace);
+        const unpackConversion = this.colorSpace === NoColorSpace || workingPrimaries === texturePrimaries
+            ? gl.NONE
+            : gl.BROWSER_DEFAULT_WEBGL;
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this.flipY);
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, this.premultiplyAlpha);
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, this.unpackAlignment);
+        gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion);
+        for (let i = 0; i < rangeCount; i++) {
+            const { row, count } = this._rowRanges[i];
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, row, width, count, glFormat, glType, data, row * width * channels);
+        }
+        this.onUpdate?.(this);
+    }
+    /**
+     * The vertex stage's share: either the whole fetch plus the varyings it feeds, or — when uniforms
+     * are read in the fragment shader — just the index handed across.
+     * @param textureName - The sampler name.
+     * @param indexName - The per-instance index available in the vertex shader; must be a float.
+     * @returns What the stage declares and what it runs first.
+     */
+    getUniformsVertexGLSL(textureName, indexName) {
+        if (this._fetchUniformsInFragmentShader) {
+            return {
+                declarations: `varying float ${VARYING_PREFIX}${indexName};`,
+                body: `${VARYING_PREFIX}${indexName} = ${indexName};`,
+            };
+        }
+        const texelsFetch = this.texelsFetchGLSL(textureName, indexName);
+        const getFromTexels = this.getFromTexelsGLSL();
+        const { assignVarying, declareVarying } = this.getVarying();
+        return {
+            declarations: `
+        uniform highp sampler2D ${textureName};
+        ${declareVarying}`,
+            body: `
+        ${texelsFetch}
+        ${getFromTexels}
+        ${assignVarying}`,
+        };
+    }
+    /**
+     * The fragment stage's share: either the varyings the vertex shader filled, or the fetch itself.
+     * @param textureName - The sampler name.
+     * @param indexName - The per-instance index carried across as a varying.
+     * @returns What the stage declares and what it runs first.
+     */
+    getUniformsFragmentGLSL(textureName, indexName) {
+        if (!this._fetchUniformsInFragmentShader) {
+            const { declareVarying, getVarying } = this.getVarying();
+            return { declarations: declareVarying, body: getVarying };
+        }
+        const texelsFetch = this.texelsFetchGLSL(textureName, `${VARYING_PREFIX}${indexName}`);
+        const getFromTexels = this.getFromTexelsGLSL();
+        return {
+            declarations: `
+        uniform highp sampler2D ${textureName};
+        varying float ${VARYING_PREFIX}${indexName};`,
+            body: `
+        ${texelsFetch}
+        ${getFromTexels}`,
+        };
+    }
+    /**
+     * GLSL fetching every texel one instance occupies.
+     * @param textureName - The sampler name.
+     * @param indexName - The instance index expression.
+     * @returns The GLSL statements.
+     */
+    texelsFetchGLSL(textureName, indexName) {
+        const pixelsPerInstance = this._pixelsPerInstance;
+        let texelsFetch = `
+      int size = textureSize(${textureName}, 0).x;
+      int j = int(${indexName}) * ${pixelsPerInstance};
+      int x = j % size;
+      int y = j / size;
+    `;
+        for (let i = 0; i < pixelsPerInstance; i++) {
+            texelsFetch += `vec4 ${TEXEL_PREFIX}${i} = texelFetch(${textureName}, ivec2(x + ${i}, y), 0);\n`;
+        }
+        return texelsFetch;
+    }
+    /**
+     * GLSL unpacking each uniform out of the fetched texels.
+     * @returns The GLSL declarations.
+     */
+    getFromTexelsGLSL() {
+        const uniforms = this._uniformMap;
+        let fromTexels = '';
+        for (const [name, { type, offset, size }] of uniforms) {
+            const tId = Math.floor(offset / this._channels);
+            const id = (offset = 0) => `${TEXEL_PREFIX}${tId + offset}`;
+            if (type === 'mat3') {
+                fromTexels += `mat3 ${name} = mat3(${id()}.rgb, vec3(${id()}.a, ${id(1)}.rg), vec3(${id(1)}.ba, ${id(2)}.r));`;
+            }
+            else if (type === 'mat4') {
+                fromTexels += `mat4 ${name} = mat4(${id()}, ${id(1)}, ${id(2)}, ${id(3)});`;
+            }
+            else {
+                const components = this.getUniformComponents(offset, size);
+                fromTexels += `${type} ${name} = ${id()}.${components};`;
+            }
+            fromTexels += '\n';
+        }
+        return fromTexels;
+    }
+    /**
+     * The varying declarations carrying each uniform from vertex to fragment stage.
+     *
+     * No `flat` qualifier, unlike both originals — see the class docs.
+     * @returns The declaration, assignment and read snippets.
+     */
+    getVarying() {
+        const uniforms = this._uniformMap;
+        let declareVarying = '';
+        let assignVarying = '';
+        let getVarying = '';
+        for (const [name, { type }] of uniforms) {
+            declareVarying += `varying ${type} ${VARYING_PREFIX}${name};\n`;
+            assignVarying += `${VARYING_PREFIX}${name} = ${name};\n`;
+            getVarying += `${type} ${name} = ${VARYING_PREFIX}${name};\n`;
+        }
+        return { declareVarying, assignVarying, getVarying };
+    }
+    /**
+     * The swizzle selecting a uniform's components out of its texel.
+     * @param offset - The uniform's element offset within an instance.
+     * @param size - How many elements it spans.
+     * @returns The component swizzle, such as `rgb`.
+     */
+    getUniformComponents(offset, size) {
+        const startIndex = offset % this._channels;
+        let components = '';
+        for (let i = 0; i < size; i++) {
+            components += COMPONENTS_ARRAY[startIndex + i];
+        }
+        return components;
+    }
+}
+/**
+ * Prefix for the varyings carrying uniforms across shader stages. Namespaced so a generated name
+ * cannot collide with anything three or a patched material declares.
+ */
+const VARYING_PREFIX = 'efp_f';
+/** Prefix for the locals holding an instance's fetched texels. */
+const TEXEL_PREFIX = 'efp_texel';
+/** The channel letters a uniform's components are swizzled out of. */
+const COMPONENTS_ARRAY = ['r', 'g', 'b', 'a'];

package/dist/core/batch/BatchedMesh.d.ts

@@ -0,0 +1,74 @@
+import { BatchedMesh as BatchedMeshBase, type BufferGeometry, type Camera, type Group, type Intersection, type Material, type Matrix4, type Raycaster, type Scene, type WebGLRenderer } from 'three';
+import { type UniformSchemaShader } from '../InstanceUniforms';
+import { type UniformValue, type UniformValueObj } from '../SquareDataTexture';
+/**
+ * Three's `BatchedMesh` with per-instance uniforms, backed by a {@link SquareDataTexture}.
+ *
+ * Ported from three.ez's batched-mesh-extensions, which supplies this as prototype patches over
+ * `BatchedMesh` rather than a subclass:
+ * {@link https://github.com/agargaro/batched-mesh-extensions/blob/master/src/core/feature/Uniforms.ts | Uniforms}
+ * and
+ * {@link https://github.com/agargaro/batched-mesh-extensions/blob/master/src/patch/PatchBatchedMeshMaterial.ts | PatchBatchedMeshMaterial}.
+ * Only the uniform feature is taken: BVH, raycasting, LOD and per-object frustum culling are left
+ * behind, since the 2D layers draw every instance and pick through their own tables.
+ *
+ * Two departures from upstream:
+ *
+ * - **Uniforms are added, not initialized once** — see {@link addUniforms} and
+ *   {@link InstanceUniforms}.
+ * - **Bounds invalidate themselves.** Every mutation that can move the mesh's extents nulls the
+ *   cached bounds, so callers cannot forget; three's frustum test recomputes a null one on demand.
+ */
+export declare class BatchedMeshImpl extends BatchedMeshBase {
+    /** Per-instance uniform store, shared with {@link InstancedMeshImpl}. */
+    private readonly uniforms;
+    /** The material whose `onBeforeCompile` is already wrapped, so it is wrapped exactly once. */
+    private patchedMaterial;
+    /**
+     * Declares per-instance uniforms, merging with any already declared and rebuilding the backing
+     * texture (existing values carried across). See {@link InstanceUniforms.add}.
+     * @param schema - The uniforms to add.
+     */
+    addUniforms(schema: UniformSchemaShader): void;
+    /**
+     * Reads one instance's uniform.
+     * @param id - The instance to read.
+     * @param name - The uniform's name.
+     * @param target - Receives the result; unused for a `float`, which is returned directly.
+     * @returns The value.
+     */
+    getUniformAt(id: number, name: string, target?: UniformValueObj): UniformValue;
+    /**
+     * Writes one instance's uniform and marks its row for upload.
+     * @param id - The instance to write.
+     * @param name - The uniform's name.
+     * @param value - The value to write.
+     */
+    setUniformAt(id: number, name: string, value: UniformValue): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+    onBeforeRender(renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: Group): void;
+    addInstance(geometryId: number): number;
+    deleteInstance(instanceId: number): this;
+    setMatrixAt(instanceId: number, matrix: Matrix4): this;
+    setInstanceCount(maxInstanceCount: number): void;
+    dispose(): void;
+    /**
+     * Nulls the cached bounds so the next frustum test recomputes them. Kept here rather than at the
+     * call sites: every mutation that moves an instance goes through one of the overrides above.
+     */
+    private invalidateBounds;
+    /**
+     * Wraps the current material's `onBeforeCompile` so compiled programs can read the uniform
+     * texture, once per material.
+     *
+     * Deferred to render time rather than done when uniforms are declared, because the material is
+     * usually attached after the mesh is constructed — R3F mounts it as a child element.
+     */
+    private patchMaterial;
+}
+/**
+ * Registers the class as an R3F element, by value so the generated key cannot collide with the
+ * `BatchedMesh` three already puts in the catalog when the canvas mounts.
+ */
+export declare const BatchedMesh: import("react").ExoticComponent<import("@react-three/fiber/dist/declarations/src/core/utils").Mutable<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<Partial<import("@react-three/fiber/dist/declarations/src/core/utils").Overwrite<BatchedMeshImpl, import("@react-three/fiber").MathProps<BatchedMeshImpl> & import("@react-three/fiber").ReactProps<BatchedMeshImpl> & Partial<import("@react-three/fiber").EventHandlers>>>, Omit<import("@react-three/fiber").InstanceProps<BatchedMeshImpl, typeof BatchedMeshImpl>, "object">>>>;
+//# sourceMappingURL=BatchedMesh.d.ts.map