File size: 4,520 Bytes
fa53282
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/* Real-time planar reflection for the existing MR mirror-door meshes. Geometry stays in the GLB. */
const MirrorReflections=(()=>{
  function reflect(point,normal,origin){return point.clone().addScaledVector(normal,-2*normal.dot(point.clone().sub(origin)));}
  function attach(viewer){
    const mirrors=[];
    viewer.model.traverse(object=>{if(object.isMesh&&String(object.userData.material||'').startsWith('MR-'))mirrors.push(object);});
    if(!mirrors.length)return null;
    const groups=new Map();
    for(const mesh of mirrors){
      const box=new THREE.Box3().setFromObject(mesh),center=box.getCenter(new THREE.Vector3()),extent=box.getSize(new THREE.Vector3());
      const axis=extent.x<extent.z?'x':'z',key=axis+':'+Math.round(center[axis]*1000);
      if(!groups.has(key))groups.set(key,{axis,point:center,meshes:[]});
      groups.get(key).meshes.push(mesh);
    }
    const entries=[];
    for(const group of groups.values()){
      const target=new THREE.WebGLRenderTarget(768,512,{depthBuffer:true,stencilBuffer:false});
      target.texture.generateMipmaps=false;
      const uniforms={reflection:{value:target.texture},projection:{value:new THREE.Matrix4()}};
      const material=new THREE.ShaderMaterial({uniforms,side:THREE.DoubleSide,
        vertexShader:'varying vec4 reflectionPoint; uniform mat4 projection; void main(){vec4 world=modelMatrix*vec4(position,1.0);reflectionPoint=projection*world;gl_Position=projectionMatrix*viewMatrix*world;}',
        fragmentShader:'uniform sampler2D reflection; varying vec4 reflectionPoint; void main(){vec2 uv=reflectionPoint.xy/reflectionPoint.w*0.5+0.5;vec3 color=texture2D(reflection,clamp(uv,0.001,0.999)).rgb;gl_FragColor=vec4(color,1.0);\n#include <tonemapping_fragment>\n#include <encodings_fragment>\n}',
      });
      for(const mesh of group.meshes){mesh.userData.mirrorMaterial=material;mesh.material=material;}
      entries.push({...group,target,material});
    }
    return {entries,mirrors};
  }
  function update(viewer){
    const state=viewer.mirrors;if(!state||viewer.white)return;
    const {renderer,scene,camera}=viewer;
    camera.updateMatrixWorld();
    const originalTarget=renderer.getRenderTarget(),originalClipping=renderer.clippingPlanes;
    const aspect=Math.max(0.5,Math.min(3,camera.aspect||renderer.domElement.clientWidth/Math.max(1,renderer.domElement.clientHeight)));
    const visibility=state.mirrors.map(mesh=>mesh.visible);
    for(const mirror of state.mirrors)mirror.visible=false;
    try{
      for(const entry of state.entries){
        if(!entry.meshes.some((mesh,i)=>visibility[state.mirrors.indexOf(mesh)]))continue;
        const height=512,width=Math.max(256,Math.min(1536,Math.round(height*aspect)));
        if(entry.target.width!==width||entry.target.height!==height)entry.target.setSize(width,height);
        const normal=new THREE.Vector3(entry.axis==='x'?1:0,0,entry.axis==='z'?1:0);
        if(normal.dot(camera.position.clone().sub(entry.point))<0)normal.negate();
        const reflected=camera.clone(),direction=new THREE.Vector3();camera.getWorldDirection(direction);
        reflected.position.copy(reflect(camera.position,normal,entry.point));
        reflected.up.copy(camera.up).reflect(normal);
        reflected.lookAt(reflect(camera.position.clone().add(direction),normal,entry.point));
        reflected.aspect=width/height;reflected.updateProjectionMatrix();reflected.updateMatrixWorld();
        entry.material.uniforms.projection.value.multiplyMatrices(reflected.projectionMatrix,reflected.matrixWorldInverse);
        renderer.clippingPlanes=[new THREE.Plane(normal,-normal.dot(entry.point))];
        renderer.setRenderTarget(entry.target);renderer.clear();renderer.render(scene,reflected);
        const stage=renderer.domElement.parentElement;if(stage){stage.dataset.mirrorPlanes=String(state.entries.length);stage.dataset.mirrorUpdates=String((Number(stage.dataset.mirrorUpdates)||0)+1);}
      }
    }finally{
      renderer.setRenderTarget(originalTarget);renderer.clippingPlanes=originalClipping;
      state.mirrors.forEach((mesh,i)=>mesh.visible=visibility[i]);
    }
  }
  function restore(viewer){if(!viewer.mirrors)return;for(const mesh of viewer.mirrors.mirrors)mesh.material=viewer.white?mesh.userData.whiteMaterial:mesh.userData.mirrorMaterial;}
  function dispose(viewer){if(!viewer.mirrors)return;for(const entry of viewer.mirrors.entries){entry.target.dispose();entry.material.dispose();}viewer.mirrors=null;}
  return {attach,update,restore,dispose};
})();