Three.js中OBJLoader加载模型后如何获取并处理Mesh对象

var bracket;
var loader = new THREE.OBJLoader();

function objectLoader( objFile, objName ) {
    var container = new THREE.Object3D();
    loader.load( objFile , function ( object ) {
        // 这个回调函数在loader.load()返回container之后才会被执行
        object.name = objName;
        object.scale.set(1, 1, 1);
        container.add( object );
    })
    // 在这一点上，container很可能是空的！
    return container;
}

bracket = objectLoader('model.obj', 'Bracket');

var loader = new THREE.OBJLoader();

async function loadObjModel( objFile ) {
    try {
        const group = await loader.loadAsync( objFile );
        return group;
    } catch (error) {
        console.error('加载OBJ模型失败:', error);
        throw error; // 向上抛出错误，以便调用者处理
    }
}

async function init() {
    // 调用异步函数加载模型
    const loadedGroup = await loadObjModel( 'model.obj' );

    // 遍历加载的Group，查找Mesh对象
    loadedGroup.traverse(object => {
        if (object.isMesh) {
            console.log('找到Mesh对象:', object);

            // 在这里对Mesh对象进行操作，例如：
            object.name = 'BracketMesh'; // 赋予一个有意义的名称
            object.scale.set(1, 1, 1); // 设置缩放
            // object.material = new THREE.MeshStandardMaterial({ color: 0x00ff00 }); // 更改材质

            // 如果你需要将这个Mesh存储到一个全局变量，可以在这里赋值
            // globalBracketMesh = object; 

            // 注意：如果OBJ文件包含多个Mesh，你可能需要一个数组来存储，
            // 或者根据特定条件选择一个Mesh。
        }
    });

    // 将处理后的group添加到场景中
    // scene.add(loadedGroup); 
}

// 启动初始化函数
init();

import * as THREE from 'three';
import { OBJLoader } from 'three/addons/loaders/OBJLoader.js'; // 假设你使用模块导入

// 场景、相机、渲染器等Three.js基础设置...
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);

camera.position.z = 5;

// OBJLoader实例
const loader = new OBJLoader();

// 全局变量，用于存储提取的Mesh
let globalBracketMesh = null;

/**
 * 异步加载OBJ模型文件，并返回加载后的Group对象。
 * @param {string} objFile - OBJ模型文件的路径。
 * @returns {Promise<THREE.Group>} - 包含加载模型的Group对象。
 */
async function loadObjModel( objFile ) {
    try {
        console.log(`开始加载模型: ${objFile}`);
        const group = await loader.loadAsync( objFile );
        console.log(`模型加载完成: ${objFile}`);
        return group;
    } catch (error) {
        console.error(`加载OBJ模型失败: ${objFile}`, error);
        throw error;
    }
}

/**
 * 初始化函数，加载模型并处理其中的Mesh。
 */
async function init() {
    try {
        const loadedGroup = await loadObjModel( 'model.obj' ); // 替换为你的模型路径

        // 遍历加载的Group，查找并处理Mesh对象
        loadedGroup.traverse(object => {
            if (object.isMesh) {
                console.log('找到Mesh对象:', object);

                // 对Mesh进行操作
                object.name = 'BracketMesh';
                object.scale.set(0.1, 0.1, 0.1); // 示例缩放
                object.material = new THREE.MeshStandardMaterial({ color: 0x007bff, roughness: 0.5, metalness: 0.8 });

                // 将第一个找到的Mesh存储到全局变量
                if (!globalBracketMesh) {
                    globalBracketMesh = object;
                    console.log('全局Bracket Mesh已设置:', globalBracketMesh);
                }
            }
        });

        // 将整个加载的Group添加到场景中
        scene.add(loadedGroup);

        // 如果需要，可以在这里对globalBracketMesh进行CSG等操作
        if (globalBracketMesh) {
            console.log('现在可以使用globalBracketMesh进行CSG等操作了。');
            // 示例：创建一个立方体并与bracketMesh进行布尔运算（需要引入CSG库）
            // const boxGeometry = new THREE.BoxGeometry(0.5, 0.5, 0.5);
            // const boxMaterial = new THREE.MeshStandardMaterial({ color: 0xff0000 });
            // const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial);
            // boxMesh.position.set(0.5, 0.5, 0.5);
            // scene.add(boxMesh);

            // const csg = CSG.fromMesh(globalBracketMesh);
            // const csgBox = CSG.fromMesh(boxMesh);
            // const resultCSG = csg.subtract(csgBox);
            // const resultMesh = CSG.toMesh(resultCSG, globalBracketMesh.matrix);
            // scene.remove(globalBracketMesh);
            // scene.add(resultMesh);
        }

        // 渲染循环
        function animate() {
            requestAnimationFrame(animate);
            // 示例：旋转模型
            if (loadedGroup) {
                loadedGroup.rotation.y += 0.01;
            }
            renderer.render(scene, camera);
        }
        animate();

    } catch (error) {
        console.error('初始化失败:', error);
    }
}

// 启动初始化过程
init();

// 添加一个光源，以便看到材质效果
const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
scene.add(ambientLight);
const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
directionalLight.position.set(1, 1, 1).normalize();
scene.add(directionalLight);

// 窗口大小调整处理
window.addEventListener('resize', () => {
    camera.aspect = window.innerWidth / window.innerHeight;
    camera.updateProjectionMatrix();
    renderer.setSize(window.innerWidth, window.innerHeight);
});