Babylon.js MirrorTexture实现3D动态反射效果详解

1. 理解MirrorTexture的核心原理

在3D图形学中，平面反射是一种通过模拟光线在光滑表面上的反射行为来增强场景真实感的技术。Babylon.js的MirrorTexture正是基于这一原理实现的动态反射解决方案。与传统的环境贴图不同，MirrorTexture能够实时捕捉场景中物体的反射图像，并根据视角变化动态更新。

MirrorTexture本质上是一个特殊的RenderTargetTexture（渲染目标纹理）。它的工作原理可以分解为以下几个关键步骤：

1. 反射平面定义：通过Plane对象确定反射面的位置和朝向
2. 反射矩阵计算：根据反射平面生成镜像变换矩阵
3. 场景渲染：将场景从反射视角渲染到临时纹理
4. 纹理应用：将生成的反射纹理应用到目标材质

这种实现方式相比静态环境贴图的最大优势在于能够准确反映动态物体的位置变化，特别适合水面、镜面等需要实时反射效果的场景。

注意：MirrorTexture的性能消耗主要来自每帧都需要重新渲染反射场景，因此必须谨慎控制反射质量和范围。

2. 工程准备与环境搭建

2.1 TypeScript项目初始化

要使用MirrorTexture，首先需要搭建一个支持TypeScript的Babylon.js开发环境。推荐使用VSCode作为开发工具，以下是具体步骤：

1. 创建新项目目录并初始化npm：

bash复制mkdir babylon-mirror-demo
cd babylon-mirror-demo
npm init -y

2. 安装必要依赖：

bash复制npm install @babylonjs/core @babylonjs/materials typescript webpack webpack-cli ts-loader --save-dev

3. 配置TypeScript编译器(tsconfig.json)：

json复制{
  "compilerOptions": {
    "target": "es6",
    "module": "es6",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

2.2 基础场景搭建

创建一个基本的3D场景作为反射效果的载体：

typescript复制import { Engine, Scene, ArcRotateCamera, Vector3, HemisphericLight } from '@babylonjs/core';

class MirrorDemo {
  private engine: Engine;
  private scene: Scene;

  constructor(canvas: HTMLCanvasElement) {
    this.engine = new Engine(canvas, true);
    this.scene = new Scene(this.engine);

    // 设置相机
    const camera = new ArcRotateCamera(
      "camera", 
      -Math.PI / 2, 
      Math.PI / 3, 
      10, 
      Vector3.Zero(), 
      this.scene
    );
    camera.attachControl(canvas, true);

    // 添加基础光照
    new HemisphericLight("light", new Vector3(0, 1, 0), this.scene);

    // 启动渲染循环
    this.engine.runRenderLoop(() => {
      this.scene.render();
    });

    // 响应窗口大小变化
    window.addEventListener('resize', () => {
      this.engine.resize();
    });
  }
}

// 初始化应用
const canvas = document.getElementById('renderCanvas') as HTMLCanvasElement;
new MirrorDemo(canvas);

3. MirrorTexture核心实现

3.1 创建反射平面

反射平面的创建需要考虑以下几个关键参数：

1. 几何形状：通常使用平面或细分程度较高的地面网格
2. 尺寸：根据场景需求确定，过大会影响性能
3. 细分级别：影响反射效果的平滑度

typescript复制private createMirrorSurface(): void {
  // 创建高细分度的地面作为反射面
  this.mirrorMesh = MeshBuilder.CreateGround(
    "mirrorSurface",
    {
      width: 10,
      height: 10,
      subdivisions: 32  // 较高的细分确保反射不失真
    },
    this.scene
  );

  // 定位反射平面（Y=0平面）
  this.mirrorMesh.position.y = 0;
}

3.2 初始化MirrorTexture

MirrorTexture的构造函数需要四个基本参数：

typescript复制private setupMirrorTexture(): void {
  this.mirrorTexture = new MirrorTexture(
    "mirrorTexture",  // 纹理名称
    1024,             // 纹理尺寸（宽度，高度自动相同）
    this.scene,       // 所属场景
    true              // 是否生成深度缓冲区
  );

  // 定义反射平面（Y=0平面，法向量朝下）
  this.mirrorTexture.mirrorPlane = Plane.FromPositionAndNormal(
    new Vector3(0, 0, 0),  // 平面经过的点
    new Vector3(0, -1, 0)  // 平面法向量（关键！必须指向反射面内部）
  );
}

3.3 配置反射材质

将MirrorTexture应用到材质上并调整反射属性：

typescript复制private applyMirrorMaterial(): void {
  const mirrorMaterial = new StandardMaterial("mirrorMat", this.scene);
  
  // 应用反射纹理
  mirrorMaterial.reflectionTexture = this.mirrorTexture;
  
  // 调整反射强度
  mirrorMaterial.reflectionTexture.level = 0.8;
  
  // 启用菲涅尔效应（视角相关的反射强度）
  mirrorMaterial.reflectionFresnelParameters = new FresnelParameters();
  mirrorMaterial.reflectionFresnelParameters.bias = 0.1;
  mirrorMaterial.reflectionFresnelParameters.power = 2;
  
  // 应用材质到反射平面
  this.mirrorMesh.material = mirrorMaterial;
}

4. 性能优化策略

4.1 反射物体筛选

控制哪些物体参与反射计算是优化性能的关键：

typescript复制private setupRenderList(): void {
  // 只选择特定层级的物体参与反射
  this.mirrorTexture.renderList = this.scene.meshes.filter(mesh => {
    // 排除不可见物体
    if (!mesh.isVisible) return false;
    
    // 排除反射平面自身
    if (mesh === this.mirrorMesh) return false;
    
    // 只包含Y坐标大于0的物体（假设反射平面在Y=0）
    return mesh.getBoundingInfo().boundingBox.maximumWorld.y > 0;
  });
}

4.2 动态分辨率调整

根据设备性能自动调整反射纹理分辨率：

typescript复制class DynamicResolutionController {
  private currentSize: number;
  private targetFPS = 60;
  
  constructor(private mirrorTexture: MirrorTexture, private scene: Scene) {
    this.currentSize = mirrorTexture.getSize().width;
    
    scene.onBeforeRenderObservable.add(() => {
      this.adjustResolution();
    });
  }
  
  private adjustResolution(): void {
    const fps = this.scene.getEngine().getFps();
    const delta = fps / this.targetFPS;
    
    // 性能不足时降低分辨率
    if (delta < 0.9 && this.currentSize > 256) {
      this.currentSize = Math.max(256, this.currentSize / 2);
      this.resizeTexture();
    } 
    // 性能充足时提高分辨率
    else if (delta > 1.1 && this.currentSize < 2048) {
      this.currentSize = Math.min(2048, this.currentSize * 2);
      this.resizeTexture();
    }
  }
  
  private resizeTexture(): void {
    // 注意：Babylon.js需要重新创建MirrorTexture来改变尺寸
    console.log(`调整反射纹理分辨率至: ${this.currentSize}px`);
    // 实际项目中需要实现纹理重建逻辑
  }
}

4.3 模糊效果优化

合理使用模糊可以在不明显降低质量的情况下提升性能：

typescript复制private configureBlurEffect(): void {
  // 根据平台选择模糊强度
  const isMobile = this.scene.getEngine().getRenderWidth() < 1024;
  
  this.mirrorTexture.blurKernel = isMobile ? 32 : 16;
  this.mirrorTexture.blurRatio = isMobile ? 0.5 : 0.8;
  
  // 启用自适应模糊
  this.mirrorTexture.adaptiveBlurKernel = 16;
}

5. 高级反射效果实现

5.1 PBR材质反射

使用物理渲染(PBR)材质实现更真实的反射效果：

typescript复制private createPBRMirror(): void {
  const pbrMaterial = new PBRMaterial("pbrMirror", this.scene);
  
  // 基础材质属性
  pbrMaterial.metallic = 0.9;
  pbrMaterial.roughness = 0.1;
  pbrMaterial.subSurface.isRefractionEnabled = false;
  
  // 反射设置
  pbrMaterial.reflectionTexture = this.mirrorTexture;
  pbrMaterial.reflectionTexture.level = 0.95;
  
  // 菲涅尔效果增强
  pbrMaterial.metallicF0 = 0.9;
  pbrMaterial.environmentIntensity = 1.0;
  
  this.mirrorMesh.material = pbrMaterial;
}

5.2 动态反射强度

根据视角和距离动态调整反射强度：

typescript复制class DynamicReflectionController {
  constructor(private material: StandardMaterial, private scene: Scene) {
    scene.onBeforeRenderObservable.add(() => {
      this.updateReflectionLevel();
    });
  }
  
  private updateReflectionLevel(): void {
    const camera = this.scene.activeCamera;
    if (!camera) return;
    
    // 计算相机与反射平面的距离
    const distance = Vector3.Distance(
      camera.position,
      this.material.getActiveMeshes()[0].position
    );
    
    // 距离越远反射越弱
    const distanceFactor = Math.max(0.3, 1 - distance / 50);
    
    // 计算视角与平面法线的夹角
    const angle = Vector3.GetAngleBetweenVectors(
      camera.getForwardRay().direction,
      new Vector3(0, 1, 0)
    );
    
    // 视角越倾斜反射越强（菲涅尔效应）
    const angleFactor = Math.sin(angle);
    
    // 综合计算最终反射强度
    this.material.reflectionTexture.level = distanceFactor * angleFactor * 0.8;
  }
}

6. 性能监控与调试

6.1 内置性能指标

Babylon.js提供了丰富的性能监控工具：

typescript复制private setupPerformanceMonitor(): void {
  const engine = this.scene.getEngine();
  const instrumentation = new EngineInstrumentation(engine);
  instrumentation.captureGPUFrameTime = true;
  
  // 每帧记录性能数据
  this.scene.onAfterRenderObservable.add(() => {
    const gpuTime = instrumentation.gpuFrameTimeCounter.current;
    const drawCalls = engine.getDrawCalls();
    
    console.log(`GPU时间: ${gpuTime.toFixed(2)}ms | Draw Calls: ${drawCalls}`);
    
    // 性能警告
    if (gpuTime > 16.67) { // 超过60FPS预算
      console.warn("性能警告：考虑优化反射设置");
    }
  });
}

6.2 调试反射平面

可视化反射平面有助于调试：

typescript复制private debugMirrorPlane(): void {
  // 创建可视化辅助平面
  const debugPlane = MeshBuilder.CreatePlane(
    "debugPlane",
    { size: 10 },
    this.scene
  );
  
  // 定位到反射平面位置
  debugPlane.position = this.mirrorMesh.position;
  debugPlane.rotation.x = Math.PI / 2;
  
  // 使用半透明材质
  const debugMat = new StandardMaterial("debugMat", this.scene);
  debugMat.alpha = 0.3;
  debugMat.wireframe = true;
  debugPlane.material = debugMat;
}

7. 实际应用案例

7.1 室内镜面效果

实现真实的室内镜面反射需要注意：

1. 避免反射递归（镜子互相反射）
2. 控制反射范围
3. 适当添加边缘模糊

typescript复制class IndoorMirror {
  constructor(scene: Scene, wall: Mesh) {
    // 在墙面上创建镜面
    const mirror = MeshBuilder.CreatePlane(
      "wallMirror",
      { width: 2, height: 1.5 },
      scene
    );
    
    // 将镜子嵌入墙面
    mirror.parent = wall;
    mirror.position.z = -0.1; // 稍微突出墙面
    
    // 创建MirrorTexture
    const mirrorTexture = new MirrorTexture(
      "wallMirrorTex",
      512,
      scene,
      true
    );
    
    // 设置反射平面（与镜面一致）
    mirrorTexture.mirrorPlane = Plane.FromPositionAndNormal(
      mirror.position,
      mirror.forward().negate()
    );
    
    // 限制反射范围
    mirrorTexture.renderList = scene.meshes.filter(m => {
      return m !== mirror && m !== wall && m.isVisible;
    });
    
    // 应用材质
    const mirrorMat = new StandardMaterial("wallMirrorMat", scene);
    mirrorMat.reflectionTexture = mirrorTexture;
    mirror.material = mirrorMat;
  }
}

7.2 动态水面反射

动态水面需要结合反射和折射效果：

typescript复制class WaterSurface {
  private waterMesh: Mesh;
  private mirrorTexture: MirrorTexture;
  
  constructor(scene: Scene, size: number = 20) {
    // 创建细分水面
    this.waterMesh = MeshBuilder.CreateGround(
      "water",
      { width: size, height: size, subdivisions: 64 },
      scene
    );
    
    // 创建反射纹理
    this.mirrorTexture = new MirrorTexture(
      "waterReflection",
      1024,
      scene,
      true
    );
    
    // 设置水面反射平面
    this.mirrorTexture.mirrorPlane = Plane.FromPositionAndNormal(
      new Vector3(0, 0, 0),
      new Vector3(0, -1, 0)
    );
    
    // 配置PBR水材质
    const waterMat = new PBRMaterial("waterMat", scene);
    waterMat.metallic = 0;
    waterMat.roughness = 0.15;
    waterMat.reflectionTexture = this.mirrorTexture;
    waterMat.reflectionTexture.level = 0.6;
    
    // 添加波浪法线贴图
    waterMat.bumpTexture = new Texture("assets/waterNormal.jpg", scene);
    waterMat.bumpTexture.level = 0.3;
    
    this.waterMesh.material = waterMat;
  }
}

8. 常见问题与解决方案

8.1 反射图像翻转或错位

问题现象：反射图像上下颠倒或位置不正确。

可能原因：

1. 反射平面法向量方向错误
2. 反射平面位置设置不当
3. 相机近裁剪面与反射平面相交

解决方案：

typescript复制// 确保法向量指向反射面内部
mirrorTexture.mirrorPlane = Plane.FromPositionAndNormal(
  new Vector3(0, 0, 0),  // 平面基点
  new Vector3(0, -1, 0)  // 必须指向反射面内部
);

// 调整相机近裁剪面
camera.minZ = 0.1; // 避免与反射平面重合

8.2 性能突然下降

问题现象：添加反射后帧率显著降低。

排查步骤：

1. 检查renderList是否包含过多物体
2. 确认纹理分辨率是否过高
3. 查看是否有不必要的模糊效果

优化代码：

typescript复制// 性能分析函数
function analyzeMirrorPerformance(mirrorTexture: MirrorTexture, scene: Scene) {
  console.log(`反射物体数量: ${mirrorTexture.renderList.length}`);
  console.log(`反射纹理尺寸: ${mirrorTexture.getSize().width}px`);
  console.log(`模糊强度: ${mirrorTexture.blurKernel}`);
  
  const drawCalls = scene.getEngine().getDrawCalls();
  console.log(`每帧Draw Calls: ${drawCalls}`);
}

8.3 反射边缘锯齿

问题现象：反射物体边缘出现锯齿状走样。

解决方案：

1. 提高反射纹理分辨率
2. 启用抗锯齿
3. 添加适当的模糊效果

typescript复制// 启用纹理抗锯齿
const engine = new Engine(canvas, true, {
  antialias: true,
  stencil: true
});

// 配置边缘模糊
mirrorTexture.blurKernel = 8;
mirrorTexture.adaptiveBlurKernel = 4;

9. 进阶技巧与最佳实践

9.1 反射代理技术

对于复杂场景，可以使用低模代理物体参与反射计算：

typescript复制class ReflectionProxy {
  private proxyMesh: Mesh;
  
  constructor(private originalMesh: Mesh, scene: Scene) {
    // 创建简化版本的网格
    this.proxyMesh = originalMesh.clone("proxy_" + originalMesh.name)!;
    
    // 简化几何体
    if (this.proxyMesh.geometry) {
      this.proxyMesh.geometry.simplify([
        { distance: 0.1, quality: 0.8 }
      ]);
    }
    
    // 隐藏代理网格
    this.proxyMesh.setEnabled(false);
    
    // 替换材质为简单反射材质
    const proxyMat = new StandardMaterial("proxyMat", scene);
    proxyMat.diffuseColor = new Color3(0.5, 0.5, 0.5);
    this.proxyMesh.material = proxyMat;
  }
  
  // 将代理网格添加到反射列表
  addToReflectionList(mirrorTexture: MirrorTexture) {
    mirrorTexture.renderList.push(this.proxyMesh);
  }
}

9.2 分帧渲染优化

将反射计算分散到多帧以减少单帧压力：

typescript复制class FrameDistributedReflection {
  private updateFrame = 0;
  
  constructor(private mirrorTexture: MirrorTexture, private interval: number = 3) {
    mirrorTexture.refreshRate = 1; // 手动控制更新
    
    mirrorTexture.onAfterRenderObservable.add(() => {
      this.updateFrame = 0;
    });
  }
  
  update() {
    this.updateFrame++;
    if (this.updateFrame % this.interval === 0) {
      this.mirrorTexture.render();
    }
  }
}

9.3 混合反射技术

结合MirrorTexture和静态环境贴图实现平衡：

typescript复制function createHybridReflectionMaterial(scene: Scene) {
  const material = new PBRMaterial("hybridMat", scene);
  
  // 静态环境贴图（基础反射）
  const envTexture = new CubeTexture("assets/env.dds", scene);
  material.reflectionTexture = envTexture;
  material.reflectionTexture.level = 0.3;
  
  // 动态MirrorTexture（细节反射）
  const mirrorTexture = new MirrorTexture("hybridMirror", 512, scene, true);
  material.reflectionTexture = mirrorTexture;
  material.reflectionTexture.level = 0.5;
  
  // 混合权重控制
  material.reflectionFresnelParameters = new FresnelParameters();
  material.reflectionFresnelParameters.bias = 0.1;
  
  return material;
}

10. 平台特定优化

10.1 移动端适配

移动设备需要特殊的优化策略：

typescript复制class MobileMirrorOptimizer {
  constructor(scene: Scene) {
    const engine = scene.getEngine();
    const isMobile = engine.getRenderWidth() < 1024;
    
    if (isMobile) {
      // 降低反射纹理分辨率
      const mirrorTexture = new MirrorTexture("mobileMirror", 512, scene, true);
      
      // 强制开启模糊
      mirrorTexture.blurKernel = 32;
      mirrorTexture.blurRatio = 0.5;
      
      // 限制反射距离
      mirrorTexture.renderList = scene.meshes.filter(mesh => {
        const distance = Vector3.Distance(
          mesh.getAbsolutePosition(),
          scene.activeCamera!.position
        );
        return distance < 20;
      });
      
      // 降低更新频率
      mirrorTexture.refreshRate = 2; // 每两帧更新一次
    }
  }
}

10.2 WebGL 1.0回退方案

对于不支持WebGL 2.0的设备：

typescript复制function createFallbackMirror(scene: Scene) {
  // 检查WebGL版本
  const isWebGL1 = scene.getEngine().webGLVersion === 1;
  
  if (isWebGL1) {
    console.warn("WebGL 1.0 detected - using fallback reflection");
    
    // 使用静态环境贴图替代
    const envTexture = new CubeTexture("assets/fallbackEnv.dds", scene);
    const material = new StandardMaterial("fallbackMat", scene);
    material.reflectionTexture = envTexture;
    material.reflectionTexture.level = 0.5;
    
    return material;
  }
  
  // 正常使用MirrorTexture
  return new MirrorTexture("mirror", 1024, scene, true);
}

11. 性能对比数据

下表展示了不同配置下的性能表现（测试场景：20个物体，中端显卡）：

12. 调试工具与技巧

12.1 反射可视化调试

typescript复制function debugMirrorTexture(mirrorTexture: MirrorTexture, scene: Scene) {
  // 创建调试平面
  const debugPlane = MeshBuilder.CreatePlane(
    "debugMirrorView",
    { width: 5, height: 5 },
    scene
  );
  
  // 定位到相机前方
  debugPlane.position = scene.activeCamera!.position.add(
    scene.activeCamera!.getForwardRay(5).direction
  );
  debugPlane.lookAt(scene.activeCamera!.position);
  
  // 显示反射纹理内容
  const debugMat = new StandardMaterial("debugMat", scene);
  debugMat.emissiveTexture = mirrorTexture;
  debugMat.disableLighting = true;
  debugPlane.material = debugMat;
}

12.2 性能热点分析

使用Chrome DevTools进行CPU分析：

1. 打开Performance面板
2. 开始记录
3. 与场景交互
4. 停止记录并分析调用栈

重点关注：

• MirrorTexture._renderForMirrorTexture调用
• 纹理上传时间
• 着色器编译时间

13. 资源管理与清理

正确释放MirrorTexture相关资源：

typescript复制class MirrorResourceManager {
  private textures: MirrorTexture[] = [];
  private meshes: Mesh[] = [];
  
  registerTexture(texture: MirrorTexture) {
    this.textures.push(texture);
  }
  
  registerMesh(mesh: Mesh) {
    this.meshes.push(mesh);
  }
  
  disposeAll() {
    // 释放所有纹理
    this.textures.forEach(texture => {
      texture.dispose();
    });
    
    // 释放所有网格
    this.meshes.forEach(mesh => {
      mesh.dispose();
    });
    
    // 清空数组
    this.textures = [];
    this.meshes = [];
  }
}

14. 测试与质量保证

14.1 单元测试要点

为反射功能编写测试用例时应关注：

1. 反射平面法向量正确性
2. 反射物体筛选逻辑
3. 性能边界条件
4. 资源释放验证

typescript复制describe('MirrorTexture', () => {
  it('should correctly filter reflection objects', () => {
    const scene = new Scene(new Engine());
    const mirror = new MirrorTexture("test", 256, scene, true);
    
    // 创建测试物体
    const visibleMesh = MeshBuilder.CreateBox("visible", {}, scene);
    const hiddenMesh = MeshBuilder.CreateBox("hidden", {}, scene);
    hiddenMesh.isVisible = false;
    
    // 设置反射列表
    mirror.renderList = [visibleMesh];
    
    // 验证
    expect(mirror.renderList).toContain(visibleMesh);
    expect(mirror.renderList).not.toContain(hiddenMesh);
  });
});

14.2 性能回归测试

建立性能基准并监控变化：

typescript复制function runPerformanceBenchmark(scene: Scene, iterations = 100) {
  const engine = scene.getEngine();
  const startTime = performance.now();
  let totalFrames = 0;
  
  // 测试循环
  const interval = setInterval(() => {
    scene.render();
    totalFrames++;
    
    if (totalFrames >= iterations) {
      clearInterval(interval);
      const duration = (performance.now() - startTime) / 1000;
      const avgFPS = totalFrames / duration;
      
      console.log(`平均FPS: ${avgFPS.toFixed(1)}`);
      console.log(`Draw Calls: ${engine.getDrawCalls()}`);
    }
  }, 0);
}

15. 项目集成建议

15.1 架构设计考虑

在大型项目中集成MirrorTexture时建议：

1. 创建专门的ReflectionManager集中管理所有反射表面
2. 实现LOD(Level of Detail)系统动态调整反射质量
3. 使用对象池复用MirrorTexture实例
4. 建立性能预算并监控

15.2 资源打包策略

针对不同平台打包不同的反射配置：

typescript复制function getPlatformSpecificConfig() {
  const isMobile = /Mobile|Android|iOS/.test(navigator.userAgent);
  
  return {
    textureSize: isMobile ? 512 : 1024,
    blurKernel: isMobile ? 32 : 16,
    maxReflectionDistance: isMobile ? 20 : 50,
    updateInterval: isMobile ? 2 : 1
  };
}

16. 扩展阅读与资源

16.1 推荐学习资料

1. Babylon.js官方文档：MirrorTexture专题
2. 《Real-Time Rendering》反射章节
3. WebGL反射技术白皮书
4. GPU Gems中的反射优化技巧

16.2 实用工具推荐

1. Spector.js - WebGL调试工具
2. Babylon.js Sandbox - 快速原型测试
3. RenderDoc - 图形调试器
4. WebGL Inspector - 性能分析工具

17. 版本兼容性说明

不同Babylon.js版本的MirrorTexture特性差异：

18. 社区经验分享

来自实际项目的几点经验：

1. 避免多层反射：镜子互相反射会导致性能指数级下降
2. 慎用动态反射：静态场景考虑使用预烘焙环境贴图
3. 注意内存泄漏：MirrorTexture需要手动释放
4. 测试低端设备：中高端PC上流畅不等于移动端可用

19. 未来发展方向

1. 基于光线追踪的混合反射
2. 机器学习驱动的反射降噪
3. 自适应反射分辨率技术
4. WebGPU原生实现

20. 总结与个人实践

在实际项目中使用MirrorTexture的关键点：

1. 性能第一：始终监控反射对帧率的影响
2. 合理筛选：严格控制renderList中的物体数量
3. 动态调整：根据设备能力自动适配质量
4. 渐进增强：为低端设备提供回退方案

一个实用的建议是建立"反射质量"参数系统，允许用户在性能和画质之间进行权衡：

typescript复制enum ReflectionQuality {
  Low = 0,    // 512px, 强模糊
  Medium = 1, // 1024px, 中等模糊
  High = 2    // 2048px, 无模糊
}

function setReflectionQuality(quality: ReflectionQuality) {
  switch(quality) {
    case ReflectionQuality.Low:
      mirrorTexture.resize(512);
      mirrorTexture.blurKernel = 32;
      break;
    case ReflectionQuality.Medium:
      mirrorTexture.resize(1024);
      mirrorTexture.blurKernel = 16;
      break;
    case ReflectionQuality.High:
      mirrorTexture.resize(2048);
      mirrorTexture.blurKernel = 0;
      break;
  }
}