@woosh/meep-engine 2.75.8 → 2.76.0

package/src/engine/graphics/render/buffer/executor/FrameBufferPool.js

@@ -1,127 +0,0 @@
-import { WebGLRenderTarget } from "three";
-import { RenderTargetParameters } from "../slot/parameter/RenderTargetParameters.js";
-
-/**
- *
- * @param {ProgramValueSlotParameterSet} parameters
- * @returns {WebGLRenderTarget}
- */
-function makeRenderTarget(parameters) {
-    const options = {};
-
-    const pFormat = parameters.getParameterByName(RenderTargetParameters.Format);
-
-    if (pFormat !== undefined) {
-        options.format = pFormat.value;
-    }
-
-    const pDataType = parameters.getParameterByName(RenderTargetParameters.DataType);
-
-    if (pDataType !== undefined) {
-        options.type = pDataType.value;
-    }
-
-    const pEncoding = parameters.getParameterByName(RenderTargetParameters.Encoding);
-
-    if (pEncoding !== undefined) {
-        options.encoding = pEncoding.value;
-    }
-
-    const result = new WebGLRenderTarget(0, 0, options);
-
-    return result;
-}
-
-class PoolEntry {
-    /**
-     *
-     * @param {ProgramValueSlotParameterSet} parameters
-     * @param {number} parametersHash
-     */
-    constructor({ parameters, parametersHash }) {
-        this.inUse = false;
-        /**
-         *
-         * @type {ProgramValueSlotParameterSet}
-         */
-        this.parameters = parameters;
-        this.parametersHash = parametersHash;
-        /**
-         *
-         * @type {WebGLRenderTarget}
-         */
-        this.buffer = makeRenderTarget(parameters);
-    }
-}
-
-
-export class FrameBufferPool {
-    constructor() {
-        /**
-         *
-         * @type {PoolEntry[]}
-         */
-        this.buffers = [];
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotParameterSet} parameters
-     * @returns {WebGLRenderTarget}
-     */
-    get(parameters) {
-        //compute hash
-        const parametersHash = parameters.hash();
-
-        //try to find one
-        let poolEntry = this.buffers.find(e => !e.inUse && e.parametersHash === parametersHash);
-
-        if (poolEntry === undefined) {
-            //doesn't exist, make one
-            poolEntry = new PoolEntry({ parameters, parametersHash });
-
-        }
-
-        //mark as being in use
-        poolEntry.inUse = true;
-
-        return poolEntry.buffer;
-    }
-
-    /**
-     *
-     * @param {WebGLRenderTarget} buffer
-     * @returns {boolean}
-     */
-    release(buffer) {
-        for (let i = 0; i < this.buffers.length; i++) {
-            const poolEntry = this.buffers[i];
-
-            if (poolEntry.buffer === buffer) {
-                if (poolEntry.inUse === false) {
-                    console.error('Attempting to release buffer that is not registered as being in use', poolEntry);
-                    return false;
-                }
-
-                poolEntry.inUse = false;
-                return true;
-            }
-        }
-
-        console.error('Attempted to release buffer that is not registered');
-        return false;
-    }
-
-    reset() {
-        while (this.buffers.length > 0) {
-            const poolEntry = this.buffers.pop();
-            //release resources
-            poolEntry.buffer.dispose()
-        }
-    }
-
-    destroy() {
-        //release all render targets
-        this.buffers.forEach(e => e.buffer.dispose());
-    }
-}

package/src/engine/graphics/render/buffer/executor/RenderGraphExecutor.js

@@ -1,261 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-import { ProgramValueDirectionKind } from "../slot/ProgramValueDirectionKind.js";
-import { ProgramValueType } from "../slot/ProgramValueType.js";
-import { FrameBufferPool } from "./FrameBufferPool.js";
-
-/**
- *
- * @param {ProgramSlotValue} slot
- * @param {function(ProgramValueSlotConnectionEndpoint)} visitor
- */
-function traverseInputBufferUsers(slot, visitor) {
-    let i, il, j, jl;
-
-    const connections0 = slot.connections;
-
-    for (i = 0, il = connections0.length; i < il; i++) {
-        const c0 = connections0[i];
-
-        const sourceSlot = c0.source.node.getSlotValue(c0.source.slot);
-
-        const connections1 = sourceSlot.connections;
-
-        for (j = 0, jl = connections1.length; j < jl; j++) {
-
-            const c1 = connections1[j];
-
-            if (c1 === c0) {
-                //ignore own connection
-                return;
-            }
-
-            const continueFlag = visitor(c1.target);
-
-            if (continueFlag === false) {
-                //stop traversal
-                return;
-            }
-        }
-    }
-}
-
-/**
- *
- * @param {RenderGraph} graph
- * @returns {RenderProgramInstance[]}
- */
-function computeExecutionOrder(graph) {
-
-    const terminalNode = graph.getTerminalNode();
-
-    assert.notEqual(terminalNode, null, 'terminal node must not be null');
-
-    const closedNodeList = [];
-    const openSet = [terminalNode];
-
-    while (openSet.length > 0) {
-        const head = openSet.shift();
-
-        closedNodeList.push(head);
-
-        const predecessorNodes = graph.getPredecessorNodes(head);
-
-        predecessorNodes.forEach(n => {
-            if (openSet.indexOf(n) === -1) {
-                openSet.push(n);
-            }
-
-            if (closedNodeList.indexOf(n) !== -1) {
-                //a loop exists
-                throw new Error(`A loop was detected, graph is not an DAG`);
-            }
-        });
-    }
-
-    //reverse the order
-    closedNodeList.reverse();
-
-    return closedNodeList;
-}
-
-export class RenderGraphExecutor {
-    constructor() {
-        /**
-         *
-         * @type {RenderGraph|null}
-         */
-        this.graph = null;
-
-        /**
-         *
-         * @type {FrameBufferPool}
-         */
-        this.frameBufferPool = new FrameBufferPool();
-    }
-
-    /**
-     *
-     * @param {RenderGraph} graph
-     */
-    initialize(graph) {
-        /**
-         *
-         * @type {RenderGraph}
-         */
-        this.graph = graph;
-
-        //clear frame buffers
-        this.frameBufferPool.reset();
-    }
-
-    build() {
-        //find screen output slot
-        const graph = this.graph;
-
-        const executionOrder = computeExecutionOrder(graph);
-
-        // At this point we have the execution order for nodes
-
-
-    }
-
-    execute(renderer, scene, camera) {
-        const frameBufferPool = this.frameBufferPool;
-        const graph = this.graph;
-
-        const executed = [];
-        //put all nodes into open set
-        const open = graph.nodes.slice();
-        //
-        const scheduled = [];
-
-        function attemptScheduling() {
-            let i, j, numOpenNodes;
-
-            numOpenNodes = open.length;
-
-            open_loop:for (i = 0; i < numOpenNodes; i++) {
-                const node = open[i];
-                const predecessorNodes = graph.getPredecessorNodes(node);
-
-                const numPredecessors = predecessorNodes.length;
-                for (j = 0; j < numPredecessors; j++) {
-                    const predecessorNode = predecessorNodes[j];
-
-                    if (executed.indexOf(predecessorNode) === -1) {
-                        //predecessor has not been executed yet
-                        continue open_loop;
-                    }
-                }
-
-                //all predecessors have been satisfied, schedule node
-                open.splice(i, 1);
-
-                i--;
-                numOpenNodes--;
-
-                //add to scheduled set
-                scheduled.push(node);
-            }
-        }
-
-
-        /**
-         *
-         * @param {RenderProgramInstance} n
-         */
-        function executeNode(n) {
-            //assign output buffers to slots
-
-            /**
-             *
-             * @type {RenderProgramDefinition}
-             */
-            const programDefinition = n.definition;
-
-            /**
-             *
-             * @type {ProgramSlotValue[]}
-             */
-            const outputBufferValues = [];
-            /**
-             *
-             * @type {ProgramSlotValue[]}
-             */
-            const inputBufferValues = [];
-
-            n.slotValues.forEach(s => {
-                if (s.definition.type !== ProgramValueType.FrameBuffer) {
-                    return;
-                }
-                if (s.definition.direction === ProgramValueDirectionKind.Out) {
-                    outputBufferValues.push(s);
-                } else {
-                    inputBufferValues.push(s);
-                }
-            });
-
-            outputBufferValues.forEach(v => {
-                /**
-                 *
-                 * @type {ProgramValueSlotDefinition}
-                 */
-                const valueSlotDefinition = v.definition;
-
-                const renderTarget = frameBufferPool.get(valueSlotDefinition.parameters);
-
-                v.setValue(renderTarget);
-            });
-
-            programDefinition.execute(n, renderer, camera, scene);
-
-            //write slot values along the connections
-            n.slotValues
-                .filter(s => s.definition.direction === ProgramValueDirectionKind.Out)
-                .forEach(s => {
-                    s.connections.forEach(c => {
-                        const targetSlot = c.target.node.getSlotValue(c.target.slot);
-
-                        targetSlot.setValue(s.getValue());
-                    });
-                });
-
-
-            //release buffers that may have become unnecessary
-            inputBufferValues.forEach(i => {
-                let stillInUse = false;
-                traverseInputBufferUsers(i, endpoint => {
-                    if (executed.indexOf(endpoint.node) === -1) {
-                        //has not yet been executed
-                        stillInUse = true;
-
-                        //signal to stop traversal
-                        return false;
-                    }
-                });
-
-                if (!stillInUse) {
-                    //release buffer so it can be reused
-                    frameBufferPool.release(i.getValue());
-                }
-            });
-        }
-
-        while (open.length > 0) {
-            attemptScheduling();
-
-            if (scheduled.length <= 0) {
-                throw new Error(`no nodes scheduled from open set (length=${open.length})`);
-            }
-
-            while (scheduled.length > 0) {
-                const node = scheduled.pop();
-
-                executeNode(node);
-
-                //move to executed set
-                executed.push(node);
-            }
-        }
-    }
-}

package/src/engine/graphics/render/buffer/executor/RenderProgramCommandType.js

@@ -1,5 +0,0 @@
-/**
- *
- * @enum {number}
- */
-export const RenderProgramCommandType = {};

package/src/engine/graphics/render/buffer/node/DeferredRenderProgramDefinition.js

@@ -1,142 +0,0 @@
-import { RenderProgramDefinition } from "./RenderProgramDefinition.js";
-import { ProgramValueSlotDefinition } from "../slot/ProgramValueSlotDefinition.js";
-import { ProgramValueType } from "../slot/ProgramValueType.js";
-import { ProgramValueDirectionKind } from "../slot/ProgramValueDirectionKind.js";
-import { ProgramValueSlotParameter } from "../slot/parameter/ProgramValueSlotParameter.js";
-import { RenderTargetParameters } from "../slot/parameter/RenderTargetParameters.js";
-import { ProgramValueSlotParameterType } from "../slot/parameter/ProgramValueSlotParameterType.js";
-import { FrontSide, MeshDepthMaterial, NoBlending, RGBADepthPacking, RGBAFormat } from "three";
-
-const DepthOutput = new ProgramValueSlotDefinition({
-    type: ProgramValueType.FrameBuffer,
-    name: 'depth',
-    direction: ProgramValueDirectionKind.Out
-});
-
-DepthOutput.parameters.add(new ProgramValueSlotParameter({
-    name: RenderTargetParameters.Format,
-    type: ProgramValueSlotParameterType.UnsignedInteger,
-    value: RGBAFormat
-}));
-
-const ColorOutput = new ProgramValueSlotDefinition({
-    type: ProgramValueType.FrameBuffer,
-    name: 'color',
-    direction: ProgramValueDirectionKind.Out
-});
-
-ColorOutput.parameters.add(new ProgramValueSlotParameter({
-    name: RenderTargetParameters.Format,
-    type: ProgramValueSlotParameterType.UnsignedInteger,
-    value: RGBAFormat
-}));
-
-
-function makeDepthRenderer() {
-    const depthMaterialSkinned = new MeshDepthMaterial();
-    depthMaterialSkinned.depthPacking = RGBADepthPacking;
-    depthMaterialSkinned.blending = NoBlending;
-    depthMaterialSkinned.side = FrontSide;
-    depthMaterialSkinned.skinning = true;
-
-    const depthMaterialStatic = new MeshDepthMaterial();
-    depthMaterialStatic.depthPacking = RGBADepthPacking;
-    depthMaterialStatic.blending = NoBlending;
-    depthMaterialStatic.side = FrontSide;
-
-
-    const materialMap = [];
-
-    function renderMethod(renderer, camera, scene, renderTarget) {
-
-        const currentVrEnabled = renderer.vr.enabled;
-        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-
-        renderer.vr.enabled = false; // Avoid camera modification and recursion
-        renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
-
-        scene.overrideMaterial = null;
-
-        //replace materials in the scene
-        scene.traverse(function (object) {
-            const material = object.material;
-            if (material !== undefined && material.depthWrite) {
-                //remember old material
-                materialMap[object.id] = material;
-
-                //set new material
-                if (material.customDepthMaterial !== undefined) {
-                    object.material = material.customDepthMaterial;
-                } else if (material.skinning) {
-                    object.material = depthMaterialSkinned;
-                } else {
-                    object.material = depthMaterialStatic;
-                }
-            }
-        });
-
-        renderer.render(scene, camera, renderTarget, true);
-
-        //restore materials
-        scene.traverse(function (object) {
-            const material = object.material;
-            if (material !== undefined) {
-                const id = object.id;
-                const m = materialMap[id];
-                if (m !== undefined) {
-                    object.material = m;
-
-                    delete materialMap[id];
-                }
-            }
-        });
-
-        scene.overrideMaterial = null;
-
-        renderer.vr.enabled = currentVrEnabled;
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-    }
-
-    return renderMethod;
-}
-
-export class DeferredRenderProgramDefinition extends RenderProgramDefinition {
-    constructor() {
-        super();
-
-        const slots = this.slots;
-
-        slots.push(ColorOutput);
-        slots.push(DepthOutput);
-
-        this.__depthRenderMethod = makeDepthRenderer();
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} instance
-     * @param {WebGLRenderer} renderer
-     * @param {PerspectiveCamera|OrthographicCamera} camera
-     * @param {Scene} scene
-     */
-    execute(instance, renderer, camera, scene) {
-        const sColor = instance.getSlotValue(ColorOutput);
-        const sDepth = instance.getSlotValue(DepthOutput);
-
-        const rtColor = sColor.getValue();
-        const rtDepth = sDepth.getValue();
-
-        //disable stencil
-        rtDepth.stencilBuffer = false;
-
-        //draw depth
-        this.__depthRenderMethod(renderer, camera, scene, rtDepth);
-
-        //draw color
-        renderer.render(scene, camera, rtColor);
-
-    }
-}
-
-DeferredRenderProgramDefinition.OutputColor = ColorOutput;
-DeferredRenderProgramDefinition.OutputDepth = DepthOutput;

package/src/engine/graphics/render/buffer/node/RenderProgramDefinition.js

@@ -1,21 +0,0 @@
-export class RenderProgramDefinition {
-    constructor() {
-        /**
-         *
-         * @type {ProgramValueSlotDefinition[]}
-         */
-        this.slots = [];
-    }
-
-    build() {
-
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} instance
-     */
-    execute(instance) {
-        throw  new Error(`Not implemented. Needs to be overridden`);
-    }
-}

package/src/engine/graphics/render/buffer/node/RenderProgramInstance.js

@@ -1,30 +0,0 @@
-import { ProgramSlotValue } from "../slot/ProgramSlotValue.js";
-
-export class RenderProgramInstance {
-    /**
-     *
-     * @param {RenderProgramDefinition} definition
-     */
-    constructor({ definition }) {
-        /**
-         *
-         * @type {RenderProgramDefinition}
-         */
-        this.definition = definition;
-
-        /**
-         *
-         * @type {ProgramSlotValue[]}
-         */
-        this.slotValues = definition.slots.map(s => new ProgramSlotValue(s));
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotDefinition} definition
-     * @return {ProgramSlotValue}
-     */
-    getSlotValue(definition) {
-        return this.slotValues.find(v => v.definition === definition);
-    }
-}

package/src/engine/graphics/render/buffer/node/ScreenSpaceRenderProgramDefinition.js

@@ -1,118 +0,0 @@
-import { RenderProgramDefinition } from "./RenderProgramDefinition.js";
-import { Mesh, OrthographicCamera, PlaneBufferGeometry, Scene, ShaderMaterial, Vector2, Vector3, Vector4 } from "three";
-import { ProgramValueDirectionKind } from "../slot/ProgramValueDirectionKind.js";
-import { ProgramValueType } from "../slot/ProgramValueType.js";
-
-/**
- * Three.js uniform types
- * @enum {string}
- */
-export const ThreeUniformType = {
-    Texture: 't',
-    Float: 'f',
-    Vector2: 'v2',
-    Vector3: 'v3',
-    Vector4: 'v4',
-    Matrix4: 'm4'
-};
-
-/**
- *
- * @param {ProgramValueType} t
- * @returns {ThreeUniformType}
- */
-function slotType2ThreeUniormType(t) {
-    switch (t) {
-        case ProgramValueType.FrameBuffer:
-            return ThreeUniformType.Texture;
-        case ProgramValueType.Scalar:
-            return ThreeUniformType.Float;
-        case ProgramValueType.Vector2:
-            return ThreeUniformType.Vector2;
-        case  ProgramValueType.Vector3:
-            return ThreeUniformType.Vector3;
-        case ProgramValueType.Vector4:
-            return ThreeUniformType.Vector4;
-        default:
-            throw  new TypeError(`Unsupported slot type: '${t}'`);
-    }
-}
-
-/**
- *
- * @param {ProgramValueType} t
- */
-function slotTpe2InitialValue(t) {
-    switch (t) {
-        case ProgramValueType.FrameBuffer:
-            return null;
-        case ProgramValueType.Scalar:
-            return 0.0;
-        case ProgramValueType.Vector2:
-            return new Vector2();
-        case  ProgramValueType.Vector3:
-            return new Vector3();
-        case ProgramValueType.Vector4:
-            return new Vector4();
-        default:
-            throw  new TypeError(`Unsupported slot type: '${t}'`);
-    }
-}
-
-export class ScreenSpaceRenderProgramDefinition extends RenderProgramDefinition {
-    /**
-     *
-     * @param {string} vertexShader
-     * @param {string} fragmentShader
-     */
-    constructor({ vertexShader, fragmentShader }) {
-        super();
-
-        this.fragmentShader = fragmentShader;
-        this.vertexShader = vertexShader;
-    }
-
-    build() {
-
-        const uniforms = {};
-
-        //Build uniforms
-        this.slots.forEach(s => {
-            if (s.direction !== ProgramValueDirectionKind.In) {
-                return;
-            }
-
-            const slotName = s.name;
-
-            const slotType = s.type;
-
-            const uniformType = slotType2ThreeUniormType(slotType);
-            const uniformValue = slotTpe2InitialValue(slotType);
-
-            uniforms[slotName] = {
-                type: uniformType,
-                value: uniformValue
-            };
-
-        });
-
-        this.uniforms = uniforms;
-
-        //build material
-        this.material = new ShaderMaterial({
-
-            defines: {},
-            uniforms: this.uniforms,
-            vertexShader: this.vertexShader,
-            fragmentShader: this.fragmentShader
-
-        });
-
-
-        this.camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
-        this.scene = new Scene();
-
-        this.quad = new Mesh(new PlaneBufferGeometry(2, 2), this.material);
-        this.scene.add(this.quad);
-    }
-}