@woosh/meep-engine 2.106.1 → 2.107.0

package/src/engine/graphics/postprocess/threejs/shaders/SSAOShader.js

@@ -1,230 +0,0 @@
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * Screen-space ambient occlusion shader
- * - ported from
- *   SSAO GLSL shader v1.2
- *   assembled by Martins Upitis (martinsh) (http://devlog-martinsh.blogspot.com)
- *   original technique is made by ArKano22 (http://www.gamedev.net/topic/550699-ssao-no-halo-artifacts/)
- * - modifications
- * - modified to use RGBA packed depth texture (use clear color 1,1,1,1 for depth pass)
- * - refactoring and optimizations
- */
-import { Vector2 } from 'three';
-
-const SSAOShader = {
-
-    uniforms: {
-
-        "tDiffuse": { type: "t", value: null },
-        "tDepth": { type: "t", value: null },
-        "size": { type: "v2", value: new Vector2(512, 512) },
-        "cameraNear": { type: "f", value: 1 },
-        "cameraFar": { type: "f", value: 100 },
-        "onlyAO": { type: "i", value: 0 },
-        "aoClamp": { type: "f", value: 0.5 },
-        "lumInfluence": { type: "f", value: 0.5 },
-        "strength": { type: "f", value: 1.0 }
-
-    },
-
-    vertexShader: [
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vUv = uv;",
-
-        "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-        "}"
-
-    ].join("\n"),
-
-    fragmentShader: [
-
-        "uniform float cameraNear;",
-        "uniform float cameraFar;",
-
-        "uniform bool onlyAO;",      // use only ambient occlusion pass?
-
-        "uniform vec2 size;",        // texture width, height
-        "uniform float aoClamp;",    // depth clamp - reduces haloing at screen edges
-
-        "uniform float lumInfluence;",  // how much luminance affects occlusion
-        "uniform float strength;",
-
-        "uniform sampler2D tDiffuse;",
-        "uniform sampler2D tDepth;",
-
-        "varying vec2 vUv;",
-
-        // "#define PI 3.14159265",
-        "#define DL 2.399963229728653",  // PI * ( 3.0 - sqrt( 5.0 ) )
-        "#define EULER 2.718281828459045",
-
-        // user variables
-
-        "const int samples = 8;",     // ao sample count
-        "const float radius = 5.0;",  // ao radius
-
-        "const bool useNoise = false;",      // use noise instead of pattern for sample dithering
-        "const float noiseAmount = 0.0003;", // dithering amount
-
-        "const float diffArea = 0.4;",   // self-shadowing reduction
-        "const float gDisplace = 0.4;",  // gauss bell center
-
-
-        // RGBA depth
-
-        "float unpackDepth( const in vec4 rgba_depth ) {",
-
-        "const vec4 bit_shift = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );",
-        "float depth = dot( rgba_depth, bit_shift );",
-        "return depth;",
-
-        "}",
-
-        // generating noise / pattern texture for dithering
-
-        "vec2 rand( const vec2 coord ) {",
-
-        "vec2 noise;",
-
-        "if ( useNoise ) {",
-
-        "float nx = dot ( coord, vec2( 12.9898, 78.233 ) );",
-        "float ny = dot ( coord, vec2( 12.9898, 78.233 ) * 2.0 );",
-
-        "noise = clamp( fract ( 43758.5453 * sin( vec2( nx, ny ) ) ), 0.0, 1.0 );",
-
-        "} else {",
-
-        "float ff = fract( 1.0 - coord.s * ( size.x / 2.0 ) );",
-        "float gg = fract( coord.t * ( size.y / 2.0 ) );",
-
-        "noise = vec2( 0.25, 0.75 ) * vec2( ff ) + vec2( 0.75, 0.25 ) * gg;",
-
-        "}",
-
-        "return ( noise * 2.0  - 1.0 ) * noiseAmount;",
-
-        "}",
-
-        "float readDepth( const in vec2 coord ) {",
-
-        "float cameraFarPlusNear = cameraFar + cameraNear;",
-        "float cameraFarMinusNear = cameraFar - cameraNear;",
-        "float cameraCoef = 2.0 * cameraNear;",
-
-        // "return ( 2.0 * cameraNear ) / ( cameraFar + cameraNear - unpackDepth( texture2D( tDepth, coord ) ) * ( cameraFar - cameraNear ) );",
-        "return cameraCoef / ( cameraFarPlusNear - unpackDepth( texture2D( tDepth, coord ) ) * cameraFarMinusNear );",
-
-
-        "}",
-
-        "float compareDepths( const in float depth1, const in float depth2, inout int far ) {",
-
-        "float garea = 2.0;",                         // gauss bell width
-        "float diff = ( depth1 - depth2 ) * 100.0;",  // depth difference (0-100)
-
-        // reduce left bell width to avoid self-shadowing
-
-        "if ( diff < gDisplace ) {",
-
-        "garea = diffArea;",
-
-        "} else {",
-
-        "far = 1;",
-
-        "}",
-
-        "float dd = diff - gDisplace;",
-        "float gauss = pow( EULER, -2.0 * dd * dd / ( garea * garea ) );",
-        "return gauss;",
-
-        "}",
-
-        "float calcAO( float depth, float dw, float dh ) {",
-
-        "float dd = radius - depth * radius;",
-        "vec2 vv = vec2( dw, dh );",
-
-        "vec2 coord1 = vUv + dd * vv;",
-        "vec2 coord2 = vUv - dd * vv;",
-
-        "float temp1 = 0.0;",
-        "float temp2 = 0.0;",
-
-        "int far = 0;",
-        "temp1 = compareDepths( depth, readDepth( coord1 ), far );",
-
-        // DEPTH EXTRAPOLATION
-
-        "if ( far > 0 ) {",
-
-        "temp2 = compareDepths( readDepth( coord2 ), depth, far );",
-        "temp1 += ( 1.0 - temp1 ) * temp2;",
-
-        "}",
-
-        "return temp1;",
-
-        "}",
-
-        "void main() {",
-
-        "vec2 noise = rand( vUv );",
-        "float depth = readDepth( vUv );",
-
-        "float tt = clamp( depth, aoClamp, 1.0 );",
-
-        "float w = ( 1.0 / size.x )  / tt + ( noise.x * ( 1.0 - noise.x ) );",
-        "float h = ( 1.0 / size.y ) / tt + ( noise.y * ( 1.0 - noise.y ) );",
-
-        "float ao = 0.0;",
-
-        "float dz = 1.0 / float( samples );",
-        "float z = 1.0 - dz / 2.0;",
-        "float l = 0.0;",
-
-        "for ( int i = 0; i <= samples; i ++ ) {",
-
-        "float r = sqrt( 1.0 - z );",
-
-        "float pw = cos( l ) * r;",
-        "float ph = sin( l ) * r;",
-        "ao += calcAO( depth, pw * w, ph * h );",
-        "z = z - dz;",
-        "l = l + DL;",
-
-        "}",
-
-        "ao /= float( samples );",
-        "ao = 1.0 - ao*strength;",
-
-        "vec3 color = texture2D( tDiffuse, vUv ).rgb;",
-
-        "vec3 lumcoeff = vec3( 0.299, 0.587, 0.114 );",
-        "float lum = dot( color.rgb, lumcoeff );",
-        "vec3 luminance = vec3( lum );",
-
-        "vec3 final = vec3( color * mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );",  // mix( color * ao, white, luminance )
-
-        "if ( onlyAO ) {",
-
-        "final = vec3( mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );",  // ambient occlusion only
-
-        "}",
-
-        "gl_FragColor = vec4( final, 1.0 );",
-
-        "}"
-
-    ].join("\n")
-
-};
-
-export default SSAOShader;

package/src/engine/graphics/postprocess/threejs/shaders/ToneMapShader.d.ts

@@ -1,36 +0,0 @@
-export default ToneMapShader;
-declare namespace ToneMapShader {
-    namespace uniforms {
-        namespace tDiffuse {
-            let type: string;
-            let value: any;
-        }
-        namespace averageLuminance {
-            let type_1: string;
-            export { type_1 as type };
-            let value_1: number;
-            export { value_1 as value };
-        }
-        namespace luminanceMap {
-            let type_2: string;
-            export { type_2 as type };
-            let value_2: any;
-            export { value_2 as value };
-        }
-        namespace maxLuminance {
-            let type_3: string;
-            export { type_3 as type };
-            let value_3: number;
-            export { value_3 as value };
-        }
-        namespace middleGrey {
-            let type_4: string;
-            export { type_4 as type };
-            let value_4: number;
-            export { value_4 as value };
-        }
-    }
-    let vertexShader: string;
-    let fragmentShader: string;
-}
-//# sourceMappingURL=ToneMapShader.d.ts.map

package/src/engine/graphics/postprocess/threejs/shaders/ToneMapShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToneMapShader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/postprocess/threejs/shaders/ToneMapShader.js"],"names":[],"mappings":""}

package/src/engine/graphics/postprocess/threejs/shaders/ToneMapShader.js

@@ -1,76 +0,0 @@
-/**
- * @author miibond
- *
- * Full-screen tone-mapping shader based on http://www.graphics.cornell.edu/~jaf/publications/sig02_paper.pdf
- */
-const ToneMapShader = {
-
-    uniforms: {
-
-        "tDiffuse": { type: "t", value: null },
-        "averageLuminance": { type: "f", value: 1.0 },
-        "luminanceMap": { type: "t", value: null },
-        "maxLuminance": { type: "f", value: 16.0 },
-        "middleGrey": { type: "f", value: 0.6 }
-    },
-
-    vertexShader: [
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vUv = uv;",
-        "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-        "}"
-
-    ].join("\n"),
-
-    fragmentShader: [
-
-        "uniform sampler2D tDiffuse;",
-
-        "varying vec2 vUv;",
-
-        "uniform float middleGrey;",
-        "uniform float maxLuminance;",
-        "#ifdef ADAPTED_LUMINANCE",
-        "uniform sampler2D luminanceMap;",
-        "#else",
-        "uniform float averageLuminance;",
-        "#endif",
-
-        "const vec3 LUM_CONVERT = vec3(0.299, 0.587, 0.114);",
-
-        "vec3 ToneMap( vec3 vColor ) {",
-        "#ifdef ADAPTED_LUMINANCE",
-        // Get the calculated average luminance
-        "float fLumAvg = texture2D(luminanceMap, vec2(0.5, 0.5)).r;",
-        "#else",
-        "float fLumAvg = averageLuminance;",
-        "#endif",
-
-        // Calculate the luminance of the current pixel
-        "float fLumPixel = dot(vColor, LUM_CONVERT);",
-
-        // Apply the modified operator (Eq. 4)
-        "float fLumScaled = (fLumPixel * middleGrey) / fLumAvg;",
-
-        "float fLumCompressed = (fLumScaled * (1.0 + (fLumScaled / (maxLuminance * maxLuminance)))) / (1.0 + fLumScaled);",
-        "return fLumCompressed * vColor;",
-        "}",
-
-        "void main() {",
-
-        "vec4 texel = texture2D( tDiffuse, vUv );",
-
-        "gl_FragColor = vec4( ToneMap( texel.xyz ), texel.w );",
-
-        "}"
-
-    ].join("\n")
-
-};
-
-export default ToneMapShader;

package/src/engine/graphics/shaders/GaussianBlurShader.d.ts

@@ -1,22 +0,0 @@
-export default GaussianBlurShader;
-declare function GaussianBlurShader(): {
-    defines: {};
-    uniforms: {
-        tDiffuse: {
-            type: string;
-            value: any;
-        };
-        resolution: {
-            type: string;
-            value: Vector2;
-        };
-        sigma: {
-            type: string;
-            value: Vector2;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-import { Vector2 } from "three";
-//# sourceMappingURL=GaussianBlurShader.d.ts.map

package/src/engine/graphics/shaders/GaussianBlurShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GaussianBlurShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/GaussianBlurShader.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;EAuEC;wBAzEuB,OAAO"}

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

@@ -1,79 +0,0 @@
-/**
- * Created by Alex on 20/09/2015.
- */
-import { Vector2 } from "three";
-
-function GaussianBlurShader() {
-
-    return {
-
-        defines: {},
-
-        uniforms: {
-
-            "tDiffuse": { type: "t", value: null },
-            "resolution": { type: "v2", value: new Vector2(800, 600) },
-            "sigma": { type: "v2", value: new Vector2(10, 10) }
-        },
-
-        vertexShader: [
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "vUv = uv;",
-            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-            "}"
-
-        ].join("\n"),
-        fragmentShader: [
-            "const int   c_samplesX    = 15;",  // must be odd
-            "const int   c_samplesY    = 15;",  // 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() {",
-
-            "   gl_FragColor = BlurredPixel(vUv);",
-            "   if(gl_FragColor.a < 0.01){ ",
-            "       discard;",
-            "   }",
-
-            "}"
-
-
-        ].join("\n")
-    };
-}
-
-export default GaussianBlurShader;

package/src/engine/graphics/shaders/GaussianGlowShader.d.ts

@@ -1,26 +0,0 @@
-export default GaussianGlowShader;
-declare namespace GaussianGlowShader {
-    let defines: {};
-    namespace uniforms {
-        namespace tDiffuse {
-            let type: string;
-            let value: any;
-        }
-        namespace resolution {
-            let type_1: string;
-            export { type_1 as type };
-            let value_1: Vector2;
-            export { value_1 as value };
-        }
-        namespace sigma {
-            let type_2: string;
-            export { type_2 as type };
-            let value_2: Vector2;
-            export { value_2 as value };
-        }
-    }
-    let vertexShader: string;
-    let fragmentShader: string;
-}
-import { Vector2 } from 'three';
-//# sourceMappingURL=GaussianGlowShader.d.ts.map

package/src/engine/graphics/shaders/GaussianGlowShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GaussianGlowShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/GaussianGlowShader.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBAGwB,OAAO"}

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

@@ -1,83 +0,0 @@
-/**
- * Created by Alex on 20/09/2015.
- */
-import { Vector2 } from 'three';
-
-const GaussianGlowShader = {
-
-    defines: {},
-
-    uniforms: {
-
-        "tDiffuse": { type: "t", value: null },
-        "resolution": { type: "v2", value: new Vector2(800, 600) },
-        "sigma": { type: "v2", value: new Vector2(15, 15) }
-    },
-
-    vertexShader: [
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vUv = uv;",
-        "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-        "}"
-
-    ].join("\n"),
-    fragmentShader: [
-        "const int   c_samplesX    = 5;",  // must be odd
-        "const int   c_samplesY    = 5;",  // must be odd
-
-        "const int   c_halfSamplesX = c_samplesX / 2;",
-        "const int   c_halfSamplesY = c_samplesY / 2;",
-
-        "const float radius = 6.0;",
-        "const vec2 samplingBias = vec2(float(c_halfSamplesX),float(c_halfSamplesY))/radius;",
-
-        "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);",
-        "    vec2 sampleResolution = resolution*samplingBias;",
-
-        "    for (int iy = 0; iy < c_samplesY; ++iy){",
-        "        float fy = Gaussian (sigma.y, float(iy) - float(c_halfSamplesY));",
-        "        float offsety = float(iy-c_halfSamplesY) / sampleResolution.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) / sampleResolution.x;",
-        "            total += fx * fy;",
-        "            ret += texture2D(tDiffuse, uv + vec2(offsetx, offsety)) * fx*fy;",
-        "        }",
-        "    }",
-        "    return ret*1.7 / 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/shaders/NormalMapShader.d.ts

@@ -1,33 +0,0 @@
-export default NormalMapShader;
-/**
- * Created by Alex on 09/11/2014.
- */
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * Normal map shader
- * - compute normals from heightmap
- */
-declare function NormalMapShader(): {
-    uniforms: {
-        heightMap: {
-            type: string;
-            value: any;
-        };
-        resolution: {
-            type: string;
-            value: import("three").Vector2;
-        };
-        scale: {
-            type: string;
-            value: import("three").Vector2;
-        };
-        height: {
-            type: string;
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-//# sourceMappingURL=NormalMapShader.d.ts.map

package/src/engine/graphics/shaders/NormalMapShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NormalMapShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/NormalMapShader.js"],"names":[],"mappings":";AAAA;;GAEG;AACH;;;;;GAKG;AAIH;;;;;;;;;;;;;;;;;;;;;EA+CC"}

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

@@ -1,62 +0,0 @@
-/**
- * Created by Alex on 09/11/2014.
- */
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * Normal map shader
- * - compute normals from heightmap
- */
-
-
-
-const NormalMapShader = function () {
-    return {
-
-        uniforms: {
-
-            "heightMap": { type: "t", value: null },
-            "resolution": { type: "v2", value: new THREE.Vector2(512, 512) },
-            "scale": { type: "v2", value: new THREE.Vector2(1, 1) },
-            "height": { type: "f", value: 0.05 }
-
-        },
-
-        vertexShader: [
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "vUv = uv;",
-            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-            "}"
-
-        ].join("\n"),
-
-        fragmentShader: [
-
-            "uniform float height;",
-            "uniform vec2 resolution;",
-            "uniform sampler2D heightMap;",
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "float val = texture2D( heightMap, vUv ).x;",
-
-            "float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;",
-            "float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;",
-
-            "gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );",
-
-            "}"
-
-        ].join("\n")
-
-    }
-};
-export default NormalMapShader;
-

package/src/engine/graphics/shaders/SoftOutlineShader.d.ts

@@ -1,3 +0,0 @@
-declare const GaussianGlowShader: any;
-export default GaussianGlowShader;
-//# sourceMappingURL=SoftOutlineShader.d.ts.map

package/src/engine/graphics/shaders/SoftOutlineShader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SoftOutlineShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/SoftOutlineShader.js"],"names":[],"mappings":""}