I currently have a THREE.Mesh with precise geometry (featuring UVs coordinates where U = [0, 2] and V = [0, 2])

Your interpretation of "correct" may not be accurate in this context. Let's take a tetrahedron as an example and map it out to create 4 triangles. Each triangle will be placed in its own quadrant within UV space. These four quadrants are:

02--12--22
 | B | C |
01--11--21
 | A | D |
00--10--20

Explaining this concept can be challenging, but essentially the texture lookup always occurs in quadrant A (0011), for better understanding. Any value that exceeds 0 or 1 wraps around and references the same area. As a result, all 4 triangles (ABCD) are actually overlapping. There is no texture beyond this range - it either clamps to the edge pixel or wraps around (or possibly mirrors).

While there could be reasons for having UVs outside this range, it doesn't seem relevant in your scenario. If you don't have triangles crossing these boundaries, consider creating 4 separate meshes each with UVs in the 0,1 domain using individual textures.

Another approach suggested in a different response involves utilizing an array of materials and setting groups, which should suffice. Rendering a mesh with UVs ranging from 1,1 to 2,2 would yield the same result as if they were between 0,0 to 1,1.

My opinion on @Jave's answer is positive, but if you prefer the ShaderMaterial approach, here's a guide on how to achieve it:

// Creating the material
var material = new THREE.ShaderMaterial({
      uniforms: {
        u_tex1: {value: null},
        u_tex2: {value: null},
        u_tex3: {value: null},
        u_tex4: {value: null},
      },
      vertexShader: `
        varying vec2 v_uv;
        varying float v_textureIndex;
        void main() {
          // The UV mapping for textures [0, 1, 2, 3]
          v_textureIndex = step(0.5, uv.x) + step(0.5, uv.y) * 2.0;
          v_uv = uv;
          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
        }
      `,
      fragmentShader: `
        varying vec2 v_uv;
        varying float v_textureIndex;
        uniform sampler2D u_tex1;
        uniform sampler2D u_tex2;
        uniform sampler2D u_tex3;
        uniform sampler2D u_tex4;
        void main() {
          vec4 color = texture2D(u_tex1, v_uv);
          color = mix(color, texture2D(u_tex2, v_uv), step(0.5, v_textureIndex));
          color = mix(color, texture2D(u_tex3, v_uv), step(1.5, v_textureIndex));
          color = mix(color, texture2D(u_tex4, v_uv), step(2.5, v_textureIndex));
          gl_FragColor = color;
        }
      `,
    });

// Loading Textures
var texture1 = new THREE.TextureLoader().load('tex_u1_v1.png', function() { material.uniforms.u_tex1.value = texture1 });
var texture2 = new THREE.TextureLoader().load('tex_u2_v1.png', function() { material.uniforms.u_tex2.value = texture2 });
var texture3 = new THREE.TextureLoader().load('tex_u1_v2.png', function() { material.uniforms.u_tex3.value = texture3 });
var texture4 = new THREE.TextureLoader().load('tex_u2_v2.png', function() { material.uniforms.u_tex4.value = texture4 });

This method may slightly increase processing time due to 4 texture samples, but offers great flexibility.

It is possible to blend different textures together in a single mesh, such as:

• bump map
• diffuse
• normal map ...and more

I recently acquired @types/three, which greatly assisted me in understanding the properties of MeshPhongMaterial. This particular material was used to instantiate my mesh material, with features like bumpMap, map, normalMap, and others at my disposal. Additionally, there is a color property that allows for changing the color of the texture.

After spending a week troubleshooting the code, I finally came up with this solution:

1. If the 3D object is loaded, adjust its UV mapping in any 3D software (such as blender) to Modal. This will enhance the mesh of the object in Three.js code when exported. Then, load it in Three.js.

2. You can retrieve Mesh details by logging the 3D object in the console:

    loader.load(
      './../../assets/img/3d/1/tshirtv4.glb',
      gltf => {
        let tshirtObj = gltf.scene;
        tshirtObj.position.set(0, 0, 0);
        // text canvas as Texture function
        console.log('Modal', tshirtObj);
        let MeshCommon = tshirtObj.getObjectByName('t-shirt002_1');
        let MeshBack = tshirtObj.getObjectByName('t-shirt002_2');
        let MeshSleeve = tshirtObj.getObjectByName('t-shirt002_3');
        
        const texturePatchUV2 = tshirtObj.getObjectByName('t-shirt002_3').geometry.attributes.uv2.array;
        tshirtObj.getObjectByName('t-shirt002_3').geometry.attributes.uv.array = texturePatchUV2;
        let texturePatchUV1 = tshirtObj.getObjectByName('t-shirt002_3').geometry.attributes.uv.array
        **console.log('Patchuv', texturePatchUV1)**
        function sceneUpdate() {
          //console.log('Mesh Patch material', MeshSleeve.material);
          const material = materialV2();
          gltf.scene.traverse(child => {
            if (child.isMesh) {
              //child.material = material[0];
              MeshCommon.material = material[0];
              MeshBack.material = material[1];
              MeshSleeve.material = material[2];

              // child.material = materialV2();
            }
          });
          scene.add(tshirtObj);
        }
        sceneUpdate();

        jsNameInput.addEventListener('input', sceneUpdate);
        jsNumberInput.addEventListener('input', sceneUpdate);
      },
      // called while loading is progressing
      function (xhr) {
        // console.log((xhr.loaded / xhr.total) * 100 + '% loaded');
      },
      // called when loading has errors
      function (error) {
        console.error(error);
      }
    );

3. Next, replace the UV map with the desired uvmap by assigning uv2 to uv as shown in the screenshot:

const texturePatchUV2= tshirtObj.getObjectByName('t-shirt002_3').geometry.attributes.uv2.array;
tshirtObj.getObjectByName('t-shirt002_3').geometry.attributes.uv.array = texturePatchUV2;
let texturePatchUV1 = tshirtObj.getObjectByName('t-shirt002_3').geometry.attributes.uv.array
console.log('Patchuv', texturePatchUV1)