bg2e-js 2.0.1 → 2.0.2

package/shaders/SelectionHighlightShader.js

@@ -1,98 +0,0 @@
-
-import Texture, { TextureTargetName } from '../base/Texture';
-import Shader from '../render/Shader';
-import ShaderProgram from '../render/webgl/ShaderProgram';
-import ShaderFunction from './ShaderFunction';
-import { applyConvolution } from './webgl_shader_lib';
-import Vec from '../math/Vec';
-
-const g_code = {
-    webgl: {
-        vertex: `precision mediump float;
-
-        attribute vec3 position;
-        attribute vec2 texCoord;
-        
-        varying vec2 fragTexCoord;
-
-        void main() {
-            fragTexCoord = texCoord;
-            gl_Position = vec4(position, 1.0);
-        }`,
-
-        fragment: ShaderFunction.GetShaderCode(`precision mediump float;
-            varying vec2 fragTexCoord;
-            
-            uniform sampler2D uTexture;
-            uniform float uConvMatrix[9];
-            uniform vec4 uBorderColor;
-            uniform float uBorderWidth;
-            uniform vec2 uTexSize;
-            `,
-            [
-                new ShaderFunction('void','main','',`{
-                    vec4 selectionColor = applyConvolution(uTexture, fragTexCoord, uTexSize, uConvMatrix, uBorderWidth);
-                    if (selectionColor.r!=0.0 && selectionColor.g!=0.0 && selectionColor.b!=0.0) {
-                        gl_FragColor = uBorderColor;
-                    }
-                    else {
-                        discard;
-                    }
-                }`, [applyConvolution])
-            ])
-    }
-}
-
-export default class SelectionHighlightShader extends Shader {
-    constructor(renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("SelectionHighlightShader is only compatible with WebGL renderer");
-        }
-    }
-
-    async load() {
-        const { gl } = this.renderer;
-
-        this._program = new ShaderProgram(gl, "SelectionHighlightShader");
-        this._program.attachVertexSource(g_code.webgl.vertex);
-        this._program.attachFragmentSource(g_code.webgl.fragment);
-        this._program.link();
-
-        this._borderWidth = 3;
-        this._borderColor = new Vec([0.0, 0.7, 1, 1.0]);
-        this._convMatrix = [
-            0, 1, 0,
-            1,-4, 1,
-            0, 1, 0
-        ];
-    }
-
-    setup(plistRenderer, materialRenderer, modelMatrix, viewMatrix, projectionMatrix) {
-        const { gl, viewport } = this.renderer;
-
-        this.renderer.state.shaderProgram = this._program;
-
-        gl.activeTexture(gl.TEXTURE0);
-        this._program.uniform1i('uTexture', 0);
-        this._program.uniform2f('uTexSize', viewport[2], viewport[3]);
-        this._program.uniform1f('uBorderWidth', this._borderWidth);
-        this._program.uniform4fv('uBorderColor', this._borderColor);
-        this._program.uniform1fv('uConvMatrix', this._convMatrix, 4);
-
-        const material = materialRenderer.material;
-        if (material.diffuse instanceof Texture) {
-            const webglTexture = materialRenderer.getTextureRenderer('diffuse').getApiObject();
-            const target = TextureTargetName[material.diffuse.target];
-            gl.bindTexture(gl[target], webglTexture);
-
-        }
-        else {
-            throw new Error("PresentTextureShader: invalid material setup. The diffuse material attribute must to be a texture");
-        }
-
-        this._program.positionAttribPointer(plistRenderer.positionAttribParams("position"));
-        this._program.texCoordAttribPointer(plistRenderer.texCoord0AttribParams("texCoord"));
-    }
-}

package/shaders/ShaderFunction.js

@@ -1,72 +0,0 @@
-
-
-const isRequired = (candidateFunction,includedFunctions) => {
-    return !includedFunctions.find(includedFunc => includedFunc.name === candidateFunction.name);
-}
-
-const getAllDependencies = (fn, result = []) => {
-    fn.dependencies.forEach(depFn => {
-        getAllDependencies(depFn, result);
-        result.push(depFn);
-    });
-    result.push(fn);
-}
-
-const getDependencies = (fn) => {
-    const allFunctions = [];
-    getAllDependencies(fn, allFunctions);
-    const includedFunctions = [];
-    return allFunctions.filter(candidateFn => {
-        if (includedFunctions.indexOf(candidateFn.name) === -1) {
-            includedFunctions.push(candidateFn.name);
-            return true;
-        }
-    });
-}
-
-export default class ShaderFunction {
-    constructor(returnType, name, params, body, deps = []) {
-        this._returnType = returnType;
-        this._name = name;
-        this._params = params;
-        this._body = body;
-        this._deps = deps;
-    }
-
-    get returnType() {
-        return this._returnType;
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    get params() {
-        return this._params;
-    }
-
-    get body() {
-        return this._body;
-    }
-
-    get dependencies() {
-        return this._deps;
-    }
-
-    getFunctionText() {
-        return `${this.returnType} ${this.name}(${this.params}) ${this.body}`;
-    }
-
-    static GetShaderCode(header, requiredFunctions) {
-        let allFunctions = [];
-        requiredFunctions.forEach(req => {
-            allFunctions = [...allFunctions, ...getDependencies(req, allFunctions)];
-        });
-        let code = header;
-        allFunctions.forEach(fn => {
-            code += fn.getFunctionText() + "\n\n";
-        });
-
-        return code;
-    }
-}

package/shaders/SkyCubeShader.js

@@ -1,78 +0,0 @@
-import Mat4 from "../math/Mat4";
-import Vec from "../math/Vec";
-import Shader from "../render/Shader";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-
-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);
-
-            // The normal can be extracted from the position
-            // since this shader is designed to be used with
-            // a cube centered in 0,0,0
-            fragNormal = normalize(vertPosition);
-        }
-        `,
-
-        fragment: `precision mediump float;
-        varying vec3 fragNormal;
-        
-        uniform samplerCube uCubemap;
-        
-        void main() {
-            gl_FragColor = textureCube(uCubemap, normalize(fragNormal));
-        }`
-    }
-};
-
-export default class SkyCubeShader 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, "SkyCubeShader");
-        this._program.attachVertexSource(g_code.webgl.vertex);
-        this._program.attachFragmentSource(g_code.webgl.fragment);
-        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 SkySphereShader: 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;
-    }
-}

package/shaders/SkySphereShader.js

@@ -1,77 +0,0 @@
-import Shader from "../render/Shader";
-import ShaderProgram from "../render/webgl/ShaderProgram";
-import { TextureTargetName } from "../base/Texture";
-import Vec from "../math/Vec";
-
-const g_code = {
-    webgl: {
-        vertex: `precision mediump float;
-        
-        attribute vec3 vertPosition;
-        attribute vec2 t0Position;
-        
-        varying vec2 fragT0Pos;
-        
-        uniform mat4 mView;
-        uniform mat4 mProj;
-        
-        void main() {
-            fragT0Pos = t0Position;
-            gl_Position = mProj * mView * vec4(vertPosition, 1.0);
-        }`,
-
-        fragment: `precision mediump float;
-        
-        varying vec2 fragT0Pos;
-        
-        uniform sampler2D uTexture;
-        
-        void main() {
-            vec4 texColor = texture2D(uTexture, fragT0Pos);
-            gl_FragColor = vec4(texColor.rgb, 1.0);
-        }`
-    }
-};
-
-export default class SkySphereShader 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, "SkySphereShader");
-        this._program.attachVertexSource(g_code.webgl.vertex);
-        this._program.attachFragmentSource(g_code.webgl.fragment);
-        this._program.link();
-    }
-
-    setup(plistRenderer, materialRenderer, modelMatrix, viewMatrix, projectionMatrix) {
-        const { material } = materialRenderer;
-        const { gl } = this.renderer;
-        this.renderer.state.shaderProgram = this._program;
-
-        this._program.uniformMatrix4fv('mView', false, viewMatrix);
-        this._program.uniformMatrix4fv('mProj', false, projectionMatrix);
-
-        gl.activeTexture(gl.TEXTURE0);
-        this._program.uniform1i('uTexture', 0);
-        if (material.diffuse instanceof Vec) {
-            throw new Error("Invalid material configuration in SkySphereShader: diffuse component must be a texture");
-        }
-        const webglTexture = materialRenderer.getTextureRenderer('diffuse').getApiObject();
-        const target = TextureTargetName[material.diffuse.target];
-        gl.bindTexture(gl[target], webglTexture);
-        
-        this._program.positionAttribPointer(plistRenderer.positionAttribParams("vertPosition"));
-        this._program.texCoordAttribPointer(plistRenderer.texCoord0AttribParams("t0Position"));
-    }
-
-    destroy() {
-        ShaderProgram.Delete(this._program);
-    }
-}

package/shaders/SpecularMapCubeShader.js

@@ -1,145 +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: (sampleCount,roughness) => `precision mediump float;
-        
-        varying vec3 fragNormal;
-        
-        uniform samplerCube uCubemap;
-        
-        float vanDerCorpus(int n, int base) {
-            float invBase = 1.0 / float(base);
-            float denom   = 1.0;
-            float result  = 0.0;
-
-            for(int i = 0; i < 16; ++i)
-            {
-                if(n > 0)
-                {
-                    denom   = mod(float(n), 2.0);
-                    result += denom * invBase;
-                    invBase = invBase / 2.0;
-                    n       = int(float(n) / 2.0);
-                }
-            }
-
-            return result;
-        }
-
-        vec2 hammersleyNoBitOps(int i, int N) {
-            return vec2(float(i)/float(N), vanDerCorpus(i, 2));
-        }
-
-        vec3 importanceSampleGGX(vec2 Xi, vec3 N) {
-            // compute roughness^4 outside the gpu
-            float a = ${ roughness*roughness*roughness*roughness };
-            
-            float phi = ${ 2.0 * Math.PI } * Xi.x;
-            float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a - 1.0) * Xi.y));
-            float sinTheta = sqrt(1.0 - cosTheta*cosTheta);
-            
-            // from spherical coordinates to cartesian coordinates
-            vec3 H;
-            H.x = sin(phi) * sinTheta;
-            H.y = cos(phi) * sinTheta;
-            H.z = cosTheta;
-            
-            // from tangent-space vector to world-space sample vector
-            vec3 up        = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-            vec3 tangent   = normalize(cross(up, N));
-            vec3 bitangent = cross(N, tangent);
-            
-            vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z;
-            return normalize(sampleVec);
-        } 
-
-        void main() {
-            vec3 N = normalize(fragNormal);
-            vec3 R = N;
-            vec3 V = R;
-
-            float totalWeight = 0.0;
-            vec3 prefilteredColor = vec3(0.0);
-            for (int i = 0; i < ${ sampleCount }; ++i)
-            {
-                vec2 Xi = hammersleyNoBitOps(i, ${ sampleCount });
-                vec3 H = importanceSampleGGX(Xi, N);
-                vec3 L = normalize(2.0 * dot(V, H) * H - V);
-
-                float NdotL = max(dot(N,L), 0.0);
-                if (NdotL > 0.0)
-                {
-                    prefilteredColor += textureCube(uCubemap, L).rgb * NdotL;
-                    totalWeight += NdotL;
-                }
-            }
-            prefilteredColor = prefilteredColor / totalWeight;
-
-            gl_FragColor = vec4(prefilteredColor, 1.0);
-        }`
-    }
-};
-
-export default class SpecularMapCubeShader extends Shader {
-    constructor(renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("SpecularMapCubeShader is only compatible with WebGL renderer");
-        }
-    }
-
-    get roughness() { return this._roughness; }
-
-    async load(roughness = 0.5) {
-        const { gl } = this.renderer;
-
-        this._roughness = roughness;
-
-        this._program = new ShaderProgram(gl, "SpecularMapCubeShader");
-        this._program.attachVertexSource(g_code.webgl.vertex);
-        this._program.attachFragmentSource(g_code.webgl.fragment(128, this._roughness));
-        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 SpecularMapCubeShader: diffuse component must be a cube map')
-        }
-        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;
-    }
-}

package/shaders/TextureMergerShader.js

@@ -1,127 +0,0 @@
-
-import { TextureChannel } from '../base/Texture';
-import Shader from '../render/Shader';
-import ShaderProgram from '../render/webgl/ShaderProgram';
-
-const g_code = {
-    webgl: {
-        vertex: `precision mediump float;
-
-        attribute vec3 position;
-        attribute vec2 texCoord;
-        
-        varying vec2 fragTexCoord;
-
-        void main() {
-            fragTexCoord = texCoord;
-            gl_Position = vec4(position, 1.0);
-        }`,
-
-        fragment: `precision mediump float;
-        
-        varying vec2 fragTexCoord;
-        
-        uniform sampler2D uTextureR;
-        uniform sampler2D uTextureG;
-        uniform sampler2D uTextureB;
-        uniform sampler2D uTextureA;
-
-        uniform int uRChannel;
-        uniform int uGChannel;
-        uniform int uBChannel;
-        uniform int uAChannel;
-        
-        float getChannel(vec4 color, int channel) {
-            if (channel == 1) {
-                return color.r;
-            }
-            else if (channel == 2) {
-                return color.g;
-            }
-            else if (channel == 3) {
-                return color.b;
-            }
-            else {
-                return color.a;
-            }
-        }
-
-        void main() {
-            vec4 result = vec4(
-                getChannel(texture2D(uTextureR, fragTexCoord), uRChannel),
-                getChannel(texture2D(uTextureG, fragTexCoord), uGChannel),
-                getChannel(texture2D(uTextureB, fragTexCoord), uBChannel),
-                getChannel(texture2D(uTextureA, fragTexCoord), uAChannel)
-            );
-            
-            gl_FragColor = result;
-        }`
-    }
-}
-
-const g_renderers = {};
-export default class TextureMergerShader extends Shader {
-    static GetUnique(renderer) {
-        if (!g_renderers[renderer.uniqueId]) {
-            g_renderers[renderer.uniqueId] = new TextureMergerShader(renderer);
-            g_renderers[renderer.uniqueId].load();
-        }
-        return g_renderers[renderer.uniqueId];
-    }
-
-    constructor(renderer) {
-        super(renderer);
-
-        if (renderer.typeId !== "WebGL") {
-            throw Error("TextureMergerShader is only compatible with WebGL renderer");
-        }
-
-        this._textures = {};
-        this._textureChannels = {};
-    }
-
-    load() {
-        const { gl } = this.renderer;
-
-        this._program = new ShaderProgram(gl, "DefaultTextureMergerShader");
-        this._program.attachVertexSource(g_code.webgl.vertex);
-        this._program.attachFragmentSource(g_code.webgl.fragment);
-        this._program.link();
-    }
-
-    setTexture(tex,channel,dstChannel = TextureChannel.R) {
-        if (channel<TextureChannel.R || channel>TextureChannel.A) {
-            throw new Error(`TextureMergerShader: invalid texture channel set ${ channel }`);
-        }
-        this._textures[channel] = tex;
-        this._textureChannels[channel] = dstChannel;
-    }
-
-    get isComplete() {
-        return  this._textures[TextureChannel.R] &&
-                this._textures[TextureChannel.G] &&
-                this._textures[TextureChannel.B] &&
-                this._textures[TextureChannel.A] && true;
-    }
-
-    setup(plistRenderer, materialRenderer, modelMatrix, viewMatrix, projectionMatrix) {
-        if (!this.isComplete) {
-            throw new Error("TextureMergerShader: the texture shader is not complete. Check that the textures are set for all channels");
-        }
-
-        this.renderer.state.shaderProgram = this._program;
-
-        this._program.bindTexture("uTextureR", this.renderer.factory.texture(this._textures[TextureChannel.R]), 0);
-        this._program.bindTexture("uTextureG", this.renderer.factory.texture(this._textures[TextureChannel.G]), 1);
-        this._program.bindTexture("uTextureB", this.renderer.factory.texture(this._textures[TextureChannel.B]), 2);
-        this._program.bindTexture("uTextureA", this.renderer.factory.texture(this._textures[TextureChannel.A]), 3);
-
-        this._program.uniform1i("uRChannel", this._textureChannels[TextureChannel.R]);
-        this._program.uniform1i("uGChannel", this._textureChannels[TextureChannel.G]);
-        this._program.uniform1i("uBChannel", this._textureChannels[TextureChannel.B]);
-        this._program.uniform1i("uAChannel", this._textureChannels[TextureChannel.A]);
-
-        this._program.positionAttribPointer(plistRenderer.positionAttribParams("position"));
-        this._program.texCoordAttribPointer(plistRenderer.texCoord0AttribParams("texCoord"));
-    }
-}