three-stdlib 2.24.2 → 2.25.1

package/shaders/ParallaxShader.js

@@ -1,133 +0,0 @@
-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/shaders/PixelShader.cjs

@@ -1,28 +0,0 @@
-"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/shaders/PixelShader.js

@@ -1,28 +0,0 @@
-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/shaders/RGBShiftShader.cjs

@@ -1,30 +0,0 @@
-"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/shaders/RGBShiftShader.js

@@ -1,30 +0,0 @@
-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/shaders/SAOShader.cjs

@@ -1,144 +0,0 @@
-"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: /* @__PURE__ */ new THREE.Vector2(512, 512) },
-    cameraNear: { value: 1 },
-    cameraFar: { value: 100 },
-    cameraProjectionMatrix: { value: /* @__PURE__ */ new THREE.Matrix4() },
-    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ 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;

package/shaders/SAOShader.js

@@ -1,144 +0,0 @@
-import { Vector2, Matrix4 } from "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: /* @__PURE__ */ new Vector2(512, 512) },
-    cameraNear: { value: 1 },
-    cameraFar: { value: 100 },
-    cameraProjectionMatrix: { value: /* @__PURE__ */ new Matrix4() },
-    cameraInverseProjectionMatrix: { value: /* @__PURE__ */ new 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")
-};
-export {
-  SAOShader
-};