@woosh/meep-engine 2.75.8 → 2.76.0

package/src/engine/graphics/material/LoadMaterial.js

@@ -1,199 +0,0 @@
-/**
- * Created by Alex on 16/10/2014.
- */
-
-
-import {
-    ClampToEdgeWrapping,
-    DataTexture,
-    FrontSide,
-    LinearEncoding,
-    LinearFilter,
-    LinearMipMapLinearFilter,
-    MeshBasicMaterial,
-    MeshPhongMaterial,
-    RepeatWrapping,
-    RGBAFormat,
-    sRGBEncoding,
-    UnsignedByteType
-} from 'three';
-import { SplatMaterial } from "./SplatMaterial.js";
-import WaterMaterial from "./WaterMaterial.js";
-import loadSampler2D from "../texture/sampler/loadSampler2D.js";
-import { mergeSampler2D } from "../texture/sampler/mergeSampler2D.js";
-import { getTextureImmediate } from "./getTextureImmediate.js";
-
-/**
- * @param textures
- * @param repeat
- * @param type
- * @param gridResolution
- * @param bumpScale
- * @param transparent
- * @param {AssetManager} assetManager
- */
-export default function loadMaterial(
-    {
-        textures,
-        repeat = { x: 1, y: 1 },
-        type,
-        gridResolution,
-        bumpScale = 1,
-        transparent = false,
-        assetManager
-    }
-) {
-    let material;
-    //
-    const diffuse = textures.diffuse;
-    const normal = textures.normal;
-    const light = textures.light;
-    const bump = textures.bump;
-    const specular = textures.specular;
-
-    /**
-     *
-     * @param {Texture} t
-     */
-    function setTextureParameters(t) {
-        t.wrapS = RepeatWrapping;
-        t.wrapT = RepeatWrapping;
-        t.repeat.set(repeat.x, repeat.y);
-        t.anisotropy = 8;
-        t.encoding = sRGBEncoding;
-
-        t.minFilter = LinearMipMapLinearFilter;
-        t.magFilter = LinearFilter;
-    }
-
-    /**
-     *
-     * @param param
-     * @param callback
-     * @returns {Texture}
-     */
-    function loadTexture(param, callback) {
-        if (param.isTexture) {
-            return param;
-        }
-
-        const t = getTextureImmediate(param, assetManager);
-
-        setTextureParameters(t);
-
-        return t;
-    }
-
-    let result = {};
-
-    let o;
-    //treat splat differently
-    if (type === "splat") {
-
-        let splatMap;
-        //deal with a case where splat map is an missing, and instead "splatMaps' are given
-        if (textures.splat !== undefined && textures.splat.length !== undefined && textures.splat instanceof Array) {
-            splatMap = new DataTexture();
-            setTextureParameters(splatMap);
-
-            const promises = textures.splat.map((url) => loadSampler2D(url, assetManager));
-
-            result.splat = {
-                samplers: promises
-            };
-
-            Promise.all(promises).then(function (results) {
-                const merged = mergeSampler2D(results);
-                splatMap.format = RGBAFormat;
-                splatMap.type = UnsignedByteType;
-                splatMap.flipY = true;
-                splatMap.image = { data: merged.data, width: merged.width, height: merged.height };
-                splatMap.needsUpdate = true;
-
-                //No wrapping for splat maps
-                splatMap.wrapT = ClampToEdgeWrapping;
-                splatMap.wrapS = ClampToEdgeWrapping;
-
-                splatMap.encoding = LinearEncoding;
-                splatMap.needsUpdate = true;
-            }, function (error) {
-                console.error(error);
-            });
-        } else {
-            splatMap = loadTexture(textures.splat);
-        }
-
-        /**
-         * @type {Texture[]}
-         */
-        const diffuseTextures = textures.diffuse
-            .map(loadTexture);
-
-        o = {
-            splatMap: splatMap,
-            diffuseMaps: diffuseTextures
-                .map(t => {
-                    t.encoding = sRGBEncoding;
-
-                    return t;
-                }),
-            gridResolution
-        };
-    } else {
-        o = {
-            specular: 0,
-            shininess: 10,
-            color: 0xFFFFFF,
-            side: FrontSide,
-            flatShading: false
-        };
-        if (diffuse !== void 0 && !(diffuse instanceof Array)) {
-            o.map = loadTexture(diffuse);
-        }
-        if (normal !== void 0) {
-            o.normalMap = loadTexture(normal);
-        }
-        if (bump !== void 0) {
-            o.bumpMap = loadTexture(bump);
-            o.bumpScale = bumpScale;
-        }
-        if (specular !== void 0) {
-            o.specularMap = loadTexture(specular);
-            o.shininess = 50;
-            o.specular = 0x333333;
-        }
-    }
-    //
-    if (transparent) {
-        o.transparent = true;
-    }
-    if (light !== void 0) {
-        o.lightMap = loadTexture(light);
-    }
-
-    switch (type) {
-        case "basic":
-            material = new MeshBasicMaterial(o);
-            break;
-        case "splat":
-            //load diffuse maps
-            material = new SplatMaterial(o);
-
-            if (light) {
-                material.uniforms.lightMap.value = o.lightMap;
-            }
-
-            break;
-        case "water":
-            material = new WaterMaterial(o);
-            break;
-        default :
-        case "phong":
-            material = new MeshPhongMaterial(o);
-            break;
-    }
-
-    result.material = material;
-
-    return result;
-};

package/src/engine/graphics/material/getTextureImmediate.js

@@ -1,21 +0,0 @@
-import { GameAssetType } from "../../asset/GameAssetType.js";
-import { noop } from "../../../core/function/Functions.js";
-
-/**
- *
- * @param {string} url
- * @param {AssetManager} assetManager
- * @returns {Texture|undefined}
- */
-export function getTextureImmediate(url, assetManager) {
-
-    let t;
-
-    assetManager.get({
-        path: url, type: GameAssetType.DeferredTexture, callback: function (asset) {
-            t = asset.create();
-        }, failure: noop
-    });
-
-    return t;
-}

package/src/engine/graphics/render/buffer/RenderGraph.js

@@ -1,177 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import { ProgramValueSlotConnection } from "./conection/ProgramValueSlotConnection.js";
-import { ProgramValueSlotConnectionEndpoint } from "./conection/ProgramValueSlotConnectionEndpoint.js";
-import { RenderProgramInstance } from "./node/RenderProgramInstance.js";
-import { ProgramValueType } from "./slot/ProgramValueType.js";
-
-export class RenderGraph {
-
-    /**
-     *
-     * @type {RenderProgramInstance[]}
-     */
-    nodes = [];
-    /**
-     *
-     * @type {ProgramValueSlotConnection[]}
-     */
-    connections = [];
-
-    /**
-     *
-     * @type {ProgramValueSlotConnectionEndpoint|null}
-     */
-    finalOutput = null;
-
-
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     * @param {ProgramValueSlotDefinition} slot
-     */
-    setFinalOutput(node, slot) {
-        assert.ok(this.containsNode(node), 'Node is not contained in the graph');
-
-        assert.equal(slot.type, ProgramValueType.FrameBuffer, `expected slot type to be FrameBuffer, instead was '${slot.type}'`);
-
-        this.finalOutput = new ProgramValueSlotConnectionEndpoint({ node, slot });
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     * @returns {boolean}
-     */
-    containsNode(node) {
-        return this.nodes.some(n => n === node);
-    }
-
-    /**
-     *
-     * @param {RenderProgramDefinition} definition
-     */
-    createNode(definition) {
-        const instance = new RenderProgramInstance({ definition });
-
-        this.addNode(instance);
-
-        return instance;
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     * @returns {boolean}
-     */
-    addNode(node) {
-        if (this.containsNode(node)) {
-            //graph already contains the node
-            return false;
-        }
-
-        this.nodes.push(node);
-
-        return true;
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} sourceInstance
-     * @param {ProgramValueSlotDefinition} sourceSlot
-     * @param {RenderProgramInstance} targetInstance
-     * @param {ProgramValueSlotDefinition} targetSlot
-     * @returns {ProgramValueSlotConnection}
-     */
-    createConnection(sourceInstance, sourceSlot, targetInstance, targetSlot) {
-        const sourceEndpoint = new ProgramValueSlotConnectionEndpoint({ node: sourceInstance, slot: sourceSlot });
-        const targetEndpoint = new ProgramValueSlotConnectionEndpoint({ node: targetInstance, slot: targetSlot });
-
-        const connection = new ProgramValueSlotConnection({ source: sourceEndpoint, target: targetEndpoint });
-
-        this.addConnection(connection);
-
-        return connection;
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotConnection} connection
-     */
-    addConnection(connection) {
-        assert.ok(this.containsNode(connection.source.node), 'Connection source node is not a part of the graph');
-        assert.ok(this.containsNode(connection.target.node), 'Connection target node is not a part of the graph');
-
-        //add connection to source and target instance slots
-        connection.source.node.getSlotValue(connection.source.slot).addConnection(connection);
-        connection.target.node.getSlotValue(connection.target.slot).addConnection(connection);
-
-        this.connections.push(connection);
-    }
-
-    /**
-     * Returns node that contains screen output
-     * @returns {RenderProgramInstance|null}
-     */
-    getTerminalNode() {
-        return this.finalOutput.node;
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     * @returns {ProgramValueSlotConnection[]}
-     */
-    getConnectionsByNode(node) {
-        return this.connections.filter(function (c) {
-            return c.source.node === node || c.target.node === node;
-        });
-    }
-
-    /**
-     * Computes set of nodes that produce inputs for parameter node
-     * @param {RenderProgramInstance} node
-     * @returns {RenderProgramInstance[]}
-     */
-    getPredecessorNodes(node) {
-        return this.connections.filter(function (c) {
-            return c.target.node === node;
-        }).map(function (c) {
-            return c.source.node;
-        });
-    }
-
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     * @return {number}
-     */
-    computeNodeDepth(node) {
-        const predecessors = this.getPredecessorNodes(node);
-
-        if (predecessors.length === 0) {
-            return 0;
-        } else {
-            return Math.max.apply(null, predecessors.map(p => this.computeNodeDepth(p)));
-        }
-    }
-
-    /**
-     *
-     * @param {function} visitor
-     */
-    traverseNodes(visitor) {
-        const nodes = this.nodes;
-
-        const numNodes = nodes.length;
-
-        for (let i = 0; i < numNodes; i++) {
-            const programInstance = nodes[i];
-
-            const continueFlag = visitor(programInstance);
-
-            if (continueFlag === false) {
-                return;
-            }
-        }
-    }
-}

package/src/engine/graphics/render/buffer/RenderGraphUtils.js

@@ -1,32 +0,0 @@
-import { RenderGraph } from "./RenderGraph.js";
-import { RenderProgramDefinition } from "./node/RenderProgramDefinition.js";
-import { ProgramValueSlotDefinition } from "./slot/ProgramValueSlotDefinition.js";
-import { ProgramValueDirectionKind } from "./slot/ProgramValueDirectionKind.js";
-import { ProgramValueType } from "./slot/ProgramValueType.js";
-
-export function buildRenderGraph() {
-    const graph = new RenderGraph();
-
-    const outDepth = new ProgramValueSlotDefinition({
-        name: 'output',
-        direction: ProgramValueDirectionKind.Out,
-        type: ProgramValueType.FrameBuffer
-    });
-
-    const outColor = new ProgramValueSlotDefinition({
-        name: 'output',
-        direction: ProgramValueDirectionKind.Out,
-        type: ProgramValueType.FrameBuffer
-    });
-
-    const pColor = new RenderProgramDefinition();
-    pColor.slots.push(outColor);
-
-    const pDepth = new RenderProgramDefinition();
-    pDepth.slots.push(outDepth);
-
-    const piColor = graph.createNode(pColor);
-    const piDepth = graph.createNode(pDepth);
-
-
-}

package/src/engine/graphics/render/buffer/buffers/DepthFrameBuffer.js

@@ -1,101 +0,0 @@
-import {
-    FrontSide,
-    LinearFilter,
-    MeshDepthMaterial,
-    NoBlending,
-    RGBADepthPacking,
-    RGBAFormat,
-    WebGLRenderTarget
-} from "three";
-import { FrameBuffer } from "../FrameBuffer.js";
-
-
-export class DepthFrameBuffer extends FrameBuffer {
-    initialize(renderer) {
-        const depthMaterialStatic = new MeshDepthMaterial();
-        depthMaterialStatic.depthPacking = RGBADepthPacking;
-        depthMaterialStatic.blending = NoBlending;
-        depthMaterialStatic.side = FrontSide;
-
-        const materialMap = [];
-
-        this.depthMaterialStatic = depthMaterialStatic;
-        this.materialMap = materialMap;
-
-        this.renderTarget = new WebGLRenderTarget(this.size.x, this.size.y, {
-            minFilter: LinearFilter,
-            magFilter: LinearFilter,
-            format: RGBAFormat,
-            stencilBuffer: false,
-            generateMipmaps: false
-        });
-    }
-
-    render(renderer, camera, scene) {
-        const renderTarget = this.renderTarget;
-
-        const materialMap = this.materialMap;
-        const depthMaterialStatic = this.depthMaterialStatic;
-
-        // remember renderer state
-        const currentXrEnabled = renderer.xr.enabled;
-        const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-
-        renderer.xr.enabled = false; // Avoid camera modification and recursion
-        renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
-
-        scene.overrideMaterial = null;
-
-        /**
-         *
-         * @param {Object3D} object
-         */
-        function visitSceneObject(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 {
-                    object.material = depthMaterialStatic;
-                }
-            }
-        }
-
-        //replace materials in the scene
-        scene.traverse(visitSceneObject);
-
-        const oldRenderTarget = renderer.getRenderTarget();
-
-        renderer.setRenderTarget(renderTarget);
-        renderer.clear();
-
-        renderer.render(scene, camera);
-
-        renderer.setRenderTarget(oldRenderTarget);
-
-        //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];
-                }
-            }
-        });
-
-        // restore renderer
-        scene.overrideMaterial = null;
-
-        renderer.xr.enabled = currentXrEnabled;
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-    }
-}
-

package/src/engine/graphics/render/buffer/conection/ProgramValueSlotConnection.js

@@ -1,43 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-import { ProgramValueDirectionKind } from "../slot/ProgramValueDirectionKind.js";
-
-export class ProgramValueSlotConnection {
-    /**
-     *
-     * @param {ProgramValueSlotConnectionEndpoint} source
-     * @param {ProgramValueSlotConnectionEndpoint} target
-     */
-    constructor({ source, target }) {
-        assert.notEqual(source, undefined, 'source is undefined');
-        assert.notEqual(target, undefined, 'target is undefined');
-
-        assert.typeOf(source, 'object', 'source');
-        assert.typeOf(target, 'object', 'target');
-
-        assert.equal(source.slot.direction, ProgramValueDirectionKind.Out, `expected source slot direction to be Out, instead was '${source.slot.direction}'`);
-        assert.equal(target.slot.direction, ProgramValueDirectionKind.In, `expected source slot direction to be In, instead was '${target.slot.direction}'`);
-
-        assert.equal(source.slot.type, target.slot.type, `source(${source.slot.type}) and target(${target.slot.type}) slot types do not match`)
-
-        /**
-         *
-         * @type {ProgramValueSlotConnectionEndpoint}
-         */
-        this.source = source;
-
-        /**
-         *
-         * @type {ProgramValueSlotConnectionEndpoint}
-         */
-        this.target = target;
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotConnection} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.source.equals(other.source) && this.target.equals(other.target);
-    }
-}

package/src/engine/graphics/render/buffer/conection/ProgramValueSlotConnectionEndpoint.js

@@ -1,39 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-
-export class ProgramValueSlotConnectionEndpoint {
-    /**
-     *
-     * @param {RenderProgramInstance} node
-     * @param {ProgramValueSlotDefinition} slot
-     */
-    constructor({ node, slot }) {
-        assert.notEqual(node, undefined, 'node is undefined');
-        assert.notEqual(slot, undefined, 'slot is undefined');
-
-        assert.typeOf(node, 'object', 'node');
-        assert.typeOf(slot, 'object', 'slot');
-
-        assert.notEqual(node.definition.slots.indexOf(slot), -1, 'node does not contain specified slot');
-
-        /**
-         *
-         * @type {RenderProgramInstance}
-         */
-        this.node = node;
-        /**
-         *
-         * @type {ProgramValueSlotDefinition}
-         */
-        this.slot = slot;
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotConnectionEndpoint} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return (this.node === other.node) && (this.slot === other.slot)
-    }
-
-}

package/src/engine/graphics/render/buffer/conection/ProgramValueSlotConnectionValidator.js

@@ -1,30 +0,0 @@
-import { ProgramValueDirectionKind } from "../slot/ProgramValueDirectionKind.js";
-
-export class ProgramValueSlotConnectionValidator {
-    constructor() {
-
-    }
-
-    /**
-     *
-     * @param {ProgramValueSlotConnection} connection
-     */
-    validate(connection) {
-
-        const sourceEndpoint = connection.source;
-
-        if (sourceEndpoint.slot.direction === ProgramValueDirectionKind.In) {
-            //source slot must not be an input
-            return false;
-        }
-
-        const targetEndpoint = connection.target;
-
-        if (targetEndpoint.slot.direction === ProgramValueDirectionKind.Out) {
-            //target slot must not be an output
-            return false;
-        }
-
-        return true;
-    }
-}