fromEquirectangularTexture method

Implementation

WebGLCubeRenderTarget fromEquirectangularTexture(WebGLRenderer renderer, Texture texture) {
  this.texture.type = texture.type;
  this.texture.colorSpace = texture.colorSpace;

  this.texture.generateMipmaps = texture.generateMipmaps;
  this.texture.minFilter = texture.minFilter;
  this.texture.magFilter = texture.magFilter;

  final shader = {
    "uniforms": {
      "tEquirect": <String,dynamic>{'value': null},
    },
    "vertexShader": """

      varying vec3 vWorldDirection;

      vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

        return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

      }

      void main() {

        vWorldDirection = transformDirection( position, modelMatrix );

        #include <begin_vertex>
        #include <project_vertex>

      }
    """,
    "fragmentShader": """

      uniform sampler2D tEquirect;

      varying vec3 vWorldDirection;

      #include <common>

      void main() {

        vec3 direction = normalize( vWorldDirection );

        vec2 sampleUV = equirectUv( direction );

        gl_FragColor = texture2D( tEquirect, sampleUV );

      }
    """
  };

  final geometry = BoxGeometry(5, 5, 5);
  final material = ShaderMaterial.fromMap({
    "name": 'CubemapFromEquirect',
    "uniforms": cloneUniforms(shader["uniforms"] as Map<String, dynamic>),
    "vertexShader": shader["vertexShader"],
    "fragmentShader": shader["fragmentShader"],
    "side": BackSide,
    "blending": NoBlending
  });

  material.uniforms["tEquirect"]["value"] = texture;

  final mesh = Mesh(geometry, material);

  final currentMinFilter = texture.minFilter;

  // Avoid blurred poles
  if (texture.minFilter == LinearMipmapLinearFilter) {
    texture.minFilter = LinearFilter;
  }

  final camera = CubeCamera(1, 10, this);
  camera.update(renderer, mesh);

  texture.minFilter = currentMinFilter;

  mesh.geometry!.dispose();
  mesh.material?.dispose();

  return this;
}