@woosh/meep-engine 2.106.1 → 2.107.0

package/src/engine/graphics/shaders/SoftOutlineShader.js

@@ -1,111 +0,0 @@
-/**
- * Created by Alex on 02/10/2015.
- */
-import * as THREE from 'three';
-import { gaussian } from "../../../core/math/gaussian.js";
-
-let SoftOutlineShader = function (edge, sigma, hardPixels) {
-
-    function makeFragmentBody() {
-        const kernel = [];
-        let totalWeight = 0;
-        for (let x = -edge; x <= edge; x++) {
-            const wX = gaussian(sigma, x);
-            for (let y = -edge; y <= edge; y++) {
-                const radius = Math.sqrt(x * x + y * y);
-                if (radius > edge) {
-                    //exclude pixels that are not within the disk
-                    continue;
-                }
-                const wY = gaussian(sigma, y);
-                const weight = wX * wY;
-                totalWeight += weight;
-                kernel.push({
-                    x: x,
-                    y: y,
-                    weight: weight
-                });
-            }
-        }
-
-        //normalize weights
-        kernel.forEach(function (t) {
-            t.weight /= totalWeight;
-        });
-    }
-
-    return {
-
-        defines: {},
-
-        uniforms: {
-
-            "tDiffuse": { type: "t", value: null },
-            "resolution": { type: "v2", value: new THREE.Vector2(800, 600) },
-            "sigma": { type: "v2", value: new THREE.Vector2(6, 6) }
-        },
-
-        vertexShader: [
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "vUv = uv;",
-            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-            "}"
-
-        ].join("\n"),
-        fragmentShader: [
-            "const int   c_samplesX    = 11;",  // must be odd
-            "const int   c_samplesY    = 11;",  // must be odd
-
-            "const int   c_halfSamplesX = c_samplesX / 2;",
-            "const int   c_halfSamplesY = c_samplesY / 2;",
-
-            "uniform vec2 resolution;",
-            "uniform vec2 sigma;",
-            "uniform sampler2D tDiffuse;",
-            "varying vec2 vUv;",
-
-            "float Gaussian (float sigma, float x){",
-            "    return exp(-(x*x) / (2.0 * sigma*sigma));",
-            "}",
-
-            "vec4 BlurredPixel (in vec2 uv){",
-
-            "    float total = 0.0;",
-            "    vec4 ret = vec4(0.0);",
-
-            "    for (int iy = 0; iy < c_samplesY; ++iy){",
-            "        float fy = Gaussian (sigma.y, float(iy) - float(c_halfSamplesY));",
-            "        float offsety = float(iy-c_halfSamplesY) / resolution.y;",
-            "        for (int ix = 0; ix < c_samplesX; ++ix){",
-            "            float fx = Gaussian (sigma.x, float(ix) - float(c_halfSamplesX));",
-            "            float offsetx = float(ix-c_halfSamplesX) / resolution.x;",
-            "            total += fx * fy;",
-            "            ret += texture2D(tDiffuse, uv + vec2(offsetx, offsety)) * fx*fy;",
-            "        }",
-            "    }",
-            "    return ret / total;",
-            "}",
-
-            "void main() {",
-            "   if(texture2D(tDiffuse, vUv).a > 0.0){",
-            "       gl_FragColor = vec4(0.0);",
-            "   }else{",
-            "       gl_FragColor = BlurredPixel(vUv);",
-            "       if(gl_FragColor.a < 0.01){ ",
-            "           gl_FragColor = vec4(0.0);",
-            "       }",
-            "   }",
-
-            "}"
-
-
-        ].join("\n")
-    }
-};
-
-export default GaussianGlowShader;

package/src/engine/graphics/three/Reflector.d.ts

@@ -1,12 +0,0 @@
-export function Reflector(geometry: any, options: any): void;
-export class Reflector {
-    constructor(geometry: any, options: any);
-    type: string;
-    material: ShaderMaterial;
-    renderOrder: number;
-    onBeforeRender: (renderer: any, scene: any, camera: any) => void;
-    getRenderTarget: () => WebGLRenderTarget;
-}
-import { ShaderMaterial } from 'three';
-import { WebGLRenderTarget } from 'three';
-//# sourceMappingURL=Reflector.d.ts.map

package/src/engine/graphics/three/Reflector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Reflector.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/three/Reflector.js"],"names":[],"mappings":"AAoBA,6DAkMC;;IAlMD,yCAkMC;IA9LG,aAAuB;IAwDvB,yBAAwB;IACxB,oBAA4B;IAE5B,iEA2HC;IAED,yCAIC;;+BAlME,OAAO;kCAAP,OAAO"}

package/src/engine/graphics/three/Reflector.js

@@ -1,281 +0,0 @@
-/**
- * @author Slayvin / http://slayvin.net
- */
-
-import {
-    Color,
-    LinearFilter,
-    Math as ThreeMath,
-    Matrix4,
-    Mesh,
-    PerspectiveCamera,
-    Plane,
-    RGBFormat,
-    ShaderMaterial,
-    UniformsUtils,
-    Vector3,
-    Vector4,
-    WebGLRenderTarget
-} from 'three';
-
-function Reflector(geometry, options) {
-
-    Mesh.call(this, geometry);
-
-    this.type = 'Reflector';
-
-    const scope = this;
-
-    options = options || {};
-
-    const color = (options.color !== undefined) ? new Color(options.color) : new Color(0x7F7F7F);
-    const textureWidth = options.textureWidth || 512;
-    const textureHeight = options.textureHeight || 512;
-    const clipBias = options.clipBias || 0;
-    const shader = ReflectorShader;
-    const recursion = options.recursion !== undefined ? options.recursion : 0;
-
-    //
-
-    const reflectorPlane = new Plane();
-    const normal = new Vector3();
-    const reflectorWorldPosition = new Vector3();
-    const cameraWorldPosition = new Vector3();
-    const rotationMatrix = new Matrix4();
-    const lookAtPosition = new Vector3(0, 0, -1);
-    const clipPlane = new Vector4();
-    const viewport = new Vector4();
-
-    const view = new Vector3();
-    const target = new Vector3();
-    const q = new Vector4();
-
-    const textureMatrix = new Matrix4();
-    const virtualCamera = new PerspectiveCamera();
-
-    const parameters = {
-        minFilter: LinearFilter,
-        magFilter: LinearFilter,
-        format: RGBFormat,
-        stencilBuffer: false
-    };
-
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters);
-
-    if (!ThreeMath.isPowerOfTwo(textureWidth) || !ThreeMath.isPowerOfTwo(textureHeight)) {
-
-        renderTarget.texture.generateMipmaps = false;
-
-    }
-
-    const material = new ShaderMaterial({
-        uniforms: UniformsUtils.clone(shader.uniforms),
-        fragmentShader: shader.fragmentShader,
-        vertexShader: shader.vertexShader
-    });
-
-    material.uniforms.tDiffuse.value = renderTarget.texture;
-    material.uniforms.color.value = color;
-    material.uniforms.textureMatrix.value = textureMatrix;
-
-    this.material = material;
-    this.renderOrder = -Infinity; // render first
-
-    this.onBeforeRender = function (renderer, scene, camera) {
-
-        if ('recursion' in camera.userData) {
-
-            if (camera.userData.recursion === recursion) return;
-
-            camera.userData.recursion++;
-
-        }
-
-        reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
-        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
-
-        rotationMatrix.extractRotation(scope.matrixWorld);
-
-        normal.set(0, 0, 1);
-        normal.applyMatrix4(rotationMatrix);
-
-        view.subVectors(reflectorWorldPosition, cameraWorldPosition);
-
-        // Avoid rendering when reflector is facing away
-
-        if (view.dot(normal) > 0) return;
-
-        view.reflect(normal).negate();
-        view.add(reflectorWorldPosition);
-
-        rotationMatrix.extractRotation(camera.matrixWorld);
-
-        lookAtPosition.set(0, 0, -1);
-        lookAtPosition.applyMatrix4(rotationMatrix);
-        lookAtPosition.add(cameraWorldPosition);
-
-        target.subVectors(reflectorWorldPosition, lookAtPosition);
-        target.reflect(normal).negate();
-        target.add(reflectorWorldPosition);
-
-        virtualCamera.position.copy(view);
-        virtualCamera.up.set(0, 1, 0);
-        virtualCamera.up.applyMatrix4(rotationMatrix);
-        virtualCamera.up.reflect(normal);
-        virtualCamera.lookAt(target);
-
-        virtualCamera.far = camera.far; // Used in WebGLBackground
-
-        virtualCamera.updateMatrixWorld();
-        virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
-
-        virtualCamera.userData.recursion = 0;
-
-        // Update the texture matrix
-        textureMatrix.set(
-            0.5, 0.0, 0.0, 0.5,
-            0.0, 0.5, 0.0, 0.5,
-            0.0, 0.0, 0.5, 0.5,
-            0.0, 0.0, 0.0, 1.0
-        );
-        textureMatrix.multiply(virtualCamera.projectionMatrix);
-        textureMatrix.multiply(virtualCamera.matrixWorldInverse);
-        textureMatrix.multiply(scope.matrixWorld);
-
-        // Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
-        // Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
-        reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition);
-        reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse);
-
-        clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);
-
-        const projectionMatrix = virtualCamera.projectionMatrix;
-
-        q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
-        q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
-        q.z = -1.0;
-        q.w = (1.0 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
-
-        // Calculate the scaled plane vector
-        clipPlane.multiplyScalar(2.0 / clipPlane.dot(q));
-
-        // Replacing the third row of the projection matrix
-        projectionMatrix.elements[2] = clipPlane.x;
-        projectionMatrix.elements[6] = clipPlane.y;
-        projectionMatrix.elements[10] = clipPlane.z + 1.0 - clipBias;
-        projectionMatrix.elements[14] = clipPlane.w;
-
-        // Render
-
-        scope.visible = false;
-
-        const currentRenderTarget = renderer.getRenderTarget();
-
-        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
-
-        renderer.render(scene, virtualCamera, renderTarget, true);
-
-        renderer.vr.enabled = currentVrEnabled;
-        renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-
-        renderer.setRenderTarget(currentRenderTarget);
-
-        // Restore viewport
-
-        const bounds = camera.bounds;
-
-        if (bounds !== undefined) {
-
-            const size = renderer.getSize();
-            const pixelRatio = renderer.getPixelRatio();
-
-            viewport.x = bounds.x * size.width * pixelRatio;
-            viewport.y = bounds.y * size.height * pixelRatio;
-            viewport.z = bounds.z * size.width * pixelRatio;
-            viewport.w = bounds.w * size.height * pixelRatio;
-
-            renderer.state.viewport(viewport);
-
-        }
-
-        scope.visible = true;
-
-    };
-
-    this.getRenderTarget = function () {
-
-        return renderTarget;
-
-    };
-
-}
-
-Reflector.prototype = Object.create(Mesh.prototype);
-Reflector.prototype.constructor = Reflector;
-
-const ReflectorShader = {
-
-    uniforms: {
-
-        'color': {
-            type: 'c',
-            value: null
-        },
-
-        'tDiffuse': {
-            type: 't',
-            value: null
-        },
-
-        'textureMatrix': {
-            type: 'm4',
-            value: null
-        }
-
-    },
-
-    vertexShader: [
-        'uniform mat4 textureMatrix;',
-        'varying vec4 vUv;',
-
-        'void main() {',
-
-        '	vUv = textureMatrix * vec4( position, 1.0 );',
-
-        '	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
-
-        '}'
-    ].join('\n'),
-
-    fragmentShader: [
-        'uniform vec3 color;',
-        'uniform sampler2D tDiffuse;',
-        'varying vec4 vUv;',
-
-        'float blendOverlay( float base, float blend ) {',
-
-        '	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );',
-
-        '}',
-
-        'vec3 blendOverlay( vec3 base, vec3 blend ) {',
-
-        '	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );',
-
-        '}',
-
-        'void main() {',
-
-        '	vec4 base = texture2DProj( tDiffuse, vUv );',
-        '	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );',
-
-        '}'
-    ].join('\n')
-};
-
-
-export { Reflector };

package/src/engine/graphics/three/Refractor.d.ts

@@ -1,11 +0,0 @@
-export function Refractor(geometry: any, options: any): void;
-export class Refractor {
-    constructor(geometry: any, options: any);
-    type: string;
-    material: ShaderMaterial;
-    onBeforeRender: (renderer: any, scene: any, camera: any) => void;
-    getRenderTarget: () => WebGLRenderTarget;
-}
-import { ShaderMaterial } from 'three';
-import { WebGLRenderTarget } from 'three';
-//# sourceMappingURL=Refractor.d.ts.map

package/src/engine/graphics/three/Refractor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Refractor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/three/Refractor.js"],"names":[],"mappings":"AAsBA,6DAgQC;;IAhQD,yCAgQC;IA5PG,aAAuB;IA0CvB,yBAKE;IAiLF,iEAoBC;IAED,yCAIC;;+BAhQE,OAAO;kCAAP,OAAO"}