bg2e-js 2.1.2 → 2.2.1

package/src/shaders/BasicDiffuseColorShader.ts

@@ -0,0 +1,111 @@
+import Shader from "../render/Shader";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+import Texture, { ProceduralTextureFunction } from "../base/Texture";
+import Vec from "../math/Vec";
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Mat4 from "../math/Mat4";
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+import TextureRenderer from "../render/TextureRenderer";
+import WebGLTextureRenderer from "../render/webgl/TextureRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+
+        attribute vec3 vertPosition;
+        attribute vec2 t0Position;
+        
+        varying vec2 fragT0Pos;
+
+        uniform mat4 mWorld;
+        uniform mat4 mView;
+        uniform mat4 mProj;
+
+        void main() {
+            fragT0Pos = t0Position;
+            gl_Position = mProj * mView * mWorld * vec4(vertPosition, 1.0);
+        }`,
+
+        fragment: `
+        precision mediump float;
+
+        varying vec2 fragT0Pos;
+
+        uniform vec3 uFixedColor;
+        uniform sampler2D uTexture;
+
+        void main() {
+            vec4 texColor = texture2D(uTexture, fragT0Pos);
+            gl_FragColor = vec4(texColor.rgb * uFixedColor, 1.0);
+        }`
+    }
+}
+
+export default class BasicDiffuseColorShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+    protected _whiteTexture!: Texture;
+    protected _whiteTextureRenderer!: TextureRenderer;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("BasicDiffuseColorShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+        this._program = new ShaderProgram(gl, "BasicDiffuseColorShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+
+        this._whiteTexture = new Texture();
+        this._whiteTexture.proceduralFunction = ProceduralTextureFunction.PLAIN_COLOR;
+        this._whiteTexture.proceduralParameters = [1,1,1,1];
+        this._whiteTexture.size = new Vec(4,4);
+        await this._whiteTexture.loadImageData();
+        this._whiteTextureRenderer = this.renderer.factory.texture(this._whiteTexture);
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("BasicDiffuseColorShader: shader program is not loaded");
+        }
+
+        const { material } = materialRenderer;
+        const rend = this.renderer as WebGLRenderer;
+        rend.state.shaderProgram = this._program;
+
+        this._program.uniformMatrix4fv('mWorld', false, modelMatrix);
+        this._program.uniformMatrix4fv('mView', false, viewMatrix);
+        this._program.uniformMatrix4fv('mProj', false, projectionMatrix);
+
+        this._program.uniform1i('uTexture', 0);
+        let texRenderer = materialRenderer.getTextureRenderer('albedoTexture') || this._whiteTextureRenderer;
+        this._program.uniform3fv('uFixedColor', material.albedo.rgb);
+        
+        (texRenderer as WebGLTextureRenderer).activeTexture(0);
+        (texRenderer as WebGLTextureRenderer).bindTexture();
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("vertPosition"));
+        this._program.texCoordAttribPointer((plistRenderer as WebGLPolyListRenderer).texCoord0AttribParams("t0Position"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}

package/src/shaders/BasicPBRLightShader.ts

@@ -0,0 +1,277 @@
+import Shader from "../render/Shader";
+
+// TODO: Deprecated. Use ./webgl/index.ts instead
+import { pbrPointLight, pbrDirectionalLight } from './webgl_shader_lib';
+
+import {
+    getColorCorrectionFunctions,
+    getNormalMapFunctions,
+    getPBRFunctions,
+    getUniformsFunctions,
+    replaceConstants
+} from "./webgl";
+
+import ShaderFunction from "./ShaderFunction";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+import Mat4 from "../math/Mat4";
+import Vec from "../math/Vec";
+import Light, { LightType } from "../base/Light";
+import { createNormalTexture, normalTexture } from "../tools/TextureResourceDatabase";
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLMaterialRenderer from "../render/webgl/MaterialRenderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+function getShaderProgramForLights(this: BasicPBRLightShader, renderer: Renderer, numLights: number): ShaderProgram {
+    const r = renderer as WebGLRenderer;
+
+    if (this._programs[numLights]) {
+        return this._programs[numLights];
+    }
+
+    const vshader = ShaderFunction.GetShaderCode(`precision mediump float;
+        attribute vec3 inPosition;
+        attribute vec3 inNormal;
+        attribute vec2 inTexCoord;
+        attribute vec3 inTangent;
+
+        uniform mat4 uWorld;
+        uniform mat4 uView;
+        uniform mat4 uProj;
+        uniform mat3 uNormMatrix;
+
+        varying vec3 fragPos;
+        varying vec3 fragNorm;
+        varying vec2 fragTexCoord;
+        varying vec3 fragTangent;
+        varying vec3 fragBitangent;
+        `,
+        [
+            new ShaderFunction('void','main','',`{
+                fragPos = (uWorld * vec4(inPosition, 1.0)).xyz;
+                fragNorm = normalize(uNormMatrix * inNormal);
+                fragTangent = normalize(uNormMatrix * inTangent);
+                fragBitangent = normalize(fragNorm * fragTangent);
+                fragTexCoord = inTexCoord;
+                gl_Position = uProj * uView * uWorld * vec4(inPosition,1.0);
+            }`)
+        ]);
+
+    const fshader = ShaderFunction.GetShaderCode(`precision mediump float;
+        varying vec3 fragPos;
+        varying vec3 fragNorm;
+        varying vec2 fragTexCoord;
+        varying vec3 fragTangent;
+        varying vec3 fragBitangent;
+
+        uniform vec3 uCameraPos;
+
+        uniform sampler2D uAlbedoTexture;
+        uniform sampler2D uNormalTexture;
+        uniform sampler2D uMetallicTexture;
+        uniform sampler2D uRoughnessTexture;
+
+        uniform vec4 uAlbedo;
+        uniform float uMetallic;
+        uniform float uRoughness;
+
+        uniform vec2 uAlbedoScale;
+        uniform vec2 uNormalScale;
+        uniform vec2 uMetallicScale;
+        uniform vec2 uRoughnessScale;
+        
+        uniform int uLightTypes[${numLights}];
+        uniform vec3 uLightPositions[${numLights}];
+        uniform vec3 uLightDirections[${numLights}];
+        uniform vec3 uLightColors[${numLights}];
+        uniform float uLightIntensities[${numLights}];
+        `,
+        [
+            new ShaderFunction('void','main','',`{
+                vec3 N = normalize(fragNorm);
+                if (!gl_FrontFacing) {
+                    N = -N;
+                }
+                vec3 T = normalize(fragTangent);
+                vec3 B = normalize(fragBitangent);
+                mat3 TBN = mat3(T,B,N);
+
+                vec3 albedo = texture2D(uAlbedoTexture, fragTexCoord * uAlbedoScale).rgb * uAlbedo.rgb;
+                vec3 normal = texture2D(uNormalTexture, fragTexCoord * uNormalScale).rgb * 2.0 - 1.0;
+                float metallic = texture2D(uMetallicTexture, fragTexCoord * uMetallicScale).r * uMetallic;
+                float roughness = max(texture2D(uRoughnessTexture, fragTexCoord * uRoughnessScale).r * uRoughness, 0.05);
+
+                N = normalize(TBN * normal);
+                vec3 V = normalize(uCameraPos - fragPos);
+
+                vec3 Lo = vec3(0.0);
+                for (int i = 0; i < ${numLights}; ++i)
+                {
+                    if (uLightTypes[i] == ${ LightType.POINT }) {
+                        Lo += pbrPointLight(
+                            uLightPositions[i], uLightColors[i] * uLightIntensities[i], fragPos, N, V,
+                            albedo, roughness, metallic, vec3(1.0));
+                    }
+                    else if (uLightTypes[i] == ${ LightType.DIRECTIONAL }) {
+                        Lo += pbrDirectionalLight(
+                            uLightDirections[i], uLightColors[i] * uLightIntensities[i], fragPos, N, V,
+                            albedo, roughness, metallic, vec3(1.0), vec3(1.0));
+                    }
+                }
+
+                vec3 ambient = vec3(0.03) * albedo;
+                vec3 color = ambient + Lo;
+                color = color / (color + vec3(1.0));
+                color = pow(color, vec3(1.0/2.2));
+
+                gl_FragColor = vec4(color,1.0);
+            }`, [pbrPointLight, pbrDirectionalLight])
+        ]);
+
+    this._programs[numLights] = ShaderProgram.Create(r.gl,"PBRBasicLight",vshader,fshader);
+    return this._programs[numLights];
+}
+export default class BasicPBRLightShader extends Shader {
+    protected _programs: { [key: number]: ShaderProgram };
+    protected _lights: Light[];
+    protected _lightTypes: LightType[] = [];
+    protected _lightPositions: Vec[] = [];
+    protected _lightDirections: Vec[] = [];
+    protected _lightColors: Vec[] = [];
+    protected _lightIntensities: number[] = [];
+    protected _cameraPosition: Vec | null = null;
+    protected _program: ShaderProgram | null = null;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        this._lights = [];
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("BasicPBRLightShader is only compatible with WebGL renderer");
+        }
+
+        this._programs = {};
+    }
+
+    async load() {
+        await createNormalTexture(this.renderer);
+    }
+
+    set cameraPosition(p: Vec) {
+        this._cameraPosition = p;
+    }
+
+    set lights(l: Light[]) {
+        if (!l.length) {
+            throw new Error("BasicPBRLightShader: Invalid light array set.");
+        }
+        this._lights = l;
+        this._lightTypes = [];
+        this._lightPositions = [];
+        this._lightDirections = [];
+        this._lightColors = [];
+        this._lightIntensities = [];
+        this._lights.forEach(light => {
+            this._lightTypes.push(light.type);
+            this._lightPositions.push(new Vec(light.position));
+            this._lightDirections.push(new Vec(light.direction));
+            this._lightColors.push(new Vec(light.color));
+            this._lightIntensities.push(light.intensity);
+        });
+        this._program = getShaderProgramForLights.apply(this, [this.renderer, this._lights.length]);
+    }
+
+    get lights() {
+        return this._lights;
+    }
+
+    updateLight(light: Light, index: number) {
+        if (index >= this._lights.length) {
+            throw new Error("BasicPBRLightShader: Invalid light index updating light data");
+        }
+        this._lightTypes[index] = light.type;
+        this._lightPositions[index] = new Vec(light.position);
+        this._lightDirections[index] = new Vec(light.direction);
+        this._lightColors[index] = new Vec(light.color);
+        this._lightIntensities[index] = light.intensity;
+    }
+
+    updateLights(lights: Light[]) {
+        if (this._lights.length !== lights.length) {
+            this.lights = lights;
+        }
+        else {
+            lights.forEach((l,i) => this.updateLight(l,i));
+        }
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("BasicPBRLightShader: lights array not specified");
+        }
+
+        const material = materialRenderer.material;
+        const rend = this.renderer as WebGLRenderer;
+        rend.state.shaderProgram = this._program;
+        
+        const normMatrix = Mat4.GetNormalMatrix(modelMatrix);
+        this._program.bindMatrix('uNormMatrix', normMatrix);
+        this._program.bindMatrix('uWorld', modelMatrix);
+        this._program.bindMatrix('uView', viewMatrix);
+        this._program.bindMatrix('uProj', projectionMatrix);
+
+        if (!this._cameraPosition) {
+            console.warn("Serious performance warning: camera position not set in BasicPBRLightShader. Extracting the camera position from the view matrix involves inverting the matrix.");
+            this._program.bindVector('uCameraPos',Mat4.GetPosition(Mat4.GetInverted(viewMatrix)));
+        }
+        else {
+            this._program.bindVector('uCameraPos',this._cameraPosition);
+        }
+
+        (materialRenderer as WebGLMaterialRenderer).bindTexture(this._program, 'albedoTexture', 'uAlbedoTexture', 0);
+        (materialRenderer as WebGLMaterialRenderer).bindTexture(this._program, 'normalTexture', 'uNormalTexture', 1, normalTexture(this.renderer));
+        (materialRenderer as WebGLMaterialRenderer).bindTexture(this._program, 'metalnessTexture', 'uMetallicTexture', 2);
+        (materialRenderer as WebGLMaterialRenderer).bindTexture(this._program, 'roughnessTexture', 'uRoughnessTexture', 3);
+
+        (materialRenderer as WebGLMaterialRenderer).bindColor(this._program, 'albedo', 'uAlbedo');
+        (materialRenderer as WebGLMaterialRenderer).bindValue(this._program, 'metalness', 'uMetallic');
+        (materialRenderer as WebGLMaterialRenderer).bindValue(this._program, 'roughness', 'uRoughness');
+        
+        
+        this._program.bindVector("uAlbedoScale", material.albedoScale);
+        this._program.bindVector("uNormalScale", material.normalScale);
+        this._program.bindVector("uMetallicScale", material.metalnessScale);
+        this._program.bindVector("uRoughnessScale", material.roughnessScale);
+
+        this._lights.forEach((light,i) => {
+            this._program?.uniform1i(`uLightTypes[${i}]`, this._lightTypes[i]);
+            this._program?.bindVector(`uLightPositions[${i}]`, this._lightPositions[i]);
+            this._program?.bindVector(`uLightDirections[${i}]`, this._lightDirections[i]);
+            this._program?.bindVector(`uLightColors[${i}]`, this._lightColors[i].rgb);
+            this._program?.uniform1f(`uLightIntensities[${i}]`, this._lightIntensities[i]);
+        });
+
+        this._program.bindAttribs(plistRenderer as WebGLPolyListRenderer, {
+            position: "inPosition",
+            normal: "inNormal",
+            tex0: "inTexCoord",
+            tangent: "inTangent"
+        });
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}

package/src/shaders/DebugRenderShader.ts

@@ -0,0 +1,98 @@
+import Shader from "../render/Shader";
+import ShaderFunction from "./ShaderFunction";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Mat4 from "../math/Mat4";
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+        
+        attribute vec3 position;
+        attribute vec2 texCoord;
+
+        uniform mat4 uModelMatrix;
+        uniform mat4 uViewMatrix;
+        uniform mat4 uProjMatrix;
+
+        varying vec2 fragTexCoord;
+        
+        void main() {
+            fragTexCoord = texCoord;
+            gl_Position = uProjMatrix * uViewMatrix * uModelMatrix * vec4(position, 1.0);
+        }`,
+
+        fragment: ShaderFunction.GetShaderCode(
+            `precision mediump float;
+
+            varying vec2 fragTexCoord;
+            uniform vec4 uColor;
+            uniform sampler2D uTexture;
+            `,
+            [
+                new ShaderFunction('void','main','',`{
+                    vec4 color = texture2D(uTexture, fragTexCoord);
+                    gl_FragColor = uColor;
+                }`)
+            ])
+    }
+}
+
+export default class DebugRenderShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("DebugRenderShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "DebugRenderShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("DebugRenderShader: shader program is not loaded");
+        }
+
+        const { material } = materialRenderer;
+        const rend = this.renderer as WebGLRenderer;
+        
+        rend.state.shaderProgram = this._program;
+        this._program.uniform1i("uTexture", 0);
+        this._program.bindMatrix("uModelMatrix", modelMatrix);
+        this._program.bindMatrix("uViewMatrix", viewMatrix);
+        this._program.bindMatrix("uProjMatrix", projMatrix);
+
+        this._program.bindVector("uColor", material.albedo);
+        
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("position"));
+        this._program.texCoordAttribPointer((plistRenderer as WebGLPolyListRenderer).texCoord0AttribParams("texCoord"));
+        
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}

package/src/shaders/DepthRenderShader.ts

@@ -0,0 +1,91 @@
+import Shader from "../render/Shader";
+import ShaderFunction from "./ShaderFunction";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Mat4 from "../math/Mat4";
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision mediump float;
+        attribute vec3 position;
+        attribute vec2 texCoord;
+
+        uniform mat4 uModelMatrix;
+        uniform mat4 uViewMatrix;
+        uniform mat4 uProjMatrix;
+
+        varying vec2 fragTexCoord;
+        
+        void main() {
+            fragTexCoord = texCoord;
+            gl_Position = uProjMatrix * uViewMatrix * uModelMatrix * vec4(position, 1.0);
+        }`,
+
+        fragment: ShaderFunction.GetShaderCode(
+            `precision mediump float;
+            
+            varying vec2 fragTexCoord;
+            `,
+            [
+                new ShaderFunction('void','main','',`{
+                    float d = gl_FragCoord.z / gl_FragCoord.w;
+                    gl_FragColor = vec4(d, d, d, 1.0);
+                }`)
+            ])
+    }
+}
+
+export default class DepthRenderShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("DepthRenderShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "DepthRenderShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment);
+        this._program.link();
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("DepthRenderShader: shader program is not loaded");
+        }
+
+        const rend = this.renderer as WebGLRenderer;
+        rend.state.shaderProgram = this._program;
+
+        this._program.bindMatrix("uModelMatrix", modelMatrix);
+        this._program.bindMatrix("uViewMatrix", viewMatrix);
+        this._program.bindMatrix("uProjMatrix", projMatrix);
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("position"));
+        this._program.texCoordAttribPointer((plistRenderer as WebGLPolyListRenderer).texCoord0AttribParams("texCoord"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}
+

package/src/shaders/IrradianceMapCubeShader.ts

@@ -0,0 +1,116 @@
+
+import Shader from "../render/Shader";
+import ShaderProgram from "../render/webgl/ShaderProgram";
+import PolyListRenderer from '../render/PolyListRenderer';
+import MaterialRenderer from '../render/MaterialRenderer';
+import Mat4 from "../math/Mat4";
+import Renderer from "../render/Renderer";
+import WebGLRenderer from "../render/webgl/Renderer";
+import WebGLTextureRenderer from "../render/webgl/TextureRenderer";
+import WebGLPolyListRenderer from "../render/webgl/PolyListRenderer";
+
+const g_code = {
+    webgl: {
+        vertex: `precision  mediump float;
+        
+        attribute vec3 vertPosition;
+        
+        uniform mat4 uMVP;
+        
+        varying vec3 fragNormal;
+
+        void main() {
+            gl_Position = uMVP * vec4(vertPosition, 1.0);
+            fragNormal = normalize(vertPosition);
+        }
+        `,
+
+        fragment: (sampleDelta: number) => `precision mediump float;
+        varying vec3 fragNormal;
+        
+        uniform samplerCube uCubemap;
+        
+        void main() {
+            vec3 normal = normalize(fragNormal);
+            vec3 irradiance = vec3(0.0);
+
+            vec3 up = vec3(0.0, 1.0, 0.0);
+            vec3 right = cross(up, normal);
+            up = cross(normal,right);
+
+            float nrSamples = 0.0;
+            for (float phi = 0.0; phi < ${ 2 * Math.PI }; phi += ${ sampleDelta })
+            {
+                for (float theta = 0.0; theta < ${ 0.5 * Math.PI }; theta += ${ sampleDelta })
+                {
+                    // Spherical to cartesian
+                    vec3 tangentSample = vec3(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
+
+                    // tangent space to world space
+                    vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * normal;
+
+                    irradiance += textureCube(uCubemap, sampleVec).rgb * cos(theta) * sin(theta);
+                    nrSamples++;
+                }
+            }
+            irradiance = ${ Math.PI } * irradiance * (1.0 / float(nrSamples));
+
+            gl_FragColor = vec4(irradiance, 1.0);
+        }`
+    }
+};
+
+export default class IrradianceMapCubeShader extends Shader {
+    protected _program: ShaderProgram | null = null;
+
+    constructor(renderer: Renderer) {
+        super(renderer);
+
+        if (renderer.typeId !== "WebGL") {
+            throw Error("IrradianceMapCubeShader is only compatible with WebGL renderer");
+        }
+    }
+
+    async load() {
+        const { gl } = (this.renderer as WebGLRenderer);
+
+        this._program = new ShaderProgram(gl, "IrradianceMapCubeShader");
+        this._program.attachVertexSource(g_code.webgl.vertex);
+        this._program.attachFragmentSource(g_code.webgl.fragment(0.1));
+        this._program.link();
+    }
+
+    setup(
+        plistRenderer: PolyListRenderer,
+        materialRenderer: MaterialRenderer,
+        modelMatrix: Mat4,
+        viewMatrix: Mat4,
+        projectionMatrix: Mat4
+    ) {
+        if (!this._program) {
+            throw new Error("IrradianceMapCubeShader: shader program is not loaded");
+        }
+
+        const rend = this.renderer as WebGLRenderer;
+        const { gl } = rend;
+        rend.state.shaderProgram = this._program;
+
+        const mvp = Mat4.Mult(projectionMatrix, viewMatrix);
+        this._program.uniformMatrix4fv('uMVP', false, mvp);
+
+        gl.activeTexture(gl.TEXTURE0);
+        this._program.uniform1i('uCubemap', 0);
+        
+        const webglTexture = (materialRenderer.getTextureRenderer('albedoTexture') as WebGLTextureRenderer).getApiObject();
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, webglTexture);
+
+        this._program.positionAttribPointer((plistRenderer as WebGLPolyListRenderer).positionAttribParams("vertPosition"));
+    }
+
+    destroy() {
+        if (this._program) {
+            ShaderProgram.Delete(this._program);
+            this._program = null;
+        }
+    }
+}