ay.constructor; if ( TypedArray !== attribute.array.constructor ) { console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' ); return null; } if ( itemSize === undefined ) itemSize = attribute.itemSize; if ( itemSize !== attribute.itemSize ) { console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' ); return null; } if ( normalized === undefined ) normalized = attribute.normalized; if ( normalized !== attribute.normalized ) { console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' ); return null; } if ( gpuType === - 1 ) gpuType = attribute.gpuType; if ( gpuType !== attribute.gpuType ) { console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' ); return null; } arrayLength += attribute.count * itemSize; } const array = new TypedArray( arrayLength ); const result = new BufferAttribute( array, itemSize, normalized ); let offset = 0; for ( let i = 0; i < attributes.length; ++ i ) { const attribute = attributes[ i ]; if ( attribute.isInterleavedBufferAttribute ) { const tupleOffset = offset / itemSize; for ( let j = 0, l = attribute.count; j < l; j ++ ) { for ( let c = 0; c < itemSize; c ++ ) { const value = attribute.getComponent( j, c ); result.setComponent( j + tupleOffset, c, value ); } } } else { array.set( attribute.array, offset ); } offset += attribute.count * itemSize; } if ( gpuType !== undefined ) { result.gpuType = gpuType; } return result; } /** * Performs a deep clone of the given buffer attribute. * * @param {BufferAttribute} attribute - The attribute to clone. * @return {BufferAttribute} The cloned attribute. */ function deepCloneAttribute( attribute ) { if ( attribute.isInstancedInterleavedBufferAttribute || attribute.isInterleavedBufferAttribute ) { return deinterleaveAttribute( attribute ); } if ( attribute.isInstancedBufferAttribute ) { return new InstancedBufferAttribute().copy( attribute ); } return new BufferAttribute().copy( attribute ); } /** * Interleaves a set of attributes and returns a new array of corresponding attributes that share a * single {@link InterleavedBuffer} instance. All attributes must have compatible types. * * @param {Array} attributes - The attributes to interleave. * @return {?Array} An array of interleaved attributes. If interleave does not succeed, the method returns `null`. */ function interleaveAttributes( attributes ) { // Interleaves the provided attributes into an InterleavedBuffer and returns // a set of InterleavedBufferAttributes for each attribute let TypedArray; let arrayLength = 0; let stride = 0; // calculate the length and type of the interleavedBuffer for ( let i = 0, l = attributes.length; i < l; ++ i ) { const attribute = attributes[ i ]; if ( TypedArray === undefined ) TypedArray = attribute.array.constructor; if ( TypedArray !== attribute.array.constructor ) { console.error( 'AttributeBuffers of different types cannot be interleaved' ); return null; } arrayLength += attribute.array.length; stride += attribute.itemSize; } // Create the set of buffer attributes const interleavedBuffer = new InterleavedBuffer( new TypedArray( arrayLength ), stride ); let offset = 0; const res = []; const getters = [ 'getX', 'getY', 'getZ', 'getW' ]; const setters = [ 'setX', 'setY', 'setZ', 'setW' ]; for ( let j = 0, l = attributes.length; j < l; j ++ ) { const attribute = attributes[ j ]; const itemSize = attribute.itemSize; const count = attribute.count; const iba = new InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, attribute.normalized ); res.push( iba ); offset += itemSize; // Move the data for each attribute into the new interleavedBuffer // at the appropriate offset for ( let c = 0; c < count; c ++ ) { for ( let k = 0; k < itemSize; k ++ ) { iba[ setters[ k ] ]( c, attribute[ getters[ k ] ]( c ) ); } } } return res; } /** * Returns a new, non-interleaved version of the given attribute. * * @param {InterleavedBufferAttribute} attribute - The interleaved attribute. * @return {BufferAttribute} The non-interleaved attribute. */ function deinterleaveAttribute( attribute ) { const cons = attribute.data.array.constructor; const count = attribute.count; const itemSize = attribute.itemSize; const normalized = attribute.normalized; const array = new cons( count * itemSize ); let newAttribute; if ( attribute.isInstancedInterleavedBufferAttribute ) { newAttribute =