import { InstancedBufferAttribute } from '../core/InstancedBufferAttribute.js';

import { Mesh } from './Mesh.js';

import { Matrix4 } from '../math/Matrix4.js';

const _instanceLocalMatrix = /*@__PURE__*/ new Matrix4();

const _instanceWorldMatrix = /*@__PURE__*/ new Matrix4();

const _instanceIntersects = [];

const _mesh = /*@__PURE__*/ new Mesh();

class InstancedMesh extends Mesh {

constructor( geometry, material, count ) {

super( geometry, material );

this.instanceMatrix = new InstancedBufferAttribute( new Float32Array( count * 16 ), 16 );

this.instanceColor = null;

this.count = count;

this.frustumCulled = false;

}

copy( source ) {

super.copy( source );

this.instanceMatrix.copy( source.instanceMatrix );

if ( source.instanceColor !== null ) this.instanceColor = source.instanceColor.clone();

this.count = source.count;

return this;

}

getColorAt( index, color ) {

color.fromArray( this.instanceColor.array, index * 3 );

}

getMatrixAt( index, matrix ) {

matrix.fromArray( this.instanceMatrix.array, index * 16 );

}

raycast( raycaster, intersects ) {

const matrixWorld = this.matrixWorld;

const raycastTimes = this.count;

_mesh.geometry = this.geometry;

_mesh.material = this.material;

if ( _mesh.material === undefined ) return;

for ( let instanceId = 0; instanceId < raycastTimes; instanceId ++ ) {

// calculate the world matrix for each instance

this.getMatrixAt( instanceId, _instanceLocalMatrix );

_instanceWorldMatrix.multiplyMatrices( matrixWorld, _instanceLocalMatrix );

// the mesh represents this single instance

_mesh.matrixWorld = _instanceWorldMatrix;

_mesh.raycast( raycaster, _instanceIntersects );

// process the result of raycast

for ( let i = 0, l = _instanceIntersects.length; i < l; i ++ ) {

const intersect = _instanceIntersects[ i ];

intersect.instanceId = instanceId;

intersect.object = this;

intersects.push( intersect );

}

_instanceIntersects.length = 0;

}

}

setColorAt( index, color ) {

if ( this.instanceColor === null ) {

this.instanceColor = new InstancedBufferAttribute( new Float32Array( this.instanceMatrix.count * 3 ), 3 );

}

color.toArray( this.instanceColor.array, index * 3 );

}

setMatrixAt( index, matrix ) {

matrix.toArray( this.instanceMatrix.array, index * 16 );

}

updateMorphTargets() {

}

dispose() {

this.dispatchEvent( { type: 'dispose' } );

}

}

InstancedMesh.prototype.isInstancedMesh = true;

export { InstancedMesh };