bg2e-js 2.0.1 → 2.0.2

package/render/PolyListRenderer.js

@@ -1,42 +0,0 @@
-
-export default class PolyListRenderer {
-    constructor(renderer,polyList) {
-        if (polyList.renderer) {
-            throw new Error("Invalid initialization of polyList renderer: the polyList is already controlled by another polyList renderer.")
-        }
-        this._renderer = renderer;
-        this._polyList = polyList;
-        this._polyList._renderer = this;
-    }
-
-    get polyList() {
-        return this._polyList;
-    }
-
-    get renderer() {
-        return this._renderer;
-    }
-
-    init() {
-
-    }
-
-    // Updates the internal state of the renderer. It is necessary to call this
-    // function if the polyList has been modified, so that the internal objects
-    // of the specific rendering API are updated.
-    refresh() {
-
-    }
-
-    bindBuffers() {
-
-    }
-
-    draw() {
-
-    }
-
-    destroy() {
-        
-    }
-}

package/render/RenderBuffer.js

@@ -1,189 +0,0 @@
-import Texture, { TextureDataType, TextureTarget, TextureRenderTargetAttachmentNames } from "../base/Texture";
-import Vec from "../math/Vec";
-import Mat4 from "../math/Mat4";
-
-export const RenderBufferType = {
-    UNINITIALIZED: 0,
-    TEXTURE: 1,
-    CUBE_MAP: 2
-};
-
-export const RenderBufferTypeName = {
-    0: 'UNINITIALIZED',
-    1: 'TEXTURE',
-    2: 'CUBE_MAP'
-};
-
-export const CubeMapFace = {
-    NONE: 0,
-    POSITIVE_X: 1,
-    NEGATIVE_X: 2,
-    POSITIVE_Y: 3,
-    NEGATIVE_Y: 4,
-    POSITIVE_Z: 5,
-    NEGATIVE_Z: 6
-}
-
-function getTargetType(texture) {
-    if (texture.target === TextureTarget.TEXTURE_2D) {
-        return RenderBufferType.TEXTURE;
-    }
-    else if (texture.target === TextureTarget.CUBE_MAP) {
-        return RenderBufferType.CUBE_MAP;
-    }
-}
-
-function getRenderBufferTypeName(type) {
-    return RenderBufferTypeName[type];
-}
-
-
-export default class RenderBuffer {
-    constructor(renderer, size = new Vec([512,512])) {
-        this._renderer = renderer;
-        this._attachments = {};
-        this._size = size;
-        this._dirty = true;
-        this._type = RenderBufferType.UNINITIALIZED;
-    }
-
-    get renderer() { return this._renderer; }
-
-    get type() { return this._type; }
-
-    get size() { return this._size; }
-
-    set size(s) {
-        this._size = new Vec(s); 
-        for (const att in this.attachments) {
-            const textureRenderer = this.attachments[att];
-            const texture = textureRenderer.texture;
-            if (!Vec.Equals(texture.size, this.size)) {
-                texture.size = this.size;
-            }
-        }
-        this._dirty = true;
-    }
-
-    // This is an object of type { TextureRenderTargetAttachmentName: TextureRenderer }
-    get attachments() { return this._attachments; }
-
-    getTextureRenderer(attachment) {
-        return this._attachments[attachment];
-    }
-
-    getTexture(attachment) {
-        return this.getAttachment(attachment)?.texture;
-    }
-
-    get dirty() { return this._dirty; }
-
-    setUpdated(updated = true) { this._dirty = !updated; }
-
-    async attachTexture(texture) {
-        if (this._attachments[texture.renderTargetAttachment]) {
-            throw new Error(`RenderBuffer.attachTexture(): The attachment is occupied by another texture ${TextureRenderTargetAttachmentNames[texture.renderTargetAttachment]}`);
-        }
-
-        if (this.type !== RenderBufferType.UNINITIALIZED) {
-            const type = getTargetType(texture);
-            if (this.type !== type) {
-                throw new Error(`Invalid texture attachment. RenderBuffer is ${ getRenderBufferTypeName(this.type) }, but the new attachment is ${ getRenderBufferTypeName(type) }`);
-            }
-        }
-        else {
-            this._type = getTargetType(texture);
-        }
-
-        texture.dataType = TextureDataType.RENDER_TARGET;
-        texture.size = this.size;
-        await texture.loadImageData();
-        const textureRenderer = this.renderer.factory.texture(texture);
-        this._attachments[texture.renderTargetAttachment] = textureRenderer;
-    }
-
-    detachTexture(texture) {
-        const textureRenderer = this._attachments[texture.renderTargetAttachment];
-        if (!textureRenderer) {
-            throw new Error(`RenderBuffer.detachTexture(): no texture attached to ${TextureRenderTargetAttachmentNames[texture.renderTargetAttachment]}`);
-        }
-
-        if (textureRenderer.texture !== texture) {
-            throw new Error(`RenderBuffer.detachTexture(): the texture is not attached to ${TextureRenderTargetAttachmentNames[texture.renderTargetAttachment]}`);
-        }
-
-        this._attachments[texture.renderTargetAttachment] = null;
-        textureRenderer.deleteTexture();
-        this._dirty = true;
-    }
-
-    beginUpdate(textureFace = CubeMapFace.NONE) {
-        throw new Error("RenderBuffer.beginUpdate(): calling base implementation.");
-    }
-
-    endUpdate(textureFace = CubeMapFace.NONE) {
-        throw new Error("RenderBuffer.endUpdate(): calling base implementation.");
-    }
-
-    destroy() {
-        throw new Error("RenderBuffer.destory(): calling base implementation.");
-    }
-
-    get frameBuffer() {
-        throw new Error("RenderBuffer.frameBuffer: calling base implementation");
-    }
-
-    // Save and restore buffer states must save the currently binded array buffer and restore it
-    saveVertexBufferState() {
-        throw new Error("RenderBuffer.saveVertexBufferState: callig base implementation");
-    }
-
-    restoreVertexBufferState() {
-        throw new Error("RenderBuffer.restoreVertexBufferState: calling base implementation");
-    }
-
-    update(drawFunc) {
-        this.saveVertexBufferState();
-        if (this.type === RenderBufferType.TEXTURE) {
-            this.beginUpdate();
-            drawFunc();
-            this.endUpdate();
-        }
-        else if (this.type === RenderBufferType.CUBE_MAP) {
-            const viewMatrix = Mat4.MakeIdentity();
-            const projectionMatrix = Mat4.MakePerspective(90, 1, 0.1, 100000);
-            for (let i = 0; i<6; ++i) {
-                const face = CubeMapFace.POSITIVE_X + i;
-                switch (face) {
-                case CubeMapFace.POSITIVE_X:
-                    viewMatrix.lookAt([-1, 0, 0], [0, 0, 0], [0,-1, 0]);
-                    break;
-                case CubeMapFace.NEGATIVE_X:
-                    viewMatrix.lookAt([ 1, 0, 0], [0, 0, 0], [0,-1, 0]);
-                    break;
-                case CubeMapFace.POSITIVE_Y:
-                    viewMatrix.lookAt([ 0,-1, 0], [0, 0, 0], [0, 0, 1]);
-                    break;
-                case CubeMapFace.NEGATIVE_Y:
-                    viewMatrix.lookAt([ 0, 1, 0], [0, 0, 0], [0, 0,-1]);
-                    break;
-                case CubeMapFace.POSITIVE_Z:
-                    viewMatrix.lookAt([ 0, 0,-1], [0, 0, 0], [0,-1, 0]);
-                    break;
-                case CubeMapFace.NEGATIVE_Z:
-                    viewMatrix.lookAt([ 0, 0, 1], [0, 0, 0], [0,-1, 0]);
-                    break;
-                }
-                
-                this.beginUpdate(face);
-                drawFunc(face,viewMatrix,projectionMatrix);
-                this.endUpdate(face);
-            }
-        }
-        this.restoreVertexBufferState();
-    }
-
-    readPixels(x, y, width, height, format, type) {
-        
-    }
- }

package/render/RenderQueue.js

@@ -1,162 +0,0 @@
-
-import { getLayers, RenderLayer } from "../base/PolyList";
-import Mat4 from "../math/Mat4";
-import { BlendFunction } from "./Pipeline";
-import RenderState from "./RenderState";
-
-export default class RenderQueue {
-    constructor(renderer) {
-        this._renderer = renderer;
-
-        this._queues = [];
-
-        this._viewMatrix = Mat4.MakeIdentity();
-        this._projectionMatrix = Mat4.MakeIdentity();
-
-        this._lights = [];
-    }
-
-    get renderer() {
-        return this._renderer;
-    }
-
-    get queues() {
-        return this._queues;
-    }
-
-    get viewMatrix() {
-        return this._viewMatrix;
-    }
-
-    set viewMatrix(m) {
-        this._viewMatrix.assign(m);
-    }
-
-    get projectionMatrix() {
-        return this._projectionMatrix;
-    }
-
-    set projectionMatrix(m) {
-        this._projectionMatrix.assign(m);
-    }
-
-    get lights() {
-        return this._lights;
-    }
-
-    getQueue(layer) {
-        return this._queues.find(l => l.layer === layer);
-    }
-
-    enableQueue(layer, shader, { beginOperation = null, endOperation = null, enabled = true } = {}) {
-        // TODO: Create pipelines for different render states (cull face, front face etc.)
-        const cullBackFace = this.renderer.factory.pipeline();
-        const cullFaceDisabled = this.renderer.factory.pipeline();
-        if (layer === RenderLayer.TRANSPARENT_DEFAULT) {
-            const blendState = {
-                enabled: true,
-                blendFuncSrc: BlendFunction.SRC_ALPHA,
-                blendFuncDst: BlendFunction.ONE_MINUS_SRC_ALPHA,
-                blendFuncSrcAlpha: BlendFunction.ONE,
-                blendFuncDstAlpha: BlendFunction.ONE_MINUS_SRC_ALPHA
-            };
-            cullBackFace.setBlendState(blendState);
-            cullFaceDisabled.setBlendState(blendState);
-        }
-        cullBackFace.create();
-        cullFaceDisabled.cullFace = false;
-        cullFaceDisabled.create();
-
-    
-        
-
-        const queue = this.getQueue(layer);
-        if (!queue) {
-            this._queues.push({
-                layer,
-                shader,
-                beginOperation,
-                endOperation,
-                enabled,
-                pipelines: {
-                    cullBackFace,
-                    cullFaceDisabled
-                },
-                queue: []
-            });
-        }
-        else {
-            queue.enabled = true;
-        }
-    }
-
-    disableQueue(layer) {
-        const queue = this.getQueue(layer);
-        if (queue) {
-            queue.enabled = true;
-        }
-    }
-
-    isQueueEnabled(layer) {
-        return this.getQueue(layer)?.enabled || false;
-    }
-
-    newFrame() {
-        this._queues.forEach(q => q.queue = []);
-        this._lights = [];
-    }
-
-    addPolyList(polyListRenderer, materialRenderer, modelMatrix) {
-        const plistLayers = getLayers(polyListRenderer.polyList, materialRenderer.material);
-        this._queues.forEach(({ layer, shader, queue, pipelines }) => {
-            if (plistLayers & layer) {
-                const { polyList } = polyListRenderer;
-                let pipeline = null;
-                // TODO: Select pipeline based on material and polyList properties
-                if (polyList.enableCullFace) {
-                    pipeline = pipelines.cullBackFace;
-                }
-                else {
-                    pipeline = pipelines.cullFaceDisabled;
-                }
-                queue.push(new RenderState({
-                    shader,
-                    polyListRenderer,
-                    materialRenderer,
-                    modelMatrix,
-                    viewMatrix: this.viewMatrix,
-                    projectionMatrix: this.projectionMatrix,
-                    pipeline
-                }))
-            }
-        });
-    }
-
-    addLight(light, transform) {
-        // Clear the depth texture, because this parameter
-        // is set each frame by the ShadowRenderer
-        light.depthTexture = null;
-        light.mvpMatrix = null;
-        this._lights.push({ light, transform });
-    }
-
-    draw(layer) {
-        const queue = this.getQueue(layer);
-        if (queue) {
-            if (typeof(queue.beginOperation) === "function") {
-                queue.beginOperation(layer);
-            }
-            
-            //queue.pipeline.activate();
-            queue.queue.forEach(rs => {
-                rs.draw();
-            });
-            if (typeof(queue.endOperation) === "function") {
-                queue.endOperation(layer);
-            }
-        }
-        else {
-            console.warn(`No render queue found for layer ${layer}`);
-        }
-    }
-}

package/render/RenderState.js

@@ -1,82 +0,0 @@
-
-import { RenderLayer } from "../base/PolyList";
-import Mat4 from "../math/Mat4";
-
-export default class RenderState {
-    constructor({
-        shader = null,
-        polyListRenderer = null,
-        materialRenderer = null,
-        modelMatrix = Mat4.MakeIdentity(),
-        viewMatrix = Mat4.MakeIdentity(),
-        projectionMatrix = Mat4.MakeIdentity(),
-        pipeline = null
-    }) {
-        this._shader = shader;
-        this._polyListRenderer = polyListRenderer;
-        this._materialRenderer = materialRenderer;
-        this._modelMatrix = modelMatrix;
-        this._viewMatrix = viewMatrix;
-        this._projectionMatrix = projectionMatrix;
-        this._pipeline = pipeline;
-    }
-
-    get valid() {
-        return this._shader && this._plistRenderer && this._materialRenderer;
-    }
-
-    get renderer() { return this._polyListRenderer?.renderer; }
-
-    set shader(shader) { this._shader = shader; }
-    get shader() { return this._shader; }
-    set polyListRenderer(polyListRenderer) { this._polyListRenderer = polyListRenderer; }
-    get polyListRenderer() { return this._polyListRenderer; }
-    set materialRenderer(materialRenderer) { this._materialRenderer = materialRenderer; }
-    get materialRenderer() { return this._materialRenderer; }
-    set modelMatrix(model) { this._modelMatrix = model; }
-    get modelMatrix() { return this._modelMatrix; }
-    set viewMatrix(view) { this._viewMatrix = view; }
-    get viewMatrix() { return this._viewMatrix; }
-    set projectionMatrix(projection) { this._projectionMatrix = projection; }
-    get projectionMatrix() { return this._projectionMatrix; }
-    get pipeline() { return this._pipeline; }
-    set pipeline(pl) { this._pipeline = pl; }
-
-    isLayerEnabled(layer) {
-        const { polyList } = this._polyListRenderer;
-        const { material } = this._materialRenderer;
-        const renderLayers = polyList.renderLayers === RenderLayer.AUTO ?
-            (material.isTransparent ? RenderLayer.TRANSPARENT_DEFAULT : RenderLayer.OPAQUE_DEFAULT) :
-            (polyList.renderLayers);
-        
-        return renderLayers & layer;
-    }
-
-    draw({ overrideShader = null, overrideViewMatrix = null, overrideProjectionMatrix = null} = {}) {
-        if (!this.polyListRenderer.polyList.visible) {
-            return;
-        }
-        if (this.renderer.debugMode) {
-            console.log(`======= Begin render polyList "${this.polyListRenderer.polyList.name}"    ==============`);
-        }
-
-        if (this.pipeline) {
-            this.pipeline.activate();
-        }
-        this.polyListRenderer.bindBuffers();
-        const shader = overrideShader || this.shader;
-        const viewMatrix = overrideViewMatrix || this.viewMatrix;
-        const projectionMatrix = overrideProjectionMatrix || this.projectionMatrix;
-        shader.setup(
-            this.polyListRenderer,
-            this.materialRenderer,
-            this.modelMatrix,
-            viewMatrix,
-            projectionMatrix
-        );
-        this.polyListRenderer.draw();
-        if (this.renderer.debugMode) {
-            console.log(`======= End render polyList "${this.polyListRenderer.polyList.name}"      ==============`);
-        }
-    }
-}

package/render/Renderer.js

@@ -1,202 +0,0 @@
-
-import PresentTextureShader from "../shaders/PresentTextureShader";
-import Material from "../base/Material";
-import PolyList from "../base/PolyList";
-import Environment from "./Environment";
-import TextureMergerRenderer from "./TextureMergerRenderer";
-
-export const EngineFeatures = {
-    RENDER_TARGET_TEXTURES:         0x1 << 0,
-    RENDER_TARGET_FLOAT:            0x1 << 1,
-    RENDER_TARGET_DEPTH:            0x1 << 2
-};
-
-export default class Renderer {
-    constructor(identifier) {
-        this._identifier = identifier;
-        this._frameBuffer = null;
-    }
-
-    get uniqueId() {
-        throw new Error("Calling Renderer.uniqueId base implementation.");
-    }
-
-    get typeId() {
-        throw new Error("Calling Renderer.typeId base implementation");
-    }
-
-    async init(canvas) {
-        this._canvas = canvas;
-    }
-
-    get canvas() {
-        return this._canvas;
-    }
-
-    get frameBuffer() {
-        throw new Error("Calling Renderer.frameBuffer base implementation.");
-    }
-
-    set viewport(vp) {
-        throw new Error("Calling Renderer.viewport setter base implementation.");
-    }
-
-    get viewport() {
-        throw new Error("Calling Renderer.viewport getter base implementation.");
-    }
-
-    get presentTextureSurfaceRenderer() {
-        if (!this._presentTextureSurface) {
-            const plist = new PolyList();
-            plist.vertex = [
-                -1, -1, 0,
-                 1, -1, 0,
-                 1,  1, 0,
-                -1,  1, 0
-            ];
-            plist.texCoord0 = [
-                0, 0,
-                1, 0,
-                1, 1,
-                0, 1
-            ];
-            plist.index = [
-                0, 1, 2,
-                2, 3, 0
-            ];
-            this._presentTextureSurface = this.factory.polyList(plist);
-        }
-        return this._presentTextureSurface;
-    }
-
-    async initPresentTextureShader() {
-        if (!this._presentTextureShader) {
-            this._presentTextureShader = new PresentTextureShader(this);
-            this._presentTextureShader.load();
-        }
-        return this._presentTextureShader;
-    }
-
-    get presentTextureShader() {
-        return this._presentTextureShader;
-    }
-
-    get presentTextureMaterialRenderer() {
-        if (!this._presentTextureMaterial) {
-            this._presentTextureMaterial = this.factory.material(new Material());
-        }
-        return this._presentTextureMaterial;
-    }
-
-    postReshape(width,height) {
-
-    }
-
-    postRedisplay() {
-
-    }
-
-    polyListFactory(plist) {
-        throw new Error("Calling base implementation of Renderer.polyListFactory()");
-    }
-
-    materialFactory(material) {
-        throw new Error("Calling base implementation of Renderer.materialFactory()");
-    }
-
-    textureFactory(texture) {
-        throw new Error("Calling base implementation of Renderer.textureFactory()");
-    }
-
-    renderBufferFactory() {
-        throw new Error("Calling base implementation of Renderer.renderBufferFactory()");
-    }
-
-    skySphereFactory() {
-        throw new Error("Calling base implementation of Renderer.skySphereFactory()");
-    }
-    
-    skyCubeFactory() {
-        throw new Error("Calling base implementation of Renderer.skyCubeFactory()");
-    }
-
-    environmentFactory() {
-        return new Environment(this);
-    }
-
-    textureMergerFactory() {
-        return new TextureMergerRenderer(this);
-    }
-
-    pipelineFactory() {
-        throw new Error("Calling base implementation of Renderer.pipelineFactory()");
-    }
-
-    sceneRendererFactory() {
-        throw new Error("Calling base implementation of Renderer.sceneRendererFactory()");
-    }
-
-    shadowRendererFactory() {
-        throw new Error("Calling base implementation of Renderer.shadowRendererFactory()");
-    }
-
-    get clearColor() {
-        throw new Error("Calling base implementation of Renderer.clearColor getter.");
-    }
-
-    set clearColor(c) {
-        throw new Error("Calling base implementation of Renderer.clearColor setter.");
-    }
-
-    get factory() {
-        const renderer = this;
-        return {
-            polyList(plist) {
-                return renderer.polyListFactory(plist);
-            },
-            material(material) {
-                return renderer.materialFactory(material);
-            },
-            texture(texture) {
-                return renderer.textureFactory(texture);
-            },
-            renderBuffer() {
-                return renderer.renderBufferFactory();
-            },
-            skySphere() {
-                return renderer.skySphereFactory();
-            },
-            skyCube() {
-                return renderer.skyCubeFactory();
-            },
-            environment() {
-                return renderer.environmentFactory();
-            },
-            textureMerger() {
-                return renderer.textureMergerFactory();
-            },
-            pipeline() {
-                return renderer.pipelineFactory();
-            },
-            scene() {
-                return renderer.sceneRendererFactory();
-            },
-            shadowRenderer() {
-                return renderer.shadowRendererFactory();
-            }
-        }
-    }
-
-    presentTexture(texture, { clearBuffers = true, shader = null, viewport = null } = {}) {
-        
-    }
-
-    // Compatibility function
-    supportsFeatures(feature) {
-        return false;
-    }
-
-    getMaximumRenderTargets() {
-        return 1;
-    }
-}