World.clone(), object: object }; } function checkGeometryIntersection( object, material, raycaster, ray, uv, uv1, normal, a, b, c ) { object.getVertexPosition( a, _vA ); object.getVertexPosition( b, _vB ); object.getVertexPosition( c, _vC ); const intersection = checkIntersection$1( object, material, raycaster, ray, _vA, _vB, _vC, _intersectionPoint ); if ( intersection ) { const barycoord = new Vector3(); Triangle.getBarycoord( _intersectionPoint, _vA, _vB, _vC, barycoord ); if ( uv ) { intersection.uv = Triangle.getInterpolatedAttribute( uv, a, b, c, barycoord, new Vector2() ); } if ( uv1 ) { intersection.uv1 = Triangle.getInterpolatedAttribute( uv1, a, b, c, barycoord, new Vector2() ); } if ( normal ) { intersection.normal = Triangle.getInterpolatedAttribute( normal, a, b, c, barycoord, new Vector3() ); if ( intersection.normal.dot( ray.direction ) > 0 ) { intersection.normal.multiplyScalar( -1 ); } } const face = { a: a, b: b, c: c, normal: new Vector3(), materialIndex: 0 }; Triangle.getNormal( _vA, _vB, _vC, face.normal ); intersection.face = face; intersection.barycoord = barycoord; } return intersection; } const _baseVector = /*@__PURE__*/ new Vector4(); const _skinIndex = /*@__PURE__*/ new Vector4(); const _skinWeight = /*@__PURE__*/ new Vector4(); const _vector4 = /*@__PURE__*/ new Vector4(); const _matrix4 = /*@__PURE__*/ new Matrix4(); const _vertex = /*@__PURE__*/ new Vector3(); const _sphere$5 = /*@__PURE__*/ new Sphere(); const _inverseMatrix$2 = /*@__PURE__*/ new Matrix4(); const _ray$2 = /*@__PURE__*/ new Ray(); /** * A mesh that has a {@link Skeleton} that can then be used to animate the * vertices of the geometry with skinning/skeleton animation. * * Next to a valid skeleton, the skinned mesh requires skin indices and weights * as buffer attributes in its geometry. These attribute define which bones affect a single * vertex to a certain extend. * * Typically skinned meshes are not created manually but loaders like {@link GLTFLoader} * or {@link FBXLoader } import respective models. * * @augments Mesh * @demo scenes/bones-browser.html */ class SkinnedMesh extends Mesh { /** * Constructs a new skinned mesh. * * @param {BufferGeometry} [geometry] - The mesh geometry. * @param {Material|Array} [material] - The mesh material. */ constructor( geometry, material ) { super( geometry, material ); /** * This flag can be used for type testing. * * @type {boolean} * @readonly * @default true */ this.isSkinnedMesh = true; this.type = 'SkinnedMesh'; /** * `AttachedBindMode` means the skinned mesh shares the same world space as the skeleton. * This is not true when using `DetachedBindMode` which is useful when sharing a skeleton * across multiple skinned meshes. * * @type {(AttachedBindMode|DetachedBindMode)} * @default AttachedBindMode */ this.bindMode = AttachedBindMode; /** * The base matrix that is used for the bound bone transforms. * * @type {Matrix4} */ this.bindMatrix = new Matrix4(); /** * The base matrix that is used for resetting the bound bone transforms. * * @type {Matrix4} */ this.bindMatrixInverse = new Matrix4(); /** * The bounding box of the skinned mesh. Can be computed via {@link SkinnedMesh#computeBoundingBox}. * * @type {?Box3} * @default null */ this.boundingBox = null; /** * The bounding sphere of the skinned mesh. Can be computed via {@link SkinnedMesh#computeBoundingSphere}. * * @type {?Sphere} * @default null */ this.boundingSphere = null; } /** * Computes the bounding box of the skinned mesh, and updates {@link SkinnedMesh#boundingBox}. * The bounding box is not automatically computed by the engine; this method must be called by your app. * If the skinned mesh is animated, the bounding box should be recomputed per frame in order to reflect * the current animation state. */ computeBoundingBox() { const geometry = this.geometry; if ( this.boundingBox === null ) { this.boundingBox = new Box3(); } this.boundingBox.makeEmpty(); const positionAttribute = geometry.getAttribute( 'position' ); for ( let i = 0; i < positionAttribute.count; i ++ ) { this.getVertexPosition( i, _vertex ); this.boundingBox.expandByPoint( _vertex ); } } /** * Computes the bounding sphere of the skinned mesh, and updates {@link SkinnedMesh#boundingSphere}. * The bounding sphere is automatically computed by the engine once when it is needed, e.g., for ray casting * and view frustum culling. If the skinned mesh is animated, the bounding sphere should be recomputed * per frame in order to reflect the current animation state. */ computeBoundingSphere() { const geometry = this.geometry; if ( this.boundingSphere === null ) { this.boundingSphere = new Sph