getTileBoundingVolume( tile ) {

		const boundingVolume = {};
		if ( this.rootTile.boundingVolume.region ) {

			const region = [ ...this.rootTile.boundingVolume.region ];
			const minX = region[ 0 ];
			const maxX = region[ 2 ];
			const minY = region[ 1 ];
			const maxY = region[ 3 ];
			const sizeX = ( maxX - minX ) / Math.pow( 2, tile.__level );
			const sizeY = ( maxY - minY ) / Math.pow( 2, tile.__level );
			region[ 0 ] = minX + sizeX * tile.__x;	//west
			region[ 2 ] = minX + sizeX * ( tile.__x + 1 );	//east
			region[ 1 ] = minY + sizeY * tile.__y;	//south
			region[ 3 ] = minY + sizeY * ( tile.__y + 1 );	//north
			for ( let k = 0; k < 4; k ++ ) {

				const coord = region[ k ];
				if ( coord < - Math.PI ) {

					region[ k ] += 2 * Math.PI;

				} else if ( coord > Math.PI ) {

					region[ k ] -= 2 * Math.PI;

				}

			}
			//Also divide the height in the case of octree.
			if ( isOctreeSubdivision( tile ) ) {

				const minZ = region[ 4 ];
				const maxZ = region[ 5 ];
				const sizeZ = ( maxZ - minZ ) / Math.pow( 2, tile.__level );
				region[ 4 ] = minZ + sizeZ * tile.__z;	//minimum height
				region[ 5 ] = minZ + sizeZ * ( tile.__z + 1 );	//maximum height

			}
			boundingVolume.region = region;

		}
		if ( this.rootTile.boundingVolume.box ) {

			// 0-2: center of the box
			// 3-5: x axis direction and half length
			// 6-8: y axis direction and half length
			// 9-11: z axis direction and half length
			const box = [ ...this.rootTile.boundingVolume.box ];
			const cellSteps = 2 ** tile.__level - 1;
			const scale = Math.pow( 2, - tile.__level );
			const axisNumber = isOctreeSubdivision( tile ) ? 3 : 2;
			for ( let i = 0; i < axisNumber; i ++ ) {

				// scale the bounds axes
				box[ 3 + i * 3 + 0 ] *= scale;
				box[ 3 + i * 3 + 1 ] *= scale;
				box[ 3 + i * 3 + 2 ] *= scale;
				// axis vector
				const x = box[ 3 + i * 3 + 0 ];
				const y = box[ 3 + i * 3 + 1 ];
				const z = box[ 3 + i * 3 + 2 ];
				// adjust the center by the x, y and z axes
				const axisOffset = i === 0 ? tile.__x : ( i === 1 ? tile.__y : tile.__z );
				box[ 0 ] += 2 * x * ( - 0.5 * cellSteps + axisOffset );
				box[ 1 ] += 2 * y * ( - 0.5 * cellSteps + axisOffset );
				box[ 2 ] += 2 * z * ( - 0.5 * cellSteps + axisOffset );

			}
			boundingVolume.box = box;

		}
		return boundingVolume;

	}
//TODO Adapt for Sphere
To maintain numerical stability during this subdivision process,
the actual bounding volumes should not be computed progressively by subdividing a non-root tile volume.
Instead, the exact bounding volumes are computed directly for a given level.
@param {Object | SubtreeTile} tile
@return {Object} object containing the bounding volume.