bg2e-js 2.0.0 → 2.0.2

package/render/webgl/ShaderProgram.js

@@ -1,348 +0,0 @@
-import Mat4 from "../../math/Mat4";
-import Mat3 from "../../math/Mat3";
-import { TextureTarget, TextureTargetName } from "../../base/Texture";
-
-export const ShaderType = {
-    VERTEX: 0,
-    FRAGMENT: 1
-};
-
-function destroy() {
-    delete this._program.__shaderProgram__;
-    this._gl.deleteProgram(this._program);
-    this._program = null;
-}
-
-export default class ShaderProgram {
-    static Create(gl,name,vertexCode,fragmentCode) {
-        if (!vertexCode ||  !fragmentCode) {
-            throw new Error("ShaderProgram.Create(): Invalid vertex or fragment code");
-        }
-        const result = new ShaderProgram(gl,name);
-        if (!Array.isArray(vertexCode)) {
-            vertexCode = [vertexCode];
-        }
-        if (!Array.isArray(fragmentCode)) {
-            fragmentCode = [fragmentCode];
-        }
-        vertexCode.forEach(shaderCode => result.attachVertexSource(shaderCode));
-        fragmentCode.forEach(shaderCode => result.attachFragmentSource(shaderCode));
-        result.link();
-        return result;
-    }
-
-    static GetShaderProgram(glProgram) {
-        return glProgram.__shaderProgram__;
-    }
-
-    static Delete(shaderProgram) {
-        destroy.apply(shaderProgram);
-    }
-
-    constructor(gl, name = "") {
-        this._gl = gl;
-        this._name = name;
-        this._program = gl.createProgram();
-        this._program.__id__ = Symbol(this._program);
-        this._program.__shaderProgram__ = this;
-        this._attribLocations = {};
-        this._uniformLocations = {};
-        this._failed = false;
-    }
-
-    get program() {
-        return this._program;
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    attachSource(src,type) {
-        if (this._failed) {
-            return;
-        }
-
-        const gl = this._gl;
-        if (type === ShaderType.VERTEX) {
-            type = gl.VERTEX_SHADER;
-        }
-        else if (type === ShaderType.FRAGMENT) {
-            type = gl.FRAGMENT_SHADER;
-        }
-        const shader = gl.createShader(type);
-        gl.shaderSource(shader, src);
-        gl.compileShader(shader);
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            this._failed = true;
-            const debugCode = src.split(/\r?\n/)
-                .map((line,i) => `${i + 1} | ${line}`)
-                .join('\n');
-            throw new Error(`Error compiling shader: \n${gl.getShaderInfoLog(shader)} 
-            ${debugCode}
-            `);
-        }
-        gl.attachShader(this._program, shader);
-    }
-
-    attachVertexSource(src) {
-        this.attachSource(src, ShaderType.VERTEX);
-    }
-
-    attachFragmentSource(src) {
-        this.attachSource(src, ShaderType.FRAGMENT);
-    }
-
-    link() {
-        if (this._failed) {
-            return false;
-        }
-        const gl = this._gl;
-        gl.linkProgram(this._program);
-        if (!gl.getProgramParameter(this._program, gl.LINK_STATUS)) {
-            throw new Error(`Error linking program: \n${gl.getProgramInfoLog(this._program)}`);
-        }
-
-        gl.validateProgram(this._program);
-        if (!gl.getProgramParameter(this._program, gl.VALIDATE_STATUS)) {
-            throw new Error(`Error validating program:\n${gl.getProgramInfoLog(this._program)}`);
-        }
-    }
-
-    useProgram() {
-        this._gl.useProgram(this._program);
-    }
-
-    getAttribLocation(name) {
-        this._attribLocations[name] = this._attribLocations[name] || this._gl.getAttribLocation(this._program, name);
-        return this._attribLocations[name];
-    }
-
-    checkInvalidLocations() {
-        let status = true;
-        for (const name in this._attribLocations) {
-            if (this._attribLocations[name] == -1) {
-                console.warn(`Invalid attrib location for name '${name}'`);
-                status = false;
-            }
-        }
-        return status;
-    }
-
-    getUniformLocation(name) {
-        this._uniformLocations[name] = this._gl.getUniformLocation(this._program, name);
-        return this._uniformLocations[name];
-    }
-
-    vertexAttribPointer(name,size,format,normalize,stride,offset) {
-        const location = this.getAttribLocation(name);
-        this._gl.vertexAttribPointer(location, size, format, normalize, stride, offset);
-    }
-
-    enableVertexAttribArray(name) {
-        const location = this.getAttribLocation(name);
-        this._gl.enableVertexAttribArray(location);
-    }
-
-    positionAttribPointer({ name, stride, size = 3, offset = 0, enable = false, bytesPerElement = Float32Array.BYTES_PER_ELEMENT }) {
-        this.vertexAttribPointer(name, size, this._gl.FLOAT, false, stride * bytesPerElement, offset * bytesPerElement);
-        if (enable) {
-            this.enableVertexAttribArray(name);
-        }
-    }
-
-    normalAttribPointer({ name, size = 3, stride, offset = 0, enable = false, bytesPerElement = Float32Array.BYTES_PER_ELEMENT }) {
-        this.vertexAttribPointer(name, size, this._gl.FLOAT, true, stride * bytesPerElement, offset * bytesPerElement);
-        if (enable) {
-            this.enableVertexAttribArray(name);
-        }
-    }
-
-    tangentAttribPointer({ name, size = 3, stride, offset = 0, enable = false, bytesPerElement = Float32Array.BYTES_PER_ELEMENT }) {
-        this.vertexAttribPointer(name, size, this._gl.FLOAT, true, stride * bytesPerElement, offset * bytesPerElement);
-        if (enable) {
-            this.enableVertexAttribArray(name);
-        }
-    }
-
-    texCoordAttribPointer({ name, stride, offset, enable = false, bytesPerElement = Float32Array.BYTES_PER_ELEMENT }) {
-        this.vertexAttribPointer(name, 2, this._gl.FLOAT, false, stride * bytesPerElement, offset * bytesPerElement);
-        if (enable) {
-            this.enableVertexAttribArray(name);
-        }
-    }
-
-    colorAttribPointer({ name, size = 4, stride, offset = 0, enable = false, bytesPerElement = Float32Array.BYTES_PER_ELEMENT }) {
-        this.vertexAttribPointer(name, size, this._gl.FLOAT, false, stride * bytesPerElement, offset * bytesPerElement);
-        if (enable) {
-            this.enableVertexAttribArray(name);
-        }
-    }
-
-    uniformMatrix2fv(name, transpose, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniformMatrix2fv(location, transpose, value);
-    }
-
-    uniformMatrix3fv(name, transpose, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniformMatrix3fv(location, transpose, value);
-    }
-
-    uniformMatrix4fv(name, transpose, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniformMatrix4fv(location, transpose, value);
-    }
-
-    uniform1f(name, v0) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform1f(location, v0);
-    }
-
-    uniform1fv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform1fv(location, value);
-    }
-
-    uniform1i(name, v0) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform1i(location, v0);
-    }
-
-    uniform1iv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform1iv(location, value);
-    }
-
-    uniform2f(name, v0, v1) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform2f(location, v0, v1);
-    }
-
-    uniform2fv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform2fv(location, value);
-    }
-
-    uniform2i(name, v0, v1) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform2i(location, v0, v1);
-    }
-
-    uniform2iv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform2iv(location, value);
-    }
-
-    uniform3f(name, v0, v1, v2) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform3f(location, v0, v1, v2);
-    }
-
-    uniform3fv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform3fv(location, value);
-    }
-
-    uniform3i(name, v0, v1, v2) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform3i(location, v0, v1, v2);
-    }
-
-    uniform3iv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform3iv(location, value);
-    }
-
-    uniform4f(name, v0, v1, v2, v3) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform4f(location, v0, v1, v2, v3);
-    }
-
-    uniform4fv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform4fv(location, value);
-    }
-
-    uniform4i(name, v0, v1, v2, v3) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform4i(location, v0, v1, v2, v3);
-    }
-
-    uniform4iv(name, value) {
-        const location = this._uniformLocations[name] || this.getUniformLocation(name);
-        this._gl.uniform4iv(location, value);
-    }
-
-    // Utility functions
-    bindAttribs(polyListRenderer, { 
-        position, 
-        normal = null, 
-        tex0 = null, 
-        tex1 = null, 
-        tex2 = null, 
-        color = null, 
-        tangent = null
-    }) {
-        this.positionAttribPointer(polyListRenderer.positionAttribParams(position));
-        if (normal) {
-            this.normalAttribPointer(polyListRenderer.normalAttribParams(normal));
-        }
-        if (tex0) {
-            this.texCoordAttribPointer(polyListRenderer.texCoord0AttribParams(tex0));
-        }
-        if (tex1) {
-            this.texCoordAttribPointer(polyListRenderer.texCoord1AttribParams(tex1));
-        }
-        if (tex2) {
-            this.texCoordAttribPointer(polyListRenderer.texCoord2AttribParams(tex1));
-        }
-        if (tangent) {
-            this.tangentAttribPointer(polyListRenderer.tangentAttribParams(tangent));
-        }
-        if (color) {
-            this.colorAttribPointer(polyListRenderer.colorAttribParams(color));
-        }
-    }
-
-    bindMatrix(uniformName, matrix) {
-        if (matrix instanceof Mat4) {
-            this.uniformMatrix4fv(uniformName, false, matrix);
-        }
-        else if (matrix instanceof Mat3) {
-            this.uniformMatrix3fv(uniformName, false, matrix);
-        }
-    }
-
-    bindVector(uniformName, vec) {
-        switch (vec.length) {
-        case 2:
-            this.uniform2fv(uniformName, vec);
-            break;
-        case 3:
-            this.uniform3fv(uniformName, vec);
-            break;
-        case 4:
-            this.uniform4fv(uniformName, vec);
-            break;
-        default:
-            throw new Error("ShaderProgram.bindVector(): invalid vector size");
-        }
-    }
-
-    bindTexture(uniformName, textureRenderer, textureUnit) {
-        const gl = this._gl;
-        const webglTexture = textureRenderer.getApiObject();
-        
-        gl.activeTexture(gl.TEXTURE0 + textureUnit);
-        switch (textureRenderer.texture.target) {
-        case TextureTarget.TEXTURE_2D:
-            gl.bindTexture(gl.TEXTURE_2D, webglTexture);
-            break;
-        case TextureTarget.CUBE_MAP:
-            gl.bindTexture(gl.TEXTURE_CUBE_MAP, webglTexture);
-            break;
-        }
-        this.uniform1i(uniformName, textureUnit);
-    }
-}

package/render/webgl/ShadowRenderer.js

@@ -1,6 +0,0 @@
-import ShadowRenderer from "../ShadowRenderer";
-
-
-export default class WebGLShadowRenderer extends ShadowRenderer {
-
-}

package/render/webgl/SkyCube.js

@@ -1,15 +0,0 @@
-import SkyCube from "../SkyCube";
-
-export default class WebGLSkyCube extends SkyCube {
-    draw() {
-        const { state } = this.renderer;
-        if (!this._renderState) {
-            throw new Error("SkyCube.draw(): the render state is not updated");
-        }
-
-        const dm = state.depthMask;
-        state.depthMask = false;
-        this._renderState.draw();
-        state.depthMask = dm;
-    }
-}

package/render/webgl/SkySphere.js

@@ -1,14 +0,0 @@
-import SkySphere from "../SkySphere";
-
-export default class WebGLSkySphere extends SkySphere {
-    draw() {
-        if (!this._renderState) {
-            throw new Error("SkySphere.draw(): the render state is not updated");
-        }
-        
-        const dm = this.renderer.state.depthMask;
-        this.renderer.state.depthMask = false;
-        this._renderState.draw();
-        this.renderer.state.depthMask = dm;
-    }
-}

package/render/webgl/State.js

@@ -1,149 +0,0 @@
-
-import Vec from "../../math/Vec";
-import ShaderProgram from "./ShaderProgram";
-
-export default class State {
-
-    get CW() { return this.gl.CW; }
-    get CCW() { return this.gl.CCW; }
-    get FRONT() { return this.gl.FRONT; }
-    get BACK() { return this.gl.BACK; }
-    get FRONT_AND_BACK() { return this.gl.FRONT_AND_BACK; }
-
-    constructor(renderer) {
-        this._renderer = renderer;
-
-        this.cullFaceEnabled = true;
-    }
-
-    get renderer() {
-        return this._renderer;
-    }
-
-    get gl() {
-        return this._renderer.gl;
-    }
-
-    get viewport() {
-        return new Vec(this.gl.getParameter(this.gl.VIEWPORT));
-    }
-
-    get maxViewportDims() {
-        return new Vec(this.gl.getParameter(this.gl.MAX_VIEWPORT_DIMS));
-    }
-
-    set viewport(vp) {
-        if (vp.length === 2) {
-            this.gl.viewport(0, 0, vp[0], vp[1]);
-        }
-        else if (vp.length >=4) {
-            this.gl.viewport(vp[0], vp[1], vp[2], vp[3]);
-        }
-        else {
-            throw new Error("Invalid parameter setting viewport");
-        }
-    }
-
-    set clearColor(c) {
-        if (c.length<4) {
-            throw new Error("Invalid parameter setting clear color");
-        }
-
-        this.gl.clearColor(c[0],c[1],c[2],c[3]);
-    }
-
-    get clearColor() {
-        return new Vec(this.gl.getParameter(this.gl.COLOR_CLEAR_VALUE));
-    }
-
-    set clearDepth(d) {
-        this.gl.clearDepth(d);
-    }
-
-    get clearDepth() {
-        return gl.getParameter(gl.DEPTH_CLEAR_VALUE);
-    }
-
-    set clearStencil(s) {
-        this.gl.clearStencil(s);
-    }
-
-    get clearStencil() {
-        return this.gl.getParameter(this.gl.STENCIL_CLEAR_VALUE);
-    }
-
-    get depthMask() {
-        return this.gl.getParameter(this.gl.DEPTH_WRITEMASK);
-    }
-
-    set depthMask(m) {
-        this.gl.depthMask(m);
-    }
-
-    set frontFace(ff) {
-        this.gl.frontFace(ff);
-    }
-
-    get frontFace() {
-        return this.gl.getParameter(this.gl.FRONT_FACE);
-    }
-
-    set cullFace(cf) {
-        this.gl.cullFace(cf);
-    }
-
-    get cullFace() {
-        return this.gl.getParameter(this.gl.CULL_FACE_MODE);
-    }
-
-    set depthTestEnabled(e) {
-        e ? this.gl.enable(this.gl.DEPTH_TEST) :
-            this.gl.disable(this.gl.DEPTH_TEST);
-    }
-
-    get depthTestEnabled() {
-        return this.gl.getParameter(this.gl.DEPTH_TEST);
-    }
-
-    set cullFaceEnabled(e) {
-        e ? this.gl.enable(this.gl.CULL_FACE) :
-            this.gl.disable(this.gl.CULL_FACE);
-    }
-
-    get blendEnabled() {
-        return this.gl.getParameter(this.gl.BLEND);
-    }
-
-    set blendEnabled(b) {
-        b ? this.gl.enable(this.gl.BLEND) :
-            this.gl.disable(this.gl.BLEND);
-    }
-
-    get cullFaceEnabled() {
-        return this.gl.getParameter(this.gl.CULL_FACE);
-    }
-
-    set shaderProgram(program) {
-        program.useProgram();
-    }
-
-    get shaderProgram() {
-        const glProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
-        if (glProgram) {
-            return ShaderProgram.GetShaderProgram(glProgram);
-        }
-        else {
-            return null;
-        }
-    }
-
-    clear({ color = true, depth = true, stencil = false} = {}) {
-        const clearValues = (color ? this.gl.COLOR_BUFFER_BIT : 0) |
-                            (depth ? this.gl.DEPTH_BUFFER_BIT : 0) |
-                            (stencil ? this.gl.STENCIL_BUFFER_BIT : 0);
-        this.gl.clear(clearValues);
-    }
-
-
-    
-}

package/render/webgl/TextureRenderer.js

@@ -1,167 +0,0 @@
-
-
-import TextureRenderer from '../TextureRenderer';
-import Texture, { 
-    TextureWrapName, 
-    TextureFilterName, 
-    TextureTargetName,
-    TextureDataType,
-    TextureComponentFormat,
-    TextureRenderTargetAttachment,
-    TextureTarget
-} from '../../base/Texture';
-import Vec from '../../math/Vec';
-import { generateUUID } from '../../tools/crypto';
-import Renderer from '../Renderer';
-
-const getTarget = (gl, tex) => {
-    switch (tex.target) {
-    case TextureTarget.TEXTURE_2D:
-        return gl.TEXTURE_2D;
-    case TextureTarget.CUBE_MAP:
-        return gl.TEXTURE_CUBE_MAP;
-    default:
-        throw new Error("Error creating WebGL Texture: invalid target");
-    }
-}
-
-const getClampMode = (gl, mode) => {
-    if (mode === 1) {
-        return gl.CLAMP_TO_EDGE;
-    }
-    else {
-        const name = TextureWrapName[mode];
-        return gl[name];
-    }
-}
-
-const getTextureFilter = (gl, filter) => {
-    const name = TextureFilterName[filter];
-    return gl[name];
-}
-
-const getDataFormat = (gl,texture) => {
-    const componentFormat = texture.componentFormat;
-    switch (componentFormat) {
-    case TextureComponentFormat.UNSIGNED_BYTE:
-        return gl.UNSIGNED_BYTE;
-    case TextureComponentFormat.FLOAT32:
-        return gl.FLOAT;
-    default:
-        throw new Error("Error creating webgl texture: invalid component data format");
-    }
-}
-
-const bg2eCreateTexture = (gl, textureObject) => {
-    textureObject._apiObject = gl.createTexture();
-    textureObject._apiObject._bg2_uuid = generateUUID();
-    gl._bg2_textures = gl._bg2_textures || {};
-    let id = textureObject.name || textureObject._apiObject._bg2_uuid;
-    if (gl._bg2_textures[id] && gl._bg2_textures[id] !== textureObject) {
-        id = textureObject.name + "_" + textureObject._apiObject._bg2_uuid;
-    }
-    gl._bg2_textures[id] = textureObject;
-}
-
-const bg2eDeleteTexture = (gl, textureObject) => {
-    if (textureObject._apiObject) {
-        gl.deleteTexture(textureObject._apiObject);
-        delete gl._bg2_textures[textureObject._apiObject._bg2_uuid];
-        textureObject._apiObject = null;
-        textureObject.setUpdated(false);
-    }
-}
-
-const getWebGLTexture = (gl, textureObject) => {
-    if (!textureObject.imageData) {
-        throw new Error("Error loading WebGL texture: image data not loaded");
-    }
-
-    bg2eDeleteTexture(gl, textureObject);
-    bg2eCreateTexture(gl, textureObject);
-
-    const target = getTarget(gl, textureObject);
-    const dataFormat = getDataFormat(gl, textureObject);
-    gl.bindTexture(target, textureObject._apiObject);
-
-    if (textureObject.dataType ===TextureDataType.RENDER_TARGET) {
-        const { width, height } = textureObject.size;
-
-        const isDepthTexture = textureObject.renderTargetAttachment === TextureRenderTargetAttachment.DEPTH_ATTACHMENT;
-        const internalFormat = isDepthTexture ? gl.DEPTH_COMPONENT : gl.RGBA;
-        let format = isDepthTexture ? gl.DEPTH_COMPONENT : gl.RGBA;
-        const type = isDepthTexture ? gl.UNSIGNED_SHORT : dataFormat;
-
-        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-        gl.texParameteri(target, gl.TEXTURE_WRAP_S, getClampMode(gl,textureObject.wrapModeX));
-        gl.texParameteri(target, gl.TEXTURE_WRAP_T, getClampMode(gl,textureObject.wrapModeY));
-        
-        if (target === gl.TEXTURE_CUBE_MAP) {
-            for (let i = 0; i<6; ++i) {
-                gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, internalFormat, width, height, 0, format, type, null);
-            }
-        }
-        else {
-            gl.texImage2D(target, 0, internalFormat, width, height, 0, format, type, null);
-        }
-
-        textureObject.imageData.currentSize = new Vec(textureObject.size);
-    }
-    else {
-    
-        gl.texImage2D(target, 0, gl.RGBA, gl.RGBA, dataFormat, textureObject._imageData);
-    
-        gl.texParameteri(target, gl.TEXTURE_WRAP_S, getClampMode(gl,textureObject.wrapModeX));
-        gl.texParameteri(target, gl.TEXTURE_WRAP_T, getClampMode(gl,textureObject.wrapModeY));
-    
-        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, getTextureFilter(gl, textureObject.magFilter));
-        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, getTextureFilter(gl, textureObject.minFilter));
-    
-        if (textureObject.mipmapRequired) {
-            gl.generateMipmap(target);
-        }
-    }
-}
-
-export default class WebGLTextureRenderer extends TextureRenderer {
-    static ListTextures(glOrRenderer) {
-        if (glOrRenderer instanceof Renderer) {
-            glOrRenderer = glOrRenderer.gl;
-        }
-        return glOrRenderer._bg2_textures || {};
-    }
-
-    getApiObject() {
-        if (this.texture.dirty) {
-            try {
-                getWebGLTexture(this.renderer.gl, this.texture);
-                this.texture.setUpdated();
-            }
-            catch (err) {
-                console.warn(err.message);
-            }
-        }
-        return this.texture._apiObject;
-    }
-    
-    destroy() {
-        const { gl } = this.renderer;
-        bg2eDeleteTexture(gl, this.texture);
-    }
-
-    ///// webgl specific functions
-    // Returns the webgl target (TEXTURE_2D, TEXTURE_3D...)
-    get target() {
-        return this.renderer.gl[TextureTargetName[this.texture.target]];
-    }
-
-    activeTexture(index = 0) {
-        const { gl } = this.renderer;
-        gl.activeTexture(gl.TEXTURE0 + index);
-    }
-
-    bindTexture() {
-        this.renderer.gl.bindTexture(this.target, this.getApiObject());
-    }
-}