static compressNormals( mesh, encodeMethod ) {

			if ( ! mesh.geometry ) {

				console.error( 'Mesh must contain geometry. ' );

			}

			const normal = mesh.geometry.attributes.normal;

			if ( ! normal ) {

				console.error( 'Geometry must contain normal attribute. ' );

			}

			if ( normal.isPacked ) return;

			if ( normal.itemSize != 3 ) {

				console.error( 'normal.itemSize is not 3, which cannot be encoded. ' );

			}

			const array = normal.array;
			const count = normal.count;
			let result;

			if ( encodeMethod == 'DEFAULT' ) {

				// TODO: Add 1 byte to the result, making the encoded length to be 4 bytes.
				result = new Uint8Array( count * 3 );

				for ( let idx = 0; idx < array.length; idx += 3 ) {

					const encoded = EncodingFuncs.defaultEncode( array[ idx ], array[ idx + 1 ], array[ idx + 2 ], 1 );
					result[ idx + 0 ] = encoded[ 0 ];
					result[ idx + 1 ] = encoded[ 1 ];
					result[ idx + 2 ] = encoded[ 2 ];

				}

				mesh.geometry.setAttribute( 'normal', new THREE.BufferAttribute( result, 3, true ) );
				mesh.geometry.attributes.normal.bytes = result.length * 1;

			} else if ( encodeMethod == 'OCT1Byte' ) {

				/**
      * It is not recommended to use 1-byte octahedron normals encoding unless you want to extremely reduce the memory usage
      * As it makes vertex data not aligned to a 4 byte boundary which may harm some WebGL implementations and sometimes the normal distortion is visible
      * Please refer to @zeux 's comments in https://github.com/mrdoob/three.js/pull/18208
      */
				result = new Int8Array( count * 2 );

				for ( let idx = 0; idx < array.length; idx += 3 ) {

					const encoded = EncodingFuncs.octEncodeBest( array[ idx ], array[ idx + 1 ], array[ idx + 2 ], 1 );
					result[ idx / 3 * 2 + 0 ] = encoded[ 0 ];
					result[ idx / 3 * 2 + 1 ] = encoded[ 1 ];

				}

				mesh.geometry.setAttribute( 'normal', new THREE.BufferAttribute( result, 2, true ) );
				mesh.geometry.attributes.normal.bytes = result.length * 1;

			} else if ( encodeMethod == 'OCT2Byte' ) {

				result = new Int16Array( count * 2 );

				for ( let idx = 0; idx < array.length; idx += 3 ) {

					const encoded = EncodingFuncs.octEncodeBest( array[ idx ], array[ idx + 1 ], array[ idx + 2 ], 2 );
					result[ idx / 3 * 2 + 0 ] = encoded[ 0 ];
					result[ idx / 3 * 2 + 1 ] = encoded[ 1 ];

				}

				mesh.geometry.setAttribute( 'normal', new THREE.BufferAttribute( result, 2, true ) );
				mesh.geometry.attributes.normal.bytes = result.length * 2;

			} else if ( encodeMethod == 'ANGLES' ) {

				result = new Uint16Array( count * 2 );

				for ( let idx = 0; idx < array.length; idx += 3 ) {

					const encoded = EncodingFuncs.anglesEncode( array[ idx ], array[ idx + 1 ], array[ idx + 2 ] );
					result[ idx / 3 * 2 + 0 ] = encoded[ 0 ];
					result[ idx / 3 * 2 + 1 ] = encoded[ 1 ];

				}

				mesh.geometry.setAttribute( 'normal', new THREE.BufferAttribute( result, 2, true ) );
				mesh.geometry.attributes.normal.bytes = result.length * 2;

			} else {

				console.error( 'Unrecognized encoding method, should be `DEFAULT` or `ANGLES` or `OCT`. ' );

			}

			mesh.geometry.attributes.normal.needsUpdate = true;
			mesh.geometry.attributes.normal.isPacked = true;
			mesh.geometry.attributes.normal.packingMethod = encodeMethod; // modify material

			if ( ! ( mesh.material instanceof PackedPhongMaterial ) ) {

				mesh.material = new PackedPhongMaterial().copy( mesh.material );

			}

			if ( encodeMethod == 'ANGLES' ) {

				mesh.material.defines.USE_PACKED_NORMAL = 0;

			}

			if ( encodeMethod == 'OCT1Byte' ) {

				mesh.material.defines.USE_PACKED_NORMAL = 1;

			}

			if ( encodeMethod == 'OCT2Byte' ) {

				mesh.material.defines.USE_PACKED_NORMAL = 1;

			}

			if ( encodeMethod == 'DEFAULT' ) {

				mesh.material.defines.USE_PACKED_NORMAL = 2;

			}

		}
Make the input mesh.geometry's normal attribute encoded and compressed by 3 different methods.
Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the normal data.

@param {THREE.Mesh} mesh
@param {String} encodeMethod		"DEFAULT" || "OCT1Byte" || "OCT2Byte" || "ANGLES"