bg2e-js 2.0.1 → 2.0.2

package/shaders/BasicPBRLightShader.js

@@ -1,238 +0,0 @@
-import Shader from "../render/Shader";
-import { pbrPointLight, pbrDirectionalLight } from './webgl_shader_lib';
-import ShaderFunction from "./ShaderFunction";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-import Mat4 from "../math/Mat4";
-import Vec from "../math/Vec";
-import { LightType } from "../base/Light";
-import { createNormalTexture, normalTexture } from "../tools/TextureResourceDatabase";
-
-function getShaderProgramForLights(renderer, numLights) {
-    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);
-                    }
-                    else if (uLightTypes[i] == ${ LightType.DIRECTIONAL }) {
-                        Lo += pbrDirectionalLight(
-                            uLightDirections[i], uLightColors[i] * uLightIntensities[i], fragPos, N, V,
-                            albedo, roughness, metallic);
-                    }
-                }
-
-                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(renderer.gl,"PBRBasicLight",vshader,fshader);
-    return this._programs[numLights];
-}
-export default class BasicPBRLightShader extends Shader {
-    constructor(renderer) {
-        super(renderer);
-
-        this._lights = [];
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("PresentTextureShader is only compatible with WebGL renderer");
-        }
-
-        this._programs = {};
-    }
-
-    async load() {
-        await createNormalTexture(this.renderer);
-    }
-
-    set cameraPosition(p) {
-        this._cameraPosition = p;
-    }
-
-    set lights(l) {
-        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,index) {
-        if (light >= 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) {
-        if (this._lights.length !== lights.length) {
-            this.lights = lights;
-        }
-        else {
-            lights.forEach((l,i) => this.updateLight(l,i));
-        }
-    }
-
-    setup(plistRenderer,materialRenderer,modelMatrix,viewMatrix,projectionMatrix) {
-        if (!this._program) {
-            throw new Error("BasicPBRLightShader: lights array not specified");
-        }
-
-        const material = materialRenderer.material;
-        this.renderer.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.bindTexture(this._program, 'diffuse', 'uAlbedoTexture', 0);
-        materialRenderer.bindTexture(this._program, 'normal', 'uNormalTexture', 1, normalTexture(this.renderer));
-        materialRenderer.bindTexture(this._program, 'metallic', 'uMetallicTexture', 2);
-        materialRenderer.bindTexture(this._program, 'roughness', 'uRoughnessTexture', 3);
-
-        materialRenderer.bindColor(this._program, 'diffuse', 'uAlbedo');
-        materialRenderer.bindValue(this._program, 'metallic', 'uMetallic');
-        materialRenderer.bindValue(this._program, 'roughness', 'uRoughness');
-        
-        
-        this._program.bindVector("uAlbedoScale", material.diffuseScale);
-        this._program.bindVector("uNormalScale", material.normalScale);
-        this._program.bindVector("uMetallicScale", material.metallicScale);
-        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, {
-            position: "inPosition",
-            normal: "inNormal",
-            tex0: "inTexCoord",
-            tangent: "inTangent"
-        });
-    }
-
-    destroy() {
-        ShaderProgram.Delete(this._program);
-    }
-}

package/shaders/DebugRenderShader.js

@@ -1,79 +0,0 @@
-import Vec from "../math/Vec";
-import Shader from "../render/Shader";
-import ShaderFunction from "./ShaderFunction";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-
-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 {
-    constructor(renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("DebugRenderShader is only compatible with WebGL renderer");
-        }
-    }
-
-    async load() {
-        const { gl } = this.renderer;
-
-        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, materialRenderer, modelMatrix, viewMatrix, projMatrix) {
-        const { gl } = this.renderer;
-        const { material } = materialRenderer;
-
-        this.renderer.state.shaderProgram = this._program;
-        this._program.uniform1i("uTexture", 0);
-        this._program.bindMatrix("uModelMatrix", modelMatrix);
-        this._program.bindMatrix("uViewMatrix", viewMatrix);
-        this._program.bindMatrix("uProjMatrix", projMatrix);
-
-        if (material.diffuse instanceof Vec) {
-            this._program.bindVector("uColor", material.diffuse);
-        }
-        else {
-            console.warning("DebugRenderShader: material.diffuse is a Texture. This shader only supports as diffuse color.");
-        }
-
-        this._program.positionAttribPointer(plistRenderer.positionAttribParams("position"));
-        this._program.texCoordAttribPointer(plistRenderer.texCoord0AttribParams("texCoord"));
-        
-    }
-}

package/shaders/DepthRenderShader.js

@@ -1,69 +0,0 @@
-import Shader from "../render/Shader";
-import ShaderFunction from "./ShaderFunction";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-
-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 {
-    constructor(renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("DepthRenderShader is only compatible with WebGL renderer");
-        }
-    }
-
-    async load() {
-        const { gl } = this.renderer;
-
-        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, materialRenderer, modelMatrix, viewMatrix, projMatrix) {
-        const { gl } = this.renderer;
-        const { material } = materialRenderer;
-
-        this.renderer.state.shaderProgram = this._program;
-
-        this._program.bindMatrix("uModelMatrix", modelMatrix);
-        this._program.bindMatrix("uViewMatrix", viewMatrix);
-        this._program.bindMatrix("uProjMatrix", projMatrix);
-
-        this._program.positionAttribPointer(plistRenderer.positionAttribParams("position"));
-        this._program.texCoordAttribPointer(plistRenderer.texCoord0AttribParams("texCoord"));
-    }
-}
-
-

package/shaders/IrradianceMapCubeShader.js

@@ -1,99 +0,0 @@
-
-import Shader from "../render/Shader";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-import Mat4 from "../math/Mat4";
-import Vec from "../math/Vec";
-
-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) => `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 {
-    constructor(renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("PresentTextureShader is only compatible with WebGL renderer");
-        }
-    }
-
-    async load() {
-        const { gl } = this.renderer;
-
-        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, materialRenderer, modelMatrix, viewMatrix, projectionMatrix) {
-        const { material } = materialRenderer;
-        const { gl } = this.renderer;
-        this.renderer.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);
-        if (material.diffuse instanceof Vec) {
-            throw new Error("Invalid material configuration in IrradianceMapCubeShader: diffuse component must be a cube map texture");
-        }
-        const webglTexture = materialRenderer.getTextureRenderer('diffuse').getApiObject();
-        gl.bindTexture(gl.TEXTURE_CUBE_MAP, webglTexture);
-
-        this._program.positionAttribPointer(plistRenderer.positionAttribParams("vertPosition"));
-    }
-
-    destroy() {
-        ShaderProgram.Delete(this._program);
-        this._program = null;
-    }
-}