three-stdlib 2.22.7 → 2.22.8

package/dist/shaders/ParallaxShader.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ParallaxShader = {
+  // Ordered from fastest to best quality.
+  modes: {
+    none: "NO_PARALLAX",
+    basic: "USE_BASIC_PARALLAX",
+    steep: "USE_STEEP_PARALLAX",
+    occlusion: "USE_OCLUSION_PARALLAX",
+    // a.k.a. POM
+    relief: "USE_RELIEF_PARALLAX"
+  },
+  uniforms: {
+    bumpMap: { value: null },
+    map: { value: null },
+    parallaxScale: { value: null },
+    parallaxMinLayers: { value: null },
+    parallaxMaxLayers: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "void main() {",
+    "	vUv = uv;",
+    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+    "	vViewPosition = -mvPosition.xyz;",
+    "	vNormal = normalize( normalMatrix * normal );",
+    "	gl_Position = projectionMatrix * mvPosition;",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D bumpMap;",
+    "uniform sampler2D map;",
+    "uniform float parallaxScale;",
+    "uniform float parallaxMinLayers;",
+    "uniform float parallaxMaxLayers;",
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "#ifdef USE_BASIC_PARALLAX",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    "		float initialHeight = texture2D( bumpMap, vUv ).r;",
+    // No Offset Limitting: messy, floating output at grazing angles.
+    //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
+    // Offset Limiting
+    "		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;",
+    "		return vUv - texCoordOffset;",
+    "	}",
+    "#else",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    // Determine number of layers from angle between V and N
+    "		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );",
+    "		float layerHeight = 1.0 / numLayers;",
+    "		float currentLayerHeight = 0.0;",
+    // Shift of texture coordinates for each iteration
+    "		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;",
+    "		vec2 currentTextureCoords = vUv;",
+    "		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    // while ( heightFromTexture > currentLayerHeight )
+    // Infinite loops are not well supported. Do a "large" finite
+    // loop, but not too large, as it slows down some compilers.
+    "		for ( int i = 0; i < 30; i += 1 ) {",
+    "			if ( heightFromTexture <= currentLayerHeight ) {",
+    "				break;",
+    "			}",
+    "			currentLayerHeight += layerHeight;",
+    // Shift texture coordinates along vector V
+    "			currentTextureCoords -= dtex;",
+    "			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "		}",
+    "		#ifdef USE_STEEP_PARALLAX",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_RELIEF_PARALLAX )",
+    "			vec2 deltaTexCoord = dtex / 2.0;",
+    "			float deltaHeight = layerHeight / 2.0;",
+    // Return to the mid point of previous layer
+    "			currentTextureCoords += deltaTexCoord;",
+    "			currentLayerHeight -= deltaHeight;",
+    // Binary search to increase precision of Steep Parallax Mapping
+    "			const int numSearches = 5;",
+    "			for ( int i = 0; i < numSearches; i += 1 ) {",
+    "				deltaTexCoord /= 2.0;",
+    "				deltaHeight /= 2.0;",
+    "				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    // Shift along or against vector V
+    "				if( heightFromTexture > currentLayerHeight ) {",
+    // Below the surface
+    "					currentTextureCoords -= deltaTexCoord;",
+    "					currentLayerHeight += deltaHeight;",
+    "				} else {",
+    // above the surface
+    "					currentTextureCoords += deltaTexCoord;",
+    "					currentLayerHeight -= deltaHeight;",
+    "				}",
+    "			}",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_OCLUSION_PARALLAX )",
+    "			vec2 prevTCoords = currentTextureCoords + dtex;",
+    // Heights for linear interpolation
+    "			float nextH = heightFromTexture - currentLayerHeight;",
+    "			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;",
+    // Proportions for linear interpolation
+    "			float weight = nextH / ( nextH - prevH );",
+    // Interpolation of texture coordinates
+    "			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );",
+    "		#else",
+    // NO_PARALLAX
+    "			return vUv;",
+    "		#endif",
+    "	}",
+    "#endif",
+    "vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {",
+    "	vec2 texDx = dFdx( vUv );",
+    "	vec2 texDy = dFdy( vUv );",
+    "	vec3 vSigmaX = dFdx( surfPosition );",
+    "	vec3 vSigmaY = dFdy( surfPosition );",
+    "	vec3 vR1 = cross( vSigmaY, surfNormal );",
+    "	vec3 vR2 = cross( surfNormal, vSigmaX );",
+    "	float fDet = dot( vSigmaX, vR1 );",
+    "	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );",
+    "	vec3 vProjVtex;",
+    "	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;",
+    "	vProjVtex.z = dot( surfNormal, viewPosition );",
+    "	return parallaxMap( vProjVtex );",
+    "}",
+    "void main() {",
+    "	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );",
+    "	gl_FragColor = texture2D( map, mapUv );",
+    "}"
+  ].join("\n")
+};
+exports.ParallaxShader = ParallaxShader;

package/dist/shaders/ParallaxShader.mjs

@@ -0,0 +1,133 @@
+const ParallaxShader = {
+  // Ordered from fastest to best quality.
+  modes: {
+    none: "NO_PARALLAX",
+    basic: "USE_BASIC_PARALLAX",
+    steep: "USE_STEEP_PARALLAX",
+    occlusion: "USE_OCLUSION_PARALLAX",
+    // a.k.a. POM
+    relief: "USE_RELIEF_PARALLAX"
+  },
+  uniforms: {
+    bumpMap: { value: null },
+    map: { value: null },
+    parallaxScale: { value: null },
+    parallaxMinLayers: { value: null },
+    parallaxMaxLayers: { value: null }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "void main() {",
+    "	vUv = uv;",
+    "	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+    "	vViewPosition = -mvPosition.xyz;",
+    "	vNormal = normalize( normalMatrix * normal );",
+    "	gl_Position = projectionMatrix * mvPosition;",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D bumpMap;",
+    "uniform sampler2D map;",
+    "uniform float parallaxScale;",
+    "uniform float parallaxMinLayers;",
+    "uniform float parallaxMaxLayers;",
+    "varying vec2 vUv;",
+    "varying vec3 vViewPosition;",
+    "varying vec3 vNormal;",
+    "#ifdef USE_BASIC_PARALLAX",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    "		float initialHeight = texture2D( bumpMap, vUv ).r;",
+    // No Offset Limitting: messy, floating output at grazing angles.
+    //"vec2 texCoordOffset = parallaxScale * V.xy / V.z * initialHeight;",
+    // Offset Limiting
+    "		vec2 texCoordOffset = parallaxScale * V.xy * initialHeight;",
+    "		return vUv - texCoordOffset;",
+    "	}",
+    "#else",
+    "	vec2 parallaxMap( in vec3 V ) {",
+    // Determine number of layers from angle between V and N
+    "		float numLayers = mix( parallaxMaxLayers, parallaxMinLayers, abs( dot( vec3( 0.0, 0.0, 1.0 ), V ) ) );",
+    "		float layerHeight = 1.0 / numLayers;",
+    "		float currentLayerHeight = 0.0;",
+    // Shift of texture coordinates for each iteration
+    "		vec2 dtex = parallaxScale * V.xy / V.z / numLayers;",
+    "		vec2 currentTextureCoords = vUv;",
+    "		float heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    // while ( heightFromTexture > currentLayerHeight )
+    // Infinite loops are not well supported. Do a "large" finite
+    // loop, but not too large, as it slows down some compilers.
+    "		for ( int i = 0; i < 30; i += 1 ) {",
+    "			if ( heightFromTexture <= currentLayerHeight ) {",
+    "				break;",
+    "			}",
+    "			currentLayerHeight += layerHeight;",
+    // Shift texture coordinates along vector V
+    "			currentTextureCoords -= dtex;",
+    "			heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    "		}",
+    "		#ifdef USE_STEEP_PARALLAX",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_RELIEF_PARALLAX )",
+    "			vec2 deltaTexCoord = dtex / 2.0;",
+    "			float deltaHeight = layerHeight / 2.0;",
+    // Return to the mid point of previous layer
+    "			currentTextureCoords += deltaTexCoord;",
+    "			currentLayerHeight -= deltaHeight;",
+    // Binary search to increase precision of Steep Parallax Mapping
+    "			const int numSearches = 5;",
+    "			for ( int i = 0; i < numSearches; i += 1 ) {",
+    "				deltaTexCoord /= 2.0;",
+    "				deltaHeight /= 2.0;",
+    "				heightFromTexture = texture2D( bumpMap, currentTextureCoords ).r;",
+    // Shift along or against vector V
+    "				if( heightFromTexture > currentLayerHeight ) {",
+    // Below the surface
+    "					currentTextureCoords -= deltaTexCoord;",
+    "					currentLayerHeight += deltaHeight;",
+    "				} else {",
+    // above the surface
+    "					currentTextureCoords += deltaTexCoord;",
+    "					currentLayerHeight -= deltaHeight;",
+    "				}",
+    "			}",
+    "			return currentTextureCoords;",
+    "		#elif defined( USE_OCLUSION_PARALLAX )",
+    "			vec2 prevTCoords = currentTextureCoords + dtex;",
+    // Heights for linear interpolation
+    "			float nextH = heightFromTexture - currentLayerHeight;",
+    "			float prevH = texture2D( bumpMap, prevTCoords ).r - currentLayerHeight + layerHeight;",
+    // Proportions for linear interpolation
+    "			float weight = nextH / ( nextH - prevH );",
+    // Interpolation of texture coordinates
+    "			return prevTCoords * weight + currentTextureCoords * ( 1.0 - weight );",
+    "		#else",
+    // NO_PARALLAX
+    "			return vUv;",
+    "		#endif",
+    "	}",
+    "#endif",
+    "vec2 perturbUv( vec3 surfPosition, vec3 surfNormal, vec3 viewPosition ) {",
+    "	vec2 texDx = dFdx( vUv );",
+    "	vec2 texDy = dFdy( vUv );",
+    "	vec3 vSigmaX = dFdx( surfPosition );",
+    "	vec3 vSigmaY = dFdy( surfPosition );",
+    "	vec3 vR1 = cross( vSigmaY, surfNormal );",
+    "	vec3 vR2 = cross( surfNormal, vSigmaX );",
+    "	float fDet = dot( vSigmaX, vR1 );",
+    "	vec2 vProjVscr = ( 1.0 / fDet ) * vec2( dot( vR1, viewPosition ), dot( vR2, viewPosition ) );",
+    "	vec3 vProjVtex;",
+    "	vProjVtex.xy = texDx * vProjVscr.x + texDy * vProjVscr.y;",
+    "	vProjVtex.z = dot( surfNormal, viewPosition );",
+    "	return parallaxMap( vProjVtex );",
+    "}",
+    "void main() {",
+    "	vec2 mapUv = perturbUv( -vViewPosition, normalize( vNormal ), normalize( vViewPosition ) );",
+    "	gl_FragColor = texture2D( map, mapUv );",
+    "}"
+  ].join("\n")
+};
+export {
+  ParallaxShader
+};

package/dist/shaders/PixelShader.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pixelation shader
+ */
+export declare const PixelShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        resolution: {
+            value: null;
+        };
+        pixelSize: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/PixelShader.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const PixelShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    resolution: { value: null },
+    pixelSize: { value: 1 }
+  },
+  vertexShader: [
+    "varying highp vec2 vUv;",
+    "void main() {",
+    "vUv = uv;",
+    "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float pixelSize;",
+    "uniform vec2 resolution;",
+    "varying highp vec2 vUv;",
+    "void main(){",
+    "vec2 dxy = pixelSize / resolution;",
+    "vec2 coord = dxy * floor( vUv / dxy );",
+    "gl_FragColor = texture2D(tDiffuse, coord);",
+    "}"
+  ].join("\n")
+};
+exports.PixelShader = PixelShader;

package/dist/shaders/PixelShader.mjs

@@ -0,0 +1,28 @@
+const PixelShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    resolution: { value: null },
+    pixelSize: { value: 1 }
+  },
+  vertexShader: [
+    "varying highp vec2 vUv;",
+    "void main() {",
+    "vUv = uv;",
+    "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float pixelSize;",
+    "uniform vec2 resolution;",
+    "varying highp vec2 vUv;",
+    "void main(){",
+    "vec2 dxy = pixelSize / resolution;",
+    "vec2 coord = dxy * floor( vUv / dxy );",
+    "gl_FragColor = texture2D(tDiffuse, coord);",
+    "}"
+  ].join("\n")
+};
+export {
+  PixelShader
+};

package/dist/shaders/RGBShiftShader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * RGB Shift Shader
+ * Shifts red and blue channels from center in opposite directions
+ * Ported from http://kriss.cx/tom/2009/05/rgb-shift/
+ * by Tom Butterworth / http://kriss.cx/tom/
+ *
+ * amount: shift distance (1 is width of input)
+ * angle: shift angle in radians
+ */
+export declare const RGBShiftShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        amount: {
+            value: number;
+        };
+        angle: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/dist/shaders/RGBShiftShader.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const RGBShiftShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    amount: { value: 5e-3 },
+    angle: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float amount;",
+    "uniform float angle;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 offset = amount * vec2( cos(angle), sin(angle));",
+    "	vec4 cr = texture2D(tDiffuse, vUv + offset);",
+    "	vec4 cga = texture2D(tDiffuse, vUv);",
+    "	vec4 cb = texture2D(tDiffuse, vUv - offset);",
+    "	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
+    "}"
+  ].join("\n")
+};
+exports.RGBShiftShader = RGBShiftShader;

package/dist/shaders/RGBShiftShader.mjs

@@ -0,0 +1,30 @@
+const RGBShiftShader = {
+  uniforms: {
+    tDiffuse: { value: null },
+    amount: { value: 5e-3 },
+    angle: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "uniform sampler2D tDiffuse;",
+    "uniform float amount;",
+    "uniform float angle;",
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vec2 offset = amount * vec2( cos(angle), sin(angle));",
+    "	vec4 cr = texture2D(tDiffuse, vUv + offset);",
+    "	vec4 cga = texture2D(tDiffuse, vUv);",
+    "	vec4 cb = texture2D(tDiffuse, vUv - offset);",
+    "	gl_FragColor = vec4(cr.r, cga.g, cb.b, cga.a);",
+    "}"
+  ].join("\n")
+};
+export {
+  RGBShiftShader
+};

package/dist/shaders/SAOShader.d.ts

@@ -0,0 +1,25 @@
+import { Matrix4, Vector2 } from 'three';
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types';
+export declare type SAOShaderDefines = Record<'DEPTH_PACKING' | 'DIFFUSE_TEXTURE' | 'NORMAL_TEXTURE' | 'NUM_RINGS' | 'NUM_SAMPLES' | 'PERSPECTIVE_CAMERA', number>;
+export declare type SAOShaderUniforms = {
+    bias: IUniform<number>;
+    cameraFar: IUniform<number>;
+    cameraInverseProjectionMatrix: IUniform<Matrix4>;
+    cameraNear: IUniform<number>;
+    cameraProjectionMatrix: IUniform<Matrix4>;
+    intensity: IUniform<number>;
+    kernelRadius: IUniform<number>;
+    minResolution: IUniform<number>;
+    randomSeed: IUniform<number>;
+    scale: IUniform<number>;
+    size: IUniform<Vector2>;
+    tDepth: IUniform<Texture | null>;
+    tDiffuse: IUniform<Texture | null>;
+    tNormal: IUniform<Texture | null>;
+};
+export interface ISAOShader extends IShader<SAOShaderUniforms, SAOShaderDefines> {
+    defines: SAOShaderDefines;
+    needsUpdate?: boolean;
+}
+export declare const SAOShader: ISAOShader;

package/dist/shaders/SAOShader.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const SAOShader = {
+  defines: {
+    NUM_SAMPLES: 7,
+    NUM_RINGS: 4,
+    NORMAL_TEXTURE: 0,
+    DIFFUSE_TEXTURE: 0,
+    DEPTH_PACKING: 1,
+    PERSPECTIVE_CAMERA: 1
+  },
+  uniforms: {
+    tDepth: { value: null },
+    tDiffuse: { value: null },
+    tNormal: { value: null },
+    size: { value: new THREE.Vector2(512, 512) },
+    cameraNear: { value: 1 },
+    cameraFar: { value: 100 },
+    cameraProjectionMatrix: { value: new THREE.Matrix4() },
+    cameraInverseProjectionMatrix: { value: new THREE.Matrix4() },
+    scale: { value: 1 },
+    intensity: { value: 0.1 },
+    bias: { value: 0.5 },
+    minResolution: { value: 0 },
+    kernelRadius: { value: 100 },
+    randomSeed: { value: 0 }
+  },
+  vertexShader: [
+    "varying vec2 vUv;",
+    "void main() {",
+    "	vUv = uv;",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+    "}"
+  ].join("\n"),
+  fragmentShader: [
+    "#include <common>",
+    "varying vec2 vUv;",
+    "#if DIFFUSE_TEXTURE == 1",
+    "uniform sampler2D tDiffuse;",
+    "#endif",
+    "uniform sampler2D tDepth;",
+    "#if NORMAL_TEXTURE == 1",
+    "uniform sampler2D tNormal;",
+    "#endif",
+    "uniform float cameraNear;",
+    "uniform float cameraFar;",
+    "uniform mat4 cameraProjectionMatrix;",
+    "uniform mat4 cameraInverseProjectionMatrix;",
+    "uniform float scale;",
+    "uniform float intensity;",
+    "uniform float bias;",
+    "uniform float kernelRadius;",
+    "uniform float minResolution;",
+    "uniform vec2 size;",
+    "uniform float randomSeed;",
+    "// RGBA depth",
+    "#include <packing>",
+    "vec4 getDefaultColor( const in vec2 screenPosition ) {",
+    "	#if DIFFUSE_TEXTURE == 1",
+    "	return texture2D( tDiffuse, vUv );",
+    "	#else",
+    "	return vec4( 1.0 );",
+    "	#endif",
+    "}",
+    "float getDepth( const in vec2 screenPosition ) {",
+    "	#if DEPTH_PACKING == 1",
+    "	return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );",
+    "	#else",
+    "	return texture2D( tDepth, screenPosition ).x;",
+    "	#endif",
+    "}",
+    "float getViewZ( const in float depth ) {",
+    "	#if PERSPECTIVE_CAMERA == 1",
+    "	return perspectiveDepthToViewZ( depth, cameraNear, cameraFar );",
+    "	#else",
+    "	return orthographicDepthToViewZ( depth, cameraNear, cameraFar );",
+    "	#endif",
+    "}",
+    "vec3 getViewPosition( const in vec2 screenPosition, const in float depth, const in float viewZ ) {",
+    "	float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];",
+    "	vec4 clipPosition = vec4( ( vec3( screenPosition, depth ) - 0.5 ) * 2.0, 1.0 );",
+    "	clipPosition *= clipW; // unprojection.",
+    "	return ( cameraInverseProjectionMatrix * clipPosition ).xyz;",
+    "}",
+    "vec3 getViewNormal( const in vec3 viewPosition, const in vec2 screenPosition ) {",
+    "	#if NORMAL_TEXTURE == 1",
+    "	return unpackRGBToNormal( texture2D( tNormal, screenPosition ).xyz );",
+    "	#else",
+    "	return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );",
+    "	#endif",
+    "}",
+    "float scaleDividedByCameraFar;",
+    "float minResolutionMultipliedByCameraFar;",
+    "float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {",
+    "	vec3 viewDelta = sampleViewPosition - centerViewPosition;",
+    "	float viewDistance = length( viewDelta );",
+    "	float scaledScreenDistance = scaleDividedByCameraFar * viewDistance;",
+    "	return max(0.0, (dot(centerViewNormal, viewDelta) - minResolutionMultipliedByCameraFar) / scaledScreenDistance - bias) / (1.0 + pow2( scaledScreenDistance ) );",
+    "}",
+    "// moving costly divides into consts",
+    "const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );",
+    "const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );",
+    "float getAmbientOcclusion( const in vec3 centerViewPosition ) {",
+    "	// precompute some variables require in getOcclusion.",
+    "	scaleDividedByCameraFar = scale / cameraFar;",
+    "	minResolutionMultipliedByCameraFar = minResolution * cameraFar;",
+    "	vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );",
+    "	// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/",
+    "	float angle = rand( vUv + randomSeed ) * PI2;",
+    "	vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;",
+    "	vec2 radiusStep = radius;",
+    "	float occlusionSum = 0.0;",
+    "	float weightSum = 0.0;",
+    "	for( int i = 0; i < NUM_SAMPLES; i ++ ) {",
+    "		vec2 sampleUv = vUv + vec2( cos( angle ), sin( angle ) ) * radius;",
+    "		radius += radiusStep;",
+    "		angle += ANGLE_STEP;",
+    "		float sampleDepth = getDepth( sampleUv );",
+    "		if( sampleDepth >= ( 1.0 - EPSILON ) ) {",
+    "			continue;",
+    "		}",
+    "		float sampleViewZ = getViewZ( sampleDepth );",
+    "		vec3 sampleViewPosition = getViewPosition( sampleUv, sampleDepth, sampleViewZ );",
+    "		occlusionSum += getOcclusion( centerViewPosition, centerViewNormal, sampleViewPosition );",
+    "		weightSum += 1.0;",
+    "	}",
+    "	if( weightSum == 0.0 ) discard;",
+    "	return occlusionSum * ( intensity / weightSum );",
+    "}",
+    "void main() {",
+    "	float centerDepth = getDepth( vUv );",
+    "	if( centerDepth >= ( 1.0 - EPSILON ) ) {",
+    "		discard;",
+    "	}",
+    "	float centerViewZ = getViewZ( centerDepth );",
+    "	vec3 viewPosition = getViewPosition( vUv, centerDepth, centerViewZ );",
+    "	float ambientOcclusion = getAmbientOcclusion( viewPosition );",
+    "	gl_FragColor = getDefaultColor( vUv );",
+    "	gl_FragColor.xyz *=  1.0 - ambientOcclusion;",
+    "}"
+  ].join("\n")
+};
+exports.SAOShader = SAOShader;