dex; } reset() { this.list.length = 0; this.index = 0; } } const _matrix$1 = /*@__PURE__*/ new Matrix4(); const _whiteColor = /*@__PURE__*/ new Color( 1, 1, 1 ); const _frustum = /*@__PURE__*/ new Frustum(); const _frustumArray = /*@__PURE__*/ new FrustumArray(); const _box$1 = /*@__PURE__*/ new Box3(); const _sphere$2 = /*@__PURE__*/ new Sphere(); const _vector$5 = /*@__PURE__*/ new Vector3(); const _forward$1 = /*@__PURE__*/ new Vector3(); const _temp = /*@__PURE__*/ new Vector3(); const _renderList = /*@__PURE__*/ new MultiDrawRenderList(); const _mesh = /*@__PURE__*/ new Mesh(); const _batchIntersects = []; // copies data from attribute "src" into "target" starting at "targetOffset" function copyAttributeData( src, target, targetOffset = 0 ) { const itemSize = target.itemSize; if ( src.isInterleavedBufferAttribute || src.array.constructor !== target.array.constructor ) { // use the component getters and setters if the array data cannot // be copied directly const vertexCount = src.count; for ( let i = 0; i < vertexCount; i ++ ) { for ( let c = 0; c < itemSize; c ++ ) { target.setComponent( i + targetOffset, c, src.getComponent( i, c ) ); } } } else { // faster copy approach using typed array set function target.array.set( src.array, targetOffset * itemSize ); } target.needsUpdate = true; } // safely copies array contents to a potentially smaller array function copyArrayContents( src, target ) { if ( src.constructor !== target.constructor ) { // if arrays are of a different type (eg due to index size increasing) then data must be per-element copied const len = Math.min( src.length, target.length ); for ( let i = 0; i < len; i ++ ) { target[ i ] = src[ i ]; } } else { // if the arrays use the same data layout we can use a fast block copy const len = Math.min( src.length, target.length ); target.set( new src.constructor( src.buffer, 0, len ) ); } } /** * A special version of a mesh with multi draw batch rendering support. Use * this class if you have to render a large number of objects with the same * material but with different geometries or world transformations. The usage of * `BatchedMesh` will help you to reduce the number of draw calls and thus improve the overall * rendering performance in your application. * * ```js * const box = new THREE.BoxGeometry( 1, 1, 1 ); * const sphere = new THREE.SphereGeometry( 1, 12, 12 ); * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } ); * * // initialize and add geometries into the batched mesh * const batchedMesh = new BatchedMesh( 10, 5000, 10000, material ); * const boxGeometryId = batchedMesh.addGeometry( box ); * const sphereGeometryId = batchedMesh.addGeometry( sphere ); * * // create instances of those geometries * const boxInstancedId1 = batchedMesh.addInstance( boxGeometryId ); * const boxInstancedId2 = batchedMesh.addInstance( boxGeometryId ); * * const sphereInstancedId1 = batchedMesh.addInstance( sphereGeometryId ); * const sphereInstancedId2 = batchedMesh.addInstance( sphereGeometryId ); * * // position the geometries * batchedMesh.setMatrixAt( boxInstancedId1, boxMatrix1 ); * batchedMesh.setMatrixAt( boxInstancedId2, boxMatrix2 ); * * batchedMesh.setMatrixAt( sphereInstancedId1, sphereMatrix1 ); * batchedMesh.setMatrixAt( sphereInstancedId2, sphereMatrix2 ); * * scene.add( batchedMesh ); * ``` * * @augments Mesh */ class BatchedMesh extends Mesh { /** * Constructs a new batched mesh. * * @param {number} maxInstanceCount - The maximum number of individual instances planned to be added and rendered. * @param {number} maxVertexCount - The maximum number of vertices to be used by all unique geometries. * @param {number} [maxIndexCount=maxVertexCount*2] - The maximum number of indices to be used by all unique geometries * @param {Material|Array} [material] - The mesh material. */ constructor( maxInstanceCount, maxVertexCount, maxIndexCount = maxVertexCount * 2, material ) { super( new BufferGeometry(), material ); /** * This flag can be used for type testing. * * @type {boolean} * @readonly * @default true */ this.isBatchedMesh = true; /** * When set ot `true`, the individual objects of a batch are frustum culled. * * @type {boolean} * @default true */ this.perObjectFrustumCulled = true; /** * When set to `true`, the individual objects of a batch are sorted to improve overdraw-related artifacts. * If the material is marked as "transparent" objects are rendered back to front and if not then they are * rendered front to back. * * @type {boolean} * @default true */ this.sortObjects = true; /** * The bounding box of the batched mesh. Can be computed via {@link BatchedMesh#computeBoundingBox}. * * @type {?Box3} * @default null */ this.boundingBox = null;