@woosh/meep-engine 2.75.9 → 2.76.0

package/src/engine/graphics/render/staged/PostProcessingEffect.js

@@ -1,32 +0,0 @@
-import { PostProcessingEffectInputCoupling } from "./PostProcessingEffectInputCoupling.js";
-
-class PostProcessingEffect {
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     */
-    constructor({ node }) {
-        /**
-         *
-         * @type {RenderProgramInstance}
-         */
-        this.node = node;
-        /**
-         *
-         * @type {PostProcessingEffectInputCoupling[]}
-         */
-        this.inputWiring = [];
-    }
-
-    /**
-     *
-     * @param {string} outputName
-     * @param {ProgramValueType} outputType
-     * @param {ProgramValueSlotDefinition} input
-     */
-    couple(outputName, outputType, input) {
-        const inputCoupling = new PostProcessingEffectInputCoupling({ outputType, outputName, input });
-
-        this.inputWiring.push(inputCoupling);
-    }
-}

package/src/engine/graphics/render/staged/PostProcessingEffectInputCoupling.js

@@ -1,41 +0,0 @@
-import { ProgramValueDirectionKind } from "../buffer/slot/ProgramValueDirectionKind.js";
-import { assert } from "../../../../core/assert.js";
-
-export class PostProcessingEffectInputCoupling {
-    /**
-     *
-     * @param {string} outputName
-     * @param {ProgramValueType} outputType
-     * @param {ProgramValueSlotDefinition} input
-     */
-    constructor({ outputName, outputType, input }) {
-        assert.notEqual(input.direction, ProgramValueDirectionKind.Out, `Supplied input slot has OUT direction (not an input slot)`);
-
-        /**
-         *
-         * @type {ProgramValueSlotDefinition}
-         */
-        this.input = input;
-        /**
-         *
-         * @type {string}
-         */
-        this.outputName = outputName;
-        /**
-         *
-         * @type {ProgramValueType}
-         */
-        this.outputType = outputType;
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotDefinition} output
-     * @returns {boolean}
-     */
-    matchOutput(output) {
-        return (output.direction !== ProgramValueDirectionKind.In)
-            && output.type === this.outputType
-            && output.name === this.outputName;
-    }
-}

package/src/engine/graphics/render/staged/PostProcessingStack.js

@@ -1,29 +0,0 @@
-import List from "../../../../core/collection/list/List.js";
-
-export class PostProcessingStack {
-    constructor() {
-        /**
-         *
-         * @type {List<RenderProgramInstance>}
-         */
-        this.effects = new List();
-    }
-
-    /**
-     *
-     * @return {Set<string>}
-     */
-    getRequiredBuffers() {
-        const result = new Set();
-
-        this.effects.forEach(e => {
-            e.getRequiredBuffers().forEach(b => result.add(b));
-        });
-
-        return result;
-    }
-
-    isEmpty() {
-        this.effects.isEmpty();
-    }
-}

package/src/engine/graphics/render/staged/StagedRenderer.js

@@ -1,161 +0,0 @@
-import List from "../../../../core/collection/list/List.js";
-import { RenderGraph } from "../buffer/RenderGraph.js";
-import { RenderProgramDefinition } from "../buffer/node/RenderProgramDefinition.js";
-import { ProgramValueSlotConnection } from "../buffer/conection/ProgramValueSlotConnection.js";
-import { ProgramValueSlotConnectionEndpoint } from "../buffer/conection/ProgramValueSlotConnectionEndpoint.js";
-import { ProgramValueType } from "../buffer/slot/ProgramValueType.js";
-import { ProgramValueDirectionKind } from "../buffer/slot/ProgramValueDirectionKind.js";
-import { RenderGraphExecutor } from "../buffer/executor/RenderGraphExecutor.js";
-import { DeferredRenderProgramDefinition } from "../buffer/node/DeferredRenderProgramDefinition.js";
-
-
-/**
- *
- * @param {PostProcessingEffectInputCoupling} coupling
- * @param {RenderGraph} graph
- * @returns {ProgramValueSlotConnectionEndpoint}
- */
-function satisfyPostProcessCoupling(coupling, graph) {
-    let bestSlot = null;
-    let bestNode = null;
-    let bestDepth = Number.NEGATIVE_INFINITY;
-
-    graph.traverseNodes(n => {
-        /**
-         *
-         * @type {RenderProgramDefinition}
-         */
-        const definition = n.definition;
-
-        const matchingSlot = definition.slots.find(s => coupling.matchOutput(s));
-
-        if (matchingSlot !== undefined) {
-
-            const depth = graph.computeNodeDepth(n);
-
-            if (depth > bestDepth) {
-                //get slot on the node with the longest chain
-                bestDepth = depth;
-                bestSlot = matchingSlot;
-                bestNode = n;
-            }
-
-        }
-    });
-
-
-    if (bestSlot === null) {
-        //no matching slot found
-        return null;
-    }
-
-    return new ProgramValueSlotConnectionEndpoint({
-        node: bestNode,
-        slot: bestSlot
-    });
-}
-
-/**
- *
- * @param {PostProcessingEffect} effect
- * @param {RenderGraph} graph
- */
-function buildWiringForPostProcessEffect(effect, graph) {
-    const node = effect.node;
-    const inputWiring = effect.inputWiring;
-
-    const connections = inputWiring.map(c => {
-
-        const sourceEndpoint = satisfyPostProcessCoupling(c);
-
-        if (sourceEndpoint === null) {
-            throw new Error(`Input Coupling ${c} of effect ${effect} could not be satisfied`);
-        }
-
-        const targetEndpoint = new ProgramValueSlotConnectionEndpoint({
-            node: node,
-            slot: c.input
-        });
-
-        const connection = new ProgramValueSlotConnection({
-            source: sourceEndpoint,
-            target: targetEndpoint
-        });
-
-        return connection;
-    });
-
-    return connections;
-}
-
-export class StagedRenderer {
-    constructor() {
-        /**
-         *
-         * @type {List<PostProcessingEffect>}
-         */
-        this.postprocess = new List();
-
-        const self = this;
-
-        function update() {
-            self.graphNeedsUpdate = true;
-        }
-
-        this.postprocess.on.added.add(update);
-        this.postprocess.on.removed.add(update);
-
-        this.graphNeedsUpdate = true;
-        this.graphExecutor = new RenderGraphExecutor();
-    }
-
-    buildGraph() {
-        const graph = new RenderGraph();
-
-        const pDeferred = new DeferredRenderProgramDefinition();
-
-
-        const piDeferred = graph.createNode(pDeferred);
-
-        if (this.postprocess.isEmpty()) {
-            graph.setFinalOutput(piDeferred, DeferredRenderProgramDefinition.OutputColor);
-        } else {
-            this.postprocess.forEach(function (effect) {
-                const connections = buildWiringForPostProcessEffect(effect, graph);
-
-                //add effect node to the graph
-                graph.addNode(effect.node);
-
-                //add connections to the graph
-                connections.forEach(connection => graph.addConnection(connection));
-            });
-
-            const lastNode = this.postprocess.last().node;
-            const outputSlot = lastNode.definition.slots.find(s => s.type === ProgramValueType.FrameBuffer && s.direction === ProgramValueDirectionKind.Out);
-
-            graph.setFinalOutput(lastNode, outputSlot);
-        }
-
-        //attach graph to the executor
-        this.graphExecutor.initialize(graph);
-    }
-
-    /**
-     *
-     * @param {WebGLRenderer} renderer
-     * @param {PerspectiveCamera|OrthographicCamera} camera
-     * @param {Scene} scene
-     */
-    render(renderer, camera, scene) {
-        renderer.gammaInput = true;
-        renderer.gammaOutput = true;
-        renderer.autoClear = true;
-        renderer.clearAlpha = 0;
-
-        if (this.graphNeedsUpdate) {
-            this.buildGraph();
-            this.graphNeedsUpdate = false;
-        }
-        this.graphExecutor.execute(renderer, scene, camera);
-    }
-}

package/src/engine/graphics/render/staged/StandardRenderOutputs.js

@@ -1,20 +0,0 @@
-import { ProgramValueSlotDefinition } from "../buffer/slot/ProgramValueSlotDefinition.js";
-import { ProgramValueDirectionKind } from "../buffer/slot/ProgramValueDirectionKind.js";
-import { ProgramValueType } from "../buffer/slot/ProgramValueType.js";
-
-/**
- *
- * @enum {ProgramValueSlotDefinition}
- */
-export const StandardRenderOutputs = {
-    DepthBuffer: new ProgramValueSlotDefinition({
-        name: 'output',
-        direction: ProgramValueDirectionKind.Out,
-        type: ProgramValueType.FrameBuffer
-    }),
-    ColorBuffer: new ProgramValueSlotDefinition({
-        name: 'output',
-        direction: ProgramValueDirectionKind.Out,
-        type: ProgramValueType.FrameBuffer
-    })
-};

package/src/engine/graphics/texture/CanvasClone.js

@@ -1,28 +0,0 @@
-/**
- * Created by Alex on 15/11/2014.
- */
-
-
-/**
- *
- * @param {HTMLCanvasElement} oldCanvas
- * @return {HTMLCanvasElement}
- */
-function cloneCanvas(oldCanvas) {
-
-    //create a new canvas
-    const newCanvas = document.createElement('canvas');
-    const context = newCanvas.getContext('2d');
-
-    //set dimensions
-    newCanvas.width = oldCanvas.width;
-    newCanvas.height = oldCanvas.height;
-
-    //apply the old canvas to the new one
-    context.drawImage(oldCanvas, 0, 0);
-
-    //return the new canvas
-    return newCanvas;
-}
-
-export default cloneCanvas;

package/src/engine/graphics/texture/sampler/differenceSampler.js

@@ -1,36 +0,0 @@
-import { Sampler2D } from "./Sampler2D.js";
-import { vector_nd_normalize } from "../../../../core/math/vector_nd_normalize.js";
-import { vector_nd_dot } from "../../../../core/math/vector_nd_dot.js";
-
-/**
- * NOTE: treats samplers as normal maps
- * @param {Sampler2D} sampler0
- * @param {Sampler2D} sampler1
- * @returns {Sampler2D}
- */
-export function differenceSampler(sampler0, sampler1) {
-    const dimension_count = sampler0.itemSize;
-
-    const v0 = new Float64Array(dimension_count);
-    const v1 = new Float64Array(dimension_count);
-    //
-    const width = sampler0.width;
-    const height = sampler0.height;
-    //
-    const difference = new Float32Array(width * height);
-    for (let y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++) {
-            sampler0.sampleBilinear(x, y, v0);
-            sampler1.sampleBilinear(x, y, v1);
-
-            vector_nd_normalize(v0, v0, dimension_count);
-            vector_nd_normalize(v1, v1, dimension_count);
-
-            //check distance
-            difference[x + y * width] = 1 - vector_nd_dot(v0, v1, dimension_count);
-        }
-    }
-    //
-    const sampleD = new Sampler2D(difference, 1, width, height);
-    return sampleD;
-}

package/src/engine/graphics/texture/sampler/loadSampler2D.js

@@ -1,41 +0,0 @@
-/**
- * Created by Alex on 30/10/2014.
- */
-import { Sampler2D } from './Sampler2D.js';
-import { GameAssetType } from "../../../asset/GameAssetType.js";
-
-
-/**
- *
- * @param {string} url
- * @param {AssetManager} assetManager
- * @returns {Promise<Sampler2D>}
- */
-export default function loadSampler2D(url, assetManager) {
-    return new Promise(function (resolve, reject) {
-        assetManager.get({
-            path: url,
-            type: GameAssetType.Image,
-            callback: (asset) => {
-                const imageData = asset.create();
-
-                const width = imageData.width;
-                const height = imageData.height;
-
-                const data = imageData.data;
-
-                //
-                const bufferSize = width * height;
-                const buffer = new Float32Array(bufferSize);
-                //
-                for (let i = 0; i < bufferSize; i++) {
-                    const j = (i * 4);
-                    buffer[i] = (data[j] + data[j + 1] + data[j + 2]) / 765;
-                }
-                const sampler2D = new Sampler2D(buffer, 1, width, height);
-                resolve(sampler2D);
-            },
-            failure: reject
-        });
-    });
-};

package/src/engine/graphics/texture/sampler/mergeSampler2D.js

@@ -1,96 +0,0 @@
-/**
- * Created by Alex on 03/08/2016.
- */
-
-
-import { Sampler2D } from './Sampler2D.js';
-
-/**
- *
- * @param {Array.<Sampler2D>} inputs
- * @returns {Sampler2D}
- */
-function mergeSampler2D(inputs) {
-    if (inputs.length > 4) {
-        throw new Error("Can not merge more than 4 samplers");
-    } else if (inputs.length === 0) {
-        throw new Error("No samplers to merge");
-    }
-
-    const width = inputs[0].width;
-    const height = inputs[0].height;
-
-    //check dimensions of other inputs
-    for (let i = 1; i < inputs.length; i++) {
-        if (inputs[i].width !== width && inputs[i].height !== height) {
-            console.warn('dimensions of ' + i + " input don't match");
-        }
-    }
-
-    const uint8Array = new Uint8Array(width * height * 4);
-    const result = new Sampler2D(uint8Array, 4, width, height);
-
-    for (let i = 0, l = inputs.length; i < l; i++) {
-        const sampler = inputs[i];
-        mergeIntoChannel(sampler, result, i);
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {Sampler2D} source
- * @param {Sampler2D} target
- * @param {int} targetChannelIndex
- */
-function mergeIntoChannel(source, target, targetChannelIndex) {
-    let sample = 0;
-    let index = 0;
-
-    const sW = source.width;
-    const sH = source.height;
-
-    const tW = target.width;
-    const tH = target.height;
-
-    let x, y;
-
-    const tData = target.data;
-    const tItemSize = target.itemSize;
-
-    if (tW === sW && tH === sH) {
-        //dimensions match exactly, no re-sampling is required
-
-        const count = sW * sH;
-        const sData = source.data;
-
-        for (index = 0; index < count; index++) {
-            sample = sData[index];
-
-            tData[index * tItemSize + targetChannelIndex] = sample * 255;
-        }
-
-    } else {
-        //dimensions don't match, use re-sampling
-
-        //to account for 1-pixel size we force divisor to be at least 1
-        const vDivisor = Math.max(1, target.height - 1);
-        const uDivisor = Math.max(1, target.width - 1);
-
-        for (y = 0; y < tH; y++) {
-            const v = y / vDivisor;
-            for (x = 0; x < tW; x++) {
-                const u = x / uDivisor;
-                sample = source.sample(u, v, sample);
-                //
-                tData[index + targetChannelIndex] = sample * 255;
-
-                index += tItemSize;
-            }
-        }
-
-    }
-}
-
-export { mergeSampler2D };

package/src/engine/graphics/texture/sampler/rgbaData2valueSampler2D.js

@@ -1,38 +0,0 @@
-/**
- * Created by Alex on 11/11/2014.
- */
-import { Sampler2D } from './Sampler2D.js';
-
-/**
- *
- * @param {ArrayLike} data
- * @param {number} width
- * @param {number} height
- * @param {number} [scale=1]
- * @param {number} [offset=0]
- * @returns {Sampler2D}
- */
-function convert(data, width, height, scale, offset) {
-    scale = scale || 1;
-    offset = offset || 0;
-    const bufferSize = width * height;
-    const buffer = new Float32Array(bufferSize);
-
-    const multiplier = scale / 765;
-
-    for (let i = 0; i < bufferSize; i++) {
-
-        const j = (i * 4);
-
-        const r = data[j];
-        const g = data[j + 1];
-        const b = data[j + 2];
-
-        buffer[i] = (r + g + b) * multiplier + offset;
-
-    }
-
-    return new Sampler2D(buffer, 1, width, height);
-}
-
-export default convert;