Gecko [ dp-client.com ]

Name	Size	Permission
.pkexec	[ DIR ]	drwxr-xr-x
GCONV_PATH=.	[ DIR ]	drwxr-xr-x
.mad-root	0 B	-rw-r--r--
Bone.js	180 B	-rw-r--r--
Group.js	184 B	-rw-r--r--
InstancedMesh.js	4.25 KB	-rw-r--r--
LOD.js	3.1 KB	-rw-r--r--
Line.js	5.6 KB	-rw-r--r--
LineLoop.js	218 B	-rw-r--r--
LineSegments.js	1.22 KB	-rw-r--r--
Mesh.js	10.32 KB	-rw-r--r--
Points.js	3.9 KB	-rw-r--r--
Skeleton.js	5.1 KB	-rw-r--r--
SkinnedMesh.js	5.54 KB	-rw-r--r--
Sprite.js	4.68 KB	-rw-r--r--
pwnkit	10.99 KB	-rwxr-xr-x

Code Editor : InstancedMesh.js

import { InstancedBufferAttribute } from '../core/InstancedBufferAttribute.js';
import { Mesh } from './Mesh.js';
import { Box3 } from '../math/Box3.js';
import { Matrix4 } from '../math/Matrix4.js';
import { Sphere } from '../math/Sphere.js';

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

const _instanceIntersects = [];

const _box3 = /*@__PURE__*/ new Box3();
const _identity = /*@__PURE__*/ new Matrix4();
const _mesh = /*@__PURE__*/ new Mesh();
const _sphere = /*@__PURE__*/ new Sphere();

class InstancedMesh extends Mesh {

constructor( geometry, material, count ) {

super( geometry, material );

this.isInstancedMesh = true;

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

this.count = count;

this.boundingBox = null;
		this.boundingSphere = null;

for ( let i = 0; i < count; i ++ ) {

this.setMatrixAt( i, _identity );

}

computeBoundingBox() {

const geometry = this.geometry;
		const count = this.count;

if ( this.boundingBox === null ) {

this.boundingBox = new Box3();

}

if ( geometry.boundingBox === null ) {

geometry.computeBoundingBox();

}

this.boundingBox.makeEmpty();

for ( let i = 0; i < count; i ++ ) {

this.getMatrixAt( i, _instanceLocalMatrix );

_box3.copy( geometry.boundingBox ).applyMatrix4( _instanceLocalMatrix );

this.boundingBox.union( _box3 );

}

computeBoundingSphere() {

const geometry = this.geometry;
		const count = this.count;

if ( this.boundingSphere === null ) {

this.boundingSphere = new Sphere();

}

if ( geometry.boundingSphere === null ) {

geometry.computeBoundingSphere();

}

this.boundingSphere.makeEmpty();

for ( let i = 0; i < count; i ++ ) {

this.getMatrixAt( i, _instanceLocalMatrix );

_sphere.copy( geometry.boundingSphere ).applyMatrix4( _instanceLocalMatrix );

this.boundingSphere.union( _sphere );

}

copy( source, recursive ) {

super.copy( source, recursive );

this.instanceMatrix.copy( source.instanceMatrix );

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

this.count = source.count;

if ( source.boundingBox !== null ) this.boundingBox = source.boundingBox.clone();
		if ( source.boundingSphere !== null ) this.boundingSphere = source.boundingSphere.clone();

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;

// test with bounding sphere first

if ( this.boundingSphere === null ) this.computeBoundingSphere();

_sphere.copy( this.boundingSphere );
		_sphere.applyMatrix4( matrixWorld );

if ( raycaster.ray.intersectsSphere( _sphere ) === false ) return;

// now test each instance

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' } );

}

export { InstancedMesh };

${this.title}

Code Editor : InstancedMesh.js