Source: scene/deprecated/environment_map.js

import {
    Reporter,
	checkPropTypes,
    WrappedImage,
    WrappedEXR,
    BuildableComponent
} from '../main.js';

import { Component } from '../component/component.js';

import { UUIDRegex } from '../lib.js';

import {
    PMREMGenerator,
    TextureLoader,
    Texture,
    CubeTexture,
    WebGLRenderer,
    CubeTextureLoader,
    sRGBEncoding,
    DefaultLoadingManager
} from '../../node_modules/three/build/three.module.js';


import { ConfigurationSettings } from '../package/configuration_settings.js';


class EnvironmentMap extends BuildableComponent {   
    
    /**
     * @param {Reporter} reporter
     * @param {Object} settings
     * @param {UUID} [settings.id] 
     * @param {WebGLRenderer} [ settings.renderer ]
     * @param {WrappedEXR} settings.exrMap
     * @param {WrappedImage} [settings.pngMap]
     * @param {CubeTexture} [settings.cubeMap]
     * @param {PMREMGenerator} [settings.pmremGenerator]                                           
     */

    constructor( reporter, settings ) {

        super( reporter, settings );

        checkPropTypes(
            settings,
            {
                exrMap: WrappedEXR,
            },    
            {
                id: UUIDRegex,
                name: "string",
                pmremGenerator: PMREMGenerator,
                
                pngMap: WrappedImage,
                cubeMap: CubeTexture,
            }
        );

        //this._pmremGenerator = settings.pmremGenerator
        //console.log( this._pmremGenerator )

    }    

    static _exportName = {
        singular: 'environment map',
        plural: 'environment maps'
    };


    /**
     * Build Cube Texture
     * @method
     * @param {LoadingQuality} quality
     * @returns {Promise<Component>}
     */

    //pmremGenerator = this._pmremGenerator
    
    async _buildEXR( renderer, exr ) { //, part, quality, dependencies

        //this.report({ msg: `Building ${quality} ${part}` });
        
        //console.log( exr )
        const pmremGenerator = new PMREMGenerator( renderer ) 
        await pmremGenerator.compileEquirectangularShader();
        //console.log( pmremGenerator )
                          
        const exrCubeRenderTarget = await pmremGenerator.fromEquirectangular( exr._content.main.medium );  // dependencies.image.content.main[quality];
        
        const exrEnvironmentMap = exrCubeRenderTarget.texture;
        exrEnvironmentMap.needsUpdate = true;
        //console.log( exrEnvironmentMap  )

        this._envMap = exrEnvironmentMap
        
        //this._setContent('main', 'medium', exrEnvironmentMap);

        return this

    };

    /**
    * @param {WebGLRenderer} renderer
	* @param {WrappedImage} pngMap
    */
    
    async _buildEnvMapPNG( renderer, pngMap ){

        //pngMap.encoding = sRGBEncoding;

        DefaultLoadingManager.onLoad = function ( ) {
            pmremGenerator.dispose();
        };

        const pmremGenerator = new PMREMGenerator( renderer );
        pmremGenerator.compileEquirectangularShader();
        
        const pngCubeRenderTarget = pmremGenerator.fromEquirectangular( pngMap._content.main.medium.img );
        const pngEnvironmentMap = pngCubeRenderTarget.texture;

        renderer.dispose();

        this._envMap = pngEnvironmentMap;

        //this._setContent( part, quality, content )

    };

    /**
	* @param {CubeTexture} cubeMap
    */

    async _buildEnvMapCube( image ){

		const loader = new CubeTextureLoader();
		loader.setPath( image.path ); //'resources/textures/cube/pisa/'
		const cubeMap = loader.load( [
			'px.png', 'nx.png',
			'py.png', 'ny.png',
			'pz.png', 'nz.png'
        ] );
        
        this._envMap = cubeMap

        

    }

}

export { EnvironmentMap };