// 全局变量
let scene, camera, renderer, controls;
let water, sun, sky;
let windTurbineModels = []; // 改为数组存储多个风电机组
let clock = new THREE.Clock();

// 在全局变量部分添加
let pointerLockControls;
let moveForward = false;
let moveBackward = false;
let moveLeft = false;
let moveRight = false;
let moveUp = false;
let moveDown = false;
let velocity = new THREE.Vector3();
let direction = new THREE.Vector3();
let prevTime = performance.now();

// 初始化Three.js场景
function init() {
    console.log('开始初始化Three.js场景');

    // 创建场景
    scene = new THREE.Scene();
    //scene.fog = new THREE.Fog(0x006994, 1, 1000);
    console.log('场景创建完成');

    //天空盒
    scene.background = new THREE.CubeTextureLoader()
        .setPath('./assets/sky/')
        .load(['px.jpg', 'nx.jpg', 'py.jpg', 'ny.jpg', 'pz.jpg', 'nz.jpg']);
    //环境光
    const ambientLight = new THREE.AmbientLight(0x666666, 20); // 柔和的白光
    scene.add(ambientLight);

    // 创建相机
    // 增大远裁剪面距离，确保远处的缩小模型也能显示
    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 5000);

    // 向右旋转270度的相机位置设置（根据你的代码）
    const cameraRotationAngle = THREE.MathUtils.degToRad(0);
    const cameraRadius = 800; // 相机距离原点的距离
    const cameraHeight = 50; // 降低相机高度，使其更接近水面

    // 计算旋转后的位置（修复变量名错误）
    const cameraX = cameraRadius * Math.sin(cameraRotationAngle);
    const cameraZ = cameraRadius * Math.cos(cameraRotationAngle); // 修复：使用cameraRotationAngle而不是cameraAngle

    camera.position.set(cameraX, cameraHeight, cameraZ);
    camera.lookAt(0, 0, 0);  // 确保相机朝向场景中心
    console.log('相机创建完成，位置:', camera.position.x, camera.position.y, camera.position.z);

    //创建渲染器
    renderer = new THREE.WebGLRenderer({
        logarithmicDepthBuffer: true,//设置对数深度缓冲区，优化深度冲突问题
        preserveDrawingBuffer: true,//把canvas画布上内容下载到本地,保存图片 
        antialias: true, // 正确开启抗锯齿
        stencil: true,//开启模版缓存区,用于高级渲染技术，如阴影体积、遮挡剔除等
        powerPreference: 'high-performance',//指定渲染器使用的 GPU 功率模式。默认 "default"
        physicalCorrectLights: true,//是否使用物理上正确的照明模式；默认为 false
        localClippingEnabled: true,//启用局部裁剪；默认为 false 
        alpha: true,//背景透明
    });

    renderer.setSize(window.innerWidth, window.innerHeight);
    renderer.shadowMap.enabled = true;
    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
    renderer.setClearColor(0x87CEEB, 1);

    // 确保canvas添加到正确的容器
    const container = document.getElementById('container');
    if (container) {
        container.appendChild(renderer.domElement);
        console.log('渲染器canvas已添加到container');
    } else {
        document.body.appendChild(renderer.domElement);
        console.log('渲染器canvas已添加到body');
    }

    // 设置canvas样式确保可见
    renderer.domElement.style.display = 'block';
    renderer.domElement.style.position = 'absolute';
    renderer.domElement.style.top = '0';
    renderer.domElement.style.left = '0';
    renderer.domElement.style.zIndex = '1';

    console.log('渲染器创建完成，canvas尺寸:', renderer.domElement.width, 'x', renderer.domElement.height);

    // 初始化指针锁定控制器
    if (typeof THREE.PointerLockControls !== 'undefined') {
        pointerLockControls = new THREE.PointerLockControls(camera, document.body);
        
        // 添加点击进入指针锁定的事件
        document.addEventListener('click', function() {
            if (pointerLockControls) {
                pointerLockControls.lock();
            }
        });
        
        // 添加键盘控制事件
        document.addEventListener('keydown', onKeyDown, false);
        document.addEventListener('keyup', onKeyUp, false);
        
        console.log('指针锁定控制器创建完成');
    } else {
        console.warn('PointerLockControls未加载，使用OrbitControls');
        // 保留原有的OrbitControls作为备选
        initOrbitControls();
    }

    // 添加相机控制 (OrbitControls 作为备选)
    function initOrbitControls() {
        if (typeof THREE.OrbitControls !== 'undefined') {
            controls = new THREE.OrbitControls(camera, renderer.domElement);
            controls.enableDamping = true;
            controls.dampingFactor = 0.05;
            controls.screenSpacePanning = false;
            controls.minDistance = 10;   // 减小最小距离
            controls.maxDistance = 3000; // 最大距离
            controls.maxPolarAngle = Math.PI / 2 - 0.1; // 限制垂直旋转角度，防止看到水面以下
            controls.target.set(0, 0, 0);
            controls.addEventListener('change', function () {
                // 限制相机高度，防止进入水面以下
                if (camera.position.y < 5) {
                    camera.position.y = 5;
                }
            });
            console.log('相机控制器创建完成');
        } else {
            console.warn('OrbitControls未加载，跳过相机控制器');
        }
    }

    // const ambientLight = new THREE.AmbientLight(0x404040);  // 环境光
    //   ambientLight.intensity = 0.5;  // 光照强度
    //   scene.add(ambientLight);
    addLights();

    // loadHDRTexture() 
    // // 创建场景元素
    // createSkybox(); // 创建天空盒
    createOcean();  // 创建海洋

    // 加载海上风电机组模型
    loadWindTurbineField();

    // 监听窗口大小变化
    window.addEventListener('resize', onWindowResize, false);

    console.log('Three.js场景初始化完成');
}

// 加载HDR环境纹理
function loadHDRTexture() {
    // 检查RGBELoader是否可用
    if (typeof THREE.RGBELoader === 'undefined') {
        console.warn('RGBELoader未加载，跳过HDR纹理加载');
        return;
    }

    const hdrLoader = new THREE.RGBELoader();
    hdrLoader.load("./textures/023.hdr", (texture) => {
        // 设置背景和环境纹理
        texture.mapping = THREE.EquirectangularReflectionMapping;
        scene.background = texture;
        scene.environment = texture;
        console.log('HDR纹理加载完成');
    }, undefined, (error) => {
        console.error('HDR纹理加载失败:', error);
    });
}

// 修改后的 createSkybox 函数：// 创建天空盒
function createSkybox() {
    const skyGeometry = new THREE.SphereGeometry(1800, 24, 18); // 增大天空盒半径
    const textureLoader = new THREE.TextureLoader().load('./textures/sky.jpg');
    textureLoader.colorSpace = THREE.SRGBColorSpace;
    // 创建天空材质（通常使用全景纹理）
    const skyMaterial = new THREE.MeshBasicMaterial({
        map: textureLoader,
        side: THREE.BackSide  // 重要：让材质渲染在球体内侧
    });

    // 创建天空网格
    const skySphere = new THREE.Mesh(skyGeometry, skyMaterial);
    scene.add(skySphere);
}
// 创建天空效果
function createSky() {
    // 注释掉Sky.js的高级天空效果

    sky = new THREE.Sky();
    sky.scale.setScalar(450000);
    scene.add(sky);

    // 创建太阳
    sun = new THREE.Vector3();

    // 配置天空参数（正午阳光设置）
    const skyUniforms = sky.material.uniforms;
    skyUniforms['turbidity'].value = 2; // 降低湍流度，营造清澈的正午天空
    skyUniforms['rayleigh'].value = 3; // 增强瑞利散射，让天空更蓝
    skyUniforms['mieCoefficient'].value = 0.005;
    skyUniforms['mieDirectionalG'].value = 0.8;

    // 设置太阳位置（正午阳光效果）
    const phi = THREE.MathUtils.degToRad(90 - 85); // 仰角 - 太阳接近天顶
    const theta = THREE.MathUtils.degToRad(0); // 方位角 - 正南方向

    sun.setFromSphericalCoords(1, phi, theta);
    skyUniforms['sunPosition'].value.copy(sun);


    // 使用sky.jpg作为天空盒纹理
    const textureLoader = new THREE.TextureLoader();
    textureLoader.load('./textures/sky.jpg', function (texture) {
        // 创建天空盒几何体
        const skyBoxGeometry = new THREE.SphereGeometry(2000, 32, 32);
        const skyBoxMaterial = new THREE.MeshBasicMaterial({
            map: texture,
            side: THREE.BackSide
        });
        const skyBox = new THREE.Mesh(skyBoxGeometry, skyBoxMaterial);
        scene.add(skyBox);
        console.log('Sky texture loaded as skybox');
    }, undefined, function (error) {
        console.error('Sky texture loading failed:', error);
        // 创建备用天空颜色
        const skyGeometry = new THREE.SphereGeometry(500, 32, 32);
        const skyMaterial = new THREE.MeshBasicMaterial({
            color: 0x87CEEB,
            side: THREE.BackSide
        });
        const sky = new THREE.Mesh(skyGeometry, skyMaterial);
        scene.add(sky);
        console.log('Fallback sky color created');
    });

    console.log('Sky created using sky.jpg texture');
}


// 创建海洋效果
function createOcean() {
    // 加载水面法线纹理
    const textureLoader = new THREE.TextureLoader();
    const waterNormals = textureLoader.load('./textures/waternormals.jpg', function (texture) {
        // 设置法线纹理的重复模式，增强水面效果
        texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
        texture.repeat.set(2, 2); // 调整重复次数以控制波浪密度
        console.log('水面法线纹理加载成功');
    }, undefined, function (error) {
        console.error('水面法线纹理加载失败:', error);
    });

    // 设置法线纹理的包装模式（即使纹理加载失败也要设置默认值）
    waterNormals.wrapS = waterNormals.wrapT = THREE.RepeatWrapping;
    waterNormals.repeat.set(2, 2); // 增加重复次数以获得更细腻的波浪效果

    // 创建水面几何体，增大尺寸以匹配天空盒尺寸
    const waterGeometry = new THREE.PlaneGeometry(10600, 10600); // 比天空盒稍大以确保完全覆盖

    // 使用Water.js创建高级水面效果 
    // 其他碧绿色选项：
    // waterColor: 0x0077be, // 经典碧绿色
    // waterColor: 0x00a86b, // 绿松石色
    // waterColor: 0x2a52be, // 地中海蓝
    // waterColor: 0x008080, // 水鸭色
    // waterColor: 0x40e0d0, // 青绿色
    water = new THREE.Water(waterGeometry, {
        textureWidth: 512,
        textureHeight: 512,
        waterNormals: waterNormals,
        sunDirection: new THREE.Vector3(0.70707, 0.70707, 0.0),
        sunColor: 0xffffff,
        waterColor: 0x0077be,//0x001e0f 0x40e0d0
        distortionScale: 3.7, // 控制波浪的扭曲程度
        fog: scene.fog !== undefined,
        alpha: 1.0, // 水面透明度
        foam: 0.1 // 泡沫效果
    });

    water.rotation.x = -Math.PI / 2;
    water.position.y = 0; // 确保水面在y=0位置
    scene.add(water);

    // 将water赋值给全局ocean变量以保持兼容性
    ocean = water;

    console.log('高级水面效果创建完成，使用法线纹理增强波浪凹凸效果');
}
// 修改 addLights 函数，增强光照效果// 修改 addLights 函数，进一步增强光照效果
function addLights() {
    // 大幅增强环境光强度
    const ambientLight = new THREE.AmbientLight(0xffffff, 1.2); // 使用白色光，强度更高
    scene.add(ambientLight);

    // 主方向光（太阳光）- 进一步调整位置和强度
    const directionalLight = new THREE.DirectionalLight(0xffffff, 1.5); // 增加强度到1.5
    directionalLight.position.set(100, 150, 100); // 调整到更合理的位置
    directionalLight.castShadow = true;
    directionalLight.shadow.mapSize.width = 2048;
    directionalLight.shadow.mapSize.height = 2048;
    directionalLight.shadow.camera.near = 0.5;
    directionalLight.shadow.camera.far = 2000; // 增加远裁剪面
    directionalLight.shadow.camera.left = -800;
    directionalLight.shadow.camera.right = 800;
    directionalLight.shadow.camera.top = 800;
    directionalLight.shadow.camera.bottom = -800;
    scene.add(directionalLight);

    // 添加更强的补光 - 减少阴影
    const fillLight = new THREE.DirectionalLight(0xffffff, 0.8); // 增加补光强度到0.8
    fillLight.position.set(-100, 100, -100);
    scene.add(fillLight);

    // 添加天光 - 模拟天空反射
    const hemiLight = new THREE.HemisphereLight(0x80deea, 0x4caf50, 0.5); // 增加强度到0.5
    hemiLight.position.set(0, 200, 0);
    scene.add(hemiLight);

    // 添加背面光，确保模型背面也有光照
    const backLight = new THREE.DirectionalLight(0xffffff, 0.6);
    backLight.position.set(0, 50, -200);
    scene.add(backLight);
}

// 加载海上风电场（20个风电机组）
function loadWindTurbineField() {
    console.log('开始加载海上风电场');

    const loader = new THREE.GLTFLoader();

    // 定义风电场布局 - 4行5列的排列（增加两排）
    const positions = [
        // 第一排
        // { x: -400, z: -600 },
        // { x: -200, z: -600 },
        // { x: 0, z: -600 },
        // { x: 200, z: -600 },
        // { x: 400, z: -600 },
        // // 第二排
        // { x: -400, z: -400 },
        // { x: -200, z: -400 },
        // { x: 0, z: -400 },
        // { x: 200, z: -400 },
        // { x: 400, z: -400 },
        // 第三排
        { x: -400, z: -200 },
        { x: -200, z: -200 },
        { x: 0, z: -200 },
        { x: 200, z: -200 },
        { x: 400, z: -200 },
        // 第四排
        { x: -400, z: 200 },
        { x: -200, z: 200 },
        { x: 0, z: 200 },
        { x: 200, z: 200 },
        { x: 400, z: 200 }
    ];

    // 旋转角度（右转50度）
    const rotationAngle = THREE.MathUtils.degToRad(50); // 转换为弧度
    const cosAngle = Math.cos(rotationAngle);
    const sinAngle = Math.sin(rotationAngle);

    let loadedCount = 0;
    const totalCount = positions.length;

    positions.forEach((position, index) => {
        // 应用旋转变换到每个风电机组的位置
        const rotatedX = position.x * cosAngle - position.z * sinAngle;
        const rotatedZ = position.x * sinAngle + position.z * cosAngle;

        loader.load(
            './models/风电组.glb',
            function (gltf) {
                console.log(`风电组.glb模型 ${index + 1} 加载成功`);
                const model = gltf.scene.clone(); // 克隆模型以创建多个实例

                // 调整模型缩放和位置（使用旋转后的位置）
                model.scale.set(0.8, 0.8, 0.8);
                // 将风机位置设置在水面上（y=0）
                model.position.set(rotatedX, 0, rotatedZ);

                // 设置模型的旋转角度（使风机面向正确的方向）
                model.rotation.y = -rotationAngle; // 负号是因为我们希望风机正面朝向旋转方向


                // 调整模型材质
                // 调整模型材质，使其更亮
                model.traverse(function (child) {
                    if (child.isMesh) {
                        child.castShadow = true;
                        child.receiveShadow = true;
                        child.frustumCulled = false;

                        // 如果材质存在，调整其属性
                        if (child.material) {
                            // 添加更强的自发光效果
                            child.material.emissive = new THREE.Color(0x444444); // 增加自发光强度

                            // 调整材质颜色，使其更亮
                            if (child.material.color) {
                                // 可以稍微提亮原始颜色
                                child.material.color.multiplyScalar(1.2);
                            }

                            // 确保材质响应光照
                            if (child.material.type === 'MeshBasicMaterial') {
                                // 如果是基础材质，替换为标准材质
                                child.material = new THREE.MeshStandardMaterial({
                                    color: child.material.color || 0xffffff,
                                    map: child.material.map,
                                    metalness: 0.1,
                                    roughness: 0.6,
                                    emissive: new THREE.Color(0x333333), // 添加自发光
                                    emissiveIntensity: 0.3
                                });
                            } else if (child.material.type === 'MeshStandardMaterial') {
                                // 调整标准材质参数使其更亮
                                child.material.metalness = Math.max(0.05, child.material.metalness || 0.1);
                                child.material.roughness = Math.min(0.8, child.material.roughness || 0.6);
                                child.material.emissive = new THREE.Color(0x333333);
                                child.material.emissiveIntensity = 0.3; // 添加自发光强度
                            } else if (child.material.type === 'MeshLambertMaterial') {
                                // 对于Lambert材质也添加自发光
                                child.material.emissive = new THREE.Color(0x333333);
                            }
                        }
                    }
                });


                // 添加到场景和数组
                scene.add(model);
                windTurbineModels.push(model);

                loadedCount++;
                console.log(`风电场进度: ${loadedCount}/${totalCount} 个风电机组已加载`);

                if (loadedCount === totalCount) {
                    console.log('海上风电场加载完成！');
                }
            },
            function (progress) {
                if (progress.total > 0) {
                    const percent = (progress.loaded / progress.total * 100).toFixed(1);
                    console.log(`风电机组 ${index + 1} 加载进度: ${percent}%`);
                }
            },
            function (error) {
                console.error(`风电机组 ${index + 1} 加载失败:`, error);
                // 如果单个模型加载失败，创建备用模型（同样应用旋转变换）
                createFallbackWindTurbine(rotatedX, rotatedZ, index);
                loadedCount++;
            }
        );
    });
}
// 修改备用风机创建函数，也应用旋转变换
function createFallbackWindTurbine(x = 0, z = 0, index = 0) {
    console.log(`创建备用风电机组模型 ${index + 1}`);

    // 创建风电机组主体（塔筒）
    const towerGeometry = new THREE.CylinderGeometry(1.6, 2.4, 24, 8); // 缩小尺寸
    const towerMaterial = new THREE.MeshLambertMaterial({ color: 0xcccccc });
    const tower = new THREE.Mesh(towerGeometry, towerMaterial);
    tower.position.set(0, 12, 0);
    tower.castShadow = true;
    tower.receiveShadow = true;
    tower.frustumCulled = false; // 禁用视锥体剔除

    // 创建机舱
    const nacelleGeometry = new THREE.BoxGeometry(6.4, 3.2, 3.2); // 缩小尺寸
    const nacelleMaterial = new THREE.MeshLambertMaterial({ color: 0xffffff });
    const nacelle = new THREE.Mesh(nacelleGeometry, nacelleMaterial);
    nacelle.position.set(0, 24, 0);
    nacelle.castShadow = true;
    nacelle.frustumCulled = false; // 禁用视锥体剔除

    // 创建叶片轮毂组（用于旋转）
    const rotorGroup = new THREE.Group();

    // 创建叶片轮毂
    const hubGeometry = new THREE.SphereGeometry(1.2, 8, 8); // 缩小尺寸
    const hubMaterial = new THREE.MeshLambertMaterial({ color: 0x666666 });
    const hub = new THREE.Mesh(hubGeometry, hubMaterial);
    hub.position.set(0, 0, 0); // 相对于rotorGroup的位置
    hub.castShadow = true;
    hub.frustumCulled = false; // 禁用视锥体剔除

    // 创建叶片
    const bladeGeometry = new THREE.BoxGeometry(0.4, 12, 0.8); // 缩小尺寸
    const bladeMaterial = new THREE.MeshLambertMaterial({ color: 0xffffff });

    const blade1 = new THREE.Mesh(bladeGeometry, bladeMaterial);
    blade1.position.set(0, 6, 0); // 相对于rotorGroup的位置
    blade1.castShadow = true;
    blade1.frustumCulled = false; // 禁用视锥体剔除

    const blade2 = new THREE.Mesh(bladeGeometry, bladeMaterial);
    blade2.position.set(0, 0, 6);
    blade2.rotation.z = Math.PI * 2 / 3;
    blade2.castShadow = true;
    blade2.frustumCulled = false; // 禁用视锥体剔除

    const blade3 = new THREE.Mesh(bladeGeometry, bladeMaterial);
    blade3.position.set(0, 0, -6);
    blade3.rotation.z = Math.PI * 4 / 3;
    blade3.castShadow = true;
    blade3.frustumCulled = false; // 禁用视锥体剔除

    // 将轮毂和叶片添加到旋转组
    rotorGroup.add(hub);
    rotorGroup.add(blade1);
    rotorGroup.add(blade2);
    rotorGroup.add(blade3);

    // 设置旋转组的位置
    rotorGroup.position.set(3.2, 24, 0);

    // 给旋转组添加一个标识，方便动画识别
    rotorGroup.name = 'rotor_group';

    // 组合风电机组
    const windTurbine = new THREE.Group();
    windTurbine.add(tower);
    windTurbine.add(nacelle);
    windTurbine.add(rotorGroup);

    // 将风机放置在水面上（y=0）
    windTurbine.position.set(x, 0, z);
    windTurbine.scale.set(0.8, 0.8, 0.8); // 整体缩放

    // 应用旋转（与主风电场一致）
    const rotationAngle = THREE.MathUtils.degToRad(50);
    windTurbine.rotation.y = -rotationAngle;

    // 禁用整个组的视锥体剔除
    windTurbine.traverse(function (child) {
        child.frustumCulled = false;
    });

    scene.add(windTurbine);
    windTurbineModels.push(windTurbine);

    console.log(`备用风电机组模型 ${index + 1} 创建完成`);
}

// 动画循环
function animate() {
    requestAnimationFrame(animate);

    const time = clock.getElapsedTime();

    // 漫游控制逻辑
    const delta = Math.min(0.1, (time - prevTime));
    
    // 如果使用指针锁定控制器且已锁定
    if (pointerLockControls && pointerLockControls.isLocked) {
        // 计算移动方向
        direction.z = Number(moveForward) - Number(moveBackward);
        direction.x = Number(moveRight) - Number(moveLeft);
        direction.y = Number(moveUp) - Number(moveDown);
        direction.normalize();
        
        // 设置移动速度
        const speed = 100.0;
        
        // 根据方向和速度更新速度向量
        if (moveForward || moveBackward) velocity.z -= direction.z * speed * delta;
        if (moveLeft || moveRight) velocity.x -= direction.x * speed * delta;
        if (moveUp || moveDown) velocity.y -= direction.y * speed * delta;
        
        // 应用阻尼（摩擦力）
        velocity.x -= velocity.x * 10.0 * delta;
        velocity.y -= velocity.y * 10.0 * delta;
        velocity.z -= velocity.z * 10.0 * delta;
        
        // 移动相机
        pointerLockControls.moveRight(-velocity.x * delta);
        pointerLockControls.moveForward(-velocity.z * delta);
        // 垂直移动
        camera.position.y -= velocity.y * delta;
        
        // 简单的高度限制
        if (camera.position.y < 5) {
            camera.position.y = 5;
            velocity.y = 0;
        }
        if (camera.position.y > 500) {
            camera.position.y = 500;
            velocity.y = 0;
        }
    }
    // 如果使用OrbitControls
    else if (controls) {
        controls.update();
    }
    
    prevTime = time;

    // 在前几秒强制更新材质（解决材质加载延迟问题）
    if (time < 3 && windTurbineModels.length > 0) {
        windTurbineModels.forEach(model => {
            model.traverse(function (child) {
                if (child.isMesh && child.material) {
                    if (child.material.needsUpdate !== undefined) {
                        child.material.needsUpdate = true;
                    }
                    // 持续调整材质亮度
                    if (child.material.emissive) {
                        child.material.emissiveIntensity = 0.3;
                    }
                }
            });
        });
    }
    // 更新水面动画 - 增强水面波动效果
    if (water && water.material.uniforms) {
        // 通过改变time值来控制水面波动动画
        water.material.uniforms['time'].value += 1.0 / 60.0;

        // 可选：增加波动速度和强度
        // water.material.uniforms['time'].value += 1.0 / 30.0;
    }

    // 风电机组动画
    if (windTurbineModels.length > 0) {
        windTurbineModels.forEach((model, index) => {
            // 每个风电机组有轻微的相位差，创造更自然的效果
            const phaseOffset = index * 0.2;
            // model.position.y = -3 + Math.sin(time * 0.5 + phaseOffset) * 1.5;

            // 叶片旋转动画
            // 如果还没有缓存旋转中心和初始偏移，先进行初始化
            if (!model.userData.rotorInitialized) {
                let rotorCenter = null;

                // 找到186部件作为旋转中心
                model.traverse((child) => {
                    if (child.name && child.name.toLowerCase().includes('186')) {
                        rotorCenter = child;
                    }
                });

                // 缓存旋转中心和叶片的初始偏移
                if (rotorCenter) {
                    model.userData.rotorCenter = rotorCenter;
                    model.userData.rotorCenterPosition = {
                        x: rotorCenter.position.x,
                        y: rotorCenter.position.y,
                        z: rotorCenter.position.z
                    };

                    // 为每个叶片计算并缓存初始偏移
                    model.traverse((child) => {
                        if (child.name && (child.name.toLowerCase().includes('200') ||
                            child.name.toLowerCase().includes('214') ||
                            child.name.toLowerCase().includes('228') ||
                            child.name.toLowerCase().includes('风轮'))) {

                            child.userData.initialOffset = {
                                x: child.position.x - rotorCenter.position.x,
                                y: child.position.y - rotorCenter.position.y,
                                z: child.position.z - rotorCenter.position.z
                            };
                        }
                    });
                }

                model.userData.rotorInitialized = true;
            }

            // 执行旋转动画
            model.traverse((child) => {
                // 如果是备用模型的旋转组
                if (child.name === 'rotor_group') {
                    child.rotation.x = time * 2.0; // 绕X轴旋转
                }
                // 如果是GLB模型的叶片部件
                else if (child.name && (child.name.toLowerCase().includes('200') ||
                    child.name.toLowerCase().includes('214') ||
                    child.name.toLowerCase().includes('228') ||
                    child.name.toLowerCase().includes('风轮'))) {

                    if (model.userData.rotorCenter && child.userData.initialOffset) {
                        // 使用缓存的旋转中心位置（固定不变）
                        const centerPos = model.userData.rotorCenterPosition;

                        // 输出第一个风电机组的centerPos到控制台
                        // if (index === 0 && child.name.toLowerCase().includes('200')) {
                        //     console.log('第一个风电机组的centerPos:', centerPos);
                        // }

                        const offset = child.userData.initialOffset;

                        // 围绕固定的旋转中心做圆周运动
                        const angle = time * 2.0;
                        const cosAngle = Math.cos(angle);
                        const sinAngle = Math.sin(angle);

                        child.position.x = centerPos.x + (offset.x * cosAngle - offset.y * sinAngle);
                        child.position.y = centerPos.y + (offset.x * sinAngle + offset.y * cosAngle) + 4;
                        child.position.z = centerPos.z + offset.z - 4;

                        // 同时让叶片自身也旋转
                        child.rotation.z = angle;
                    } else {
                        // 如果没有找到186部件，使用原来的旋转方式
                        child.rotation.z = time * 2.0;
                    }
                }
            });
        });
    }

    // 渲染场景
    if (scene && camera && renderer) {
        renderer.render(scene, camera);

        // 每隔一段时间输出渲染信息
        if (Math.floor(time) % 5 === 0 && time % 1 < 0.1) {
            console.log('正在渲染场景，时间:', Math.floor(time), '场景对象数量:', scene.children.length);
        }
    } else {
        console.warn('场景、相机或渲染器未初始化');
    }
}
// 窗口大小变化处理
function onWindowResize() {
    camera.aspect = window.innerWidth / window.innerHeight;
    camera.updateProjectionMatrix();
    renderer.setSize(window.innerWidth, window.innerHeight);
}

// 页面加载完成后初始化
window.addEventListener('DOMContentLoaded', function () {
    console.log('DOM加载完成，开始初始化Three.js场景');

    // 检查Three.js是否加载
    if (typeof THREE === 'undefined') {
        console.error('Three.js未加载！');
        document.getElementById('loading').innerHTML = '错误：Three.js库未加载';
        return;
    }

    console.log('Three.js版本:', THREE.REVISION);

    // 隐藏加载提示
    const loadingElement = document.getElementById('loading');
    if (loadingElement) {
        loadingElement.style.display = 'none';
    }

    init();
    animate();
});


// 添加一个切换控制模式的函数
function toggleControls() {
    if (pointerLockControls) {
        if (pointerLockControls.isLocked) {
            pointerLockControls.unlock();
        } else {
            pointerLockControls.lock();
        }
    }
}

// 键盘事件处理函数
function onKeyDown(event) {
    switch (event.code) {
        case 'ArrowUp':
        case 'KeyW':
            moveForward = true;
            break;
        case 'ArrowLeft':
        case 'KeyA':
            moveLeft = true;
            break;
        case 'ArrowDown':
        case 'KeyS':
            moveBackward = true;
            break;
        case 'ArrowRight':
        case 'KeyD':
            moveRight = true;
            break;
        case 'KeyQ':
            moveUp = true;
            break;
        case 'KeyE':
            moveDown = true;
            break;
    }
}

function onKeyUp(event) {
    switch (event.code) {
        case 'ArrowUp':
        case 'KeyW':
            moveForward = false;
            break;
        case 'ArrowLeft':
        case 'KeyA':
            moveLeft = false;
            break;
        case 'ArrowDown':
        case 'KeyS':
            moveBackward = false;
            break;
        case 'ArrowRight':
        case 'KeyD':
            moveRight = false;
            break;
        case 'KeyQ':
            moveUp = false;
            break;
        case 'KeyE':
            moveDown = false;
            break;
    }
}