/** * @author alteredq / http://alteredqualia.com/ * @author mr.doob / http://mrdoob.com/ * * ShaderUtils currently contains * fresnel * normal * cube * convolution * film * screen * basic */ if ( THREE.WebGLRenderer ) { THREE.ShaderUtils = { lib: { /* ------------------------------------------------------------------------- // Fresnel shader // - based on Nvidia Cg tutorial ------------------------------------------------------------------------- */ 'fresnel': { uniforms: { "mRefractionRatio": { type: "f", value: 1.02 }, "mFresnelBias": { type: "f", value: 0.1 }, "mFresnelPower": { type: "f", value: 2.0 }, "mFresnelScale": { type: "f", value: 1.0 }, "tCube": { type: "t", value: 1, texture: null } }, fragmentShader: [ "uniform samplerCube tCube;", "varying vec3 vReflect;", "varying vec3 vRefract[3];", "varying float vReflectionFactor;", "void main() {", "vec4 reflectedColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );", "vec4 refractedColor = vec4( 1.0, 1.0, 1.0, 1.0 );", "refractedColor.r = textureCube( tCube, vec3( -vRefract[0].x, vRefract[0].yz ) ).r;", "refractedColor.g = textureCube( tCube, vec3( -vRefract[1].x, vRefract[1].yz ) ).g;", "refractedColor.b = textureCube( tCube, vec3( -vRefract[2].x, vRefract[2].yz ) ).b;", "refractedColor.a = 1.0;", "gl_FragColor = mix( refractedColor, reflectedColor, clamp( vReflectionFactor, 0.0, 1.0 ) );", "}" ].join("\n"), vertexShader: [ "uniform float mRefractionRatio;", "uniform float mFresnelBias;", "uniform float mFresnelScale;", "uniform float mFresnelPower;", "varying vec3 vReflect;", "varying vec3 vRefract[3];", "varying float vReflectionFactor;", "void main() {", "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", "vec4 mPosition = objectMatrix * vec4( position, 1.0 );", "vec3 nWorld = normalize ( mat3( objectMatrix[0].xyz, objectMatrix[1].xyz, objectMatrix[2].xyz ) * normal );", "vec3 I = mPosition.xyz - cameraPosition;", "vReflect = reflect( I, nWorld );", "vRefract[0] = refract( normalize( I ), nWorld, mRefractionRatio );", "vRefract[1] = refract( normalize( I ), nWorld, mRefractionRatio * 0.99 );", "vRefract[2] = refract( normalize( I ), nWorld, mRefractionRatio * 0.98 );", "vReflectionFactor = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( I ), nWorld ), mFresnelPower );", "gl_Position = projectionMatrix * mvPosition;", "}" ].join("\n") }, /* ------------------------------------------------------------------------- // Normal map shader // - Blinn-Phong // - normal + diffuse + specular + AO + displacement maps // - point and directional lights (use with "lights: true" material option) ------------------------------------------------------------------------- */ 'normal' : { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "fog" ], THREE.UniformsLib[ "lights" ], { "enableAO" : { type: "i", value: 0 }, "enableDiffuse" : { type: "i", value: 0 }, "enableSpecular": { type: "i", value: 0 }, "tDiffuse" : { type: "t", value: 0, texture: null }, "tNormal" : { type: "t", value: 2, texture: null }, "tSpecular" : { type: "t", value: 3, texture: null }, "tAO" : { type: "t", value: 4, texture: null }, "uNormalScale": { type: "f", value: 1.0 }, "tDisplacement": { type: "t", value: 5, texture: null }, "uDisplacementBias": { type: "f", value: 0.0 }, "uDisplacementScale": { type: "f", value: 1.0 }, "uDiffuseColor": { type: "c", value: new THREE.Color( 0xeeeeee ) }, "uSpecularColor": { type: "c", value: new THREE.Color( 0x111111 ) }, "uAmbientColor": { type: "c", value: new THREE.Color( 0x050505 ) }, "uShininess": { type: "f", value: 30 }, "uOpacity": { type: "f", value: 1 } } ] ), fragmentShader: [ "uniform vec3 uAmbientColor;", "uniform vec3 uDiffuseColor;", "uniform vec3 uSpecularColor;", "uniform float uShininess;", "uniform float uOpacity;", "uniform bool enableDiffuse;", "uniform bool enableSpecular;", "uniform bool enableAO;", "uniform sampler2D tDiffuse;", "uniform sampler2D tNormal;", "uniform sampler2D tSpecular;", "uniform sampler2D tAO;", "uniform float uNormalScale;", "varying vec3 vTangent;", "varying vec3 vBinormal;", "varying vec3 vNormal;", "varying vec2 vUv;", "uniform vec3 ambientLightColor;", "#if MAX_DIR_LIGHTS > 0", "uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];", "uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];", "#endif", "#if MAX_POINT_LIGHTS > 0", "uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];", "varying vec4 vPointLight[ MAX_POINT_LIGHTS ];", "#endif", "varying vec3 vViewPosition;", THREE.ShaderChunk[ "fog_pars_fragment" ], "void main() {", "gl_FragColor = vec4( 1.0 );", "vec4 mColor = vec4( uDiffuseColor, uOpacity );", "vec4 mSpecular = vec4( uSpecularColor, uOpacity );", "vec3 specularTex = vec3( 1.0 );", "vec3 normalTex = texture2D( tNormal, vUv ).xyz * 2.0 - 1.0;", "normalTex.xy *= uNormalScale;", "normalTex = normalize( normalTex );", "if( enableDiffuse )", "gl_FragColor = gl_FragColor * texture2D( tDiffuse, vUv );", "if( enableAO )", "gl_FragColor = gl_FragColor * texture2D( tAO, vUv );", "if( enableSpecular )", "specularTex = texture2D( tSpecular, vUv ).xyz;", "mat3 tsb = mat3( vTangent, vBinormal, vNormal );", "vec3 finalNormal = tsb * normalTex;", "vec3 normal = normalize( finalNormal );", "vec3 viewPosition = normalize( vViewPosition );", // point lights "#if MAX_POINT_LIGHTS > 0", "vec4 pointTotal = vec4( vec3( 0.0 ), 1.0 );", "for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {", "vec3 pointVector = normalize( vPointLight[ i ].xyz );", "vec3 pointHalfVector = normalize( vPointLight[ i ].xyz + viewPosition );", "float pointDistance = vPointLight[ i ].w;", "float pointDotNormalHalf = dot( normal, pointHalfVector );", "float pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );", "float pointSpecularWeight = 0.0;", "if ( pointDotNormalHalf >= 0.0 )", "pointSpecularWeight = specularTex.r * pow( pointDotNormalHalf, uShininess );", "pointTotal += pointDistance * vec4( pointLightColor[ i ], 1.0 ) * ( mColor * pointDiffuseWeight + mSpecular * pointSpecularWeight * pointDiffuseWeight );", "}", "#endif", // directional lights "#if MAX_DIR_LIGHTS > 0", "vec4 dirTotal = vec4( vec3( 0.0 ), 1.0 );", "for( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {", "vec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );", "vec3 dirVector = normalize( lDirection.xyz );", "vec3 dirHalfVector = normalize( lDirection.xyz + viewPosition );", "float dirDotNormalHalf = dot( normal, dirHalfVector );", "float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );", "float dirSpecularWeight = 0.0;", "if ( dirDotNormalHalf >= 0.0 )", "dirSpecularWeight = specularTex.r * pow( dirDotNormalHalf, uShininess );", "dirTotal += vec4( directionalLightColor[ i ], 1.0 ) * ( mColor * dirDiffuseWeight + mSpecular * dirSpecularWeight * dirDiffuseWeight );", "}", "#endif", // all lights contribution summation "vec4 totalLight = vec4( ambientLightColor * uAmbientColor, uOpacity );", "#if MAX_DIR_LIGHTS > 0", "totalLight += dirTotal;", "#endif", "#if MAX_POINT_LIGHTS > 0", "totalLight += pointTotal;", "#endif", "gl_FragColor = gl_FragColor * totalLight;", THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n"), vertexShader: [ "attribute vec4 tangent;", "#ifdef VERTEX_TEXTURES", "uniform sampler2D tDisplacement;", "uniform float uDisplacementScale;", "uniform float uDisplacementBias;", "#endif", "varying vec3 vTangent;", "varying vec3 vBinormal;", "varying vec3 vNormal;", "varying vec2 vUv;", "#if MAX_POINT_LIGHTS > 0", "uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];", "uniform float pointLightDistance[ MAX_POINT_LIGHTS ];", "varying vec4 vPointLight[ MAX_POINT_LIGHTS ];", "#endif", "varying vec3 vViewPosition;", "void main() {", "vec4 mPosition = objectMatrix * vec4( position, 1.0 );", "vViewPosition = cameraPosition - mPosition.xyz;", "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", "vNormal = normalize( normalMatrix * normal );", // tangent and binormal vectors "vTangent = normalize( normalMatrix * tangent.xyz );", "vBinormal = cross( vNormal, vTangent ) * tangent.w;", "vBinormal = normalize( vBinormal );", "vUv = uv;", // point lights "#if MAX_POINT_LIGHTS > 0", "for( int i = 0; i < MAX_POINT_LIGHTS; i++ ) {", "vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );", "vec3 lVector = lPosition.xyz - mvPosition.xyz;", "float lDistance = 1.0;", "if ( pointLightDistance[ i ] > 0.0 )", "lDistance = 1.0 - min( ( length( lVector ) / pointLightDistance[ i ] ), 1.0 );", "lVector = normalize( lVector );", "vPointLight[ i ] = vec4( lVector, lDistance );", "}", "#endif", // displacement mapping "#ifdef VERTEX_TEXTURES", "vec3 dv = texture2D( tDisplacement, uv ).xyz;", "float df = uDisplacementScale * dv.x + uDisplacementBias;", "vec4 displacedPosition = vec4( vNormal.xyz * df, 0.0 ) + mvPosition;", "gl_Position = projectionMatrix * displacedPosition;", "#else", "gl_Position = projectionMatrix * mvPosition;", "#endif", "}" ].join("\n") }, /* ------------------------------------------------------------------------- // Cube map shader ------------------------------------------------------------------------- */ 'cube': { uniforms: { "tCube": { type: "t", value: 1, texture: null } }, vertexShader: [ "varying vec3 vViewPosition;", "void main() {", "vec4 mPosition = objectMatrix * vec4( position, 1.0 );", "vViewPosition = cameraPosition - mPosition.xyz;", "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", "}" ].join("\n"), fragmentShader: [ "uniform samplerCube tCube;", "varying vec3 vViewPosition;", "void main() {", "vec3 wPos = cameraPosition - vViewPosition;", "gl_FragColor = textureCube( tCube, vec3( - wPos.x, wPos.yz ) );", "}" ].join("\n") }, /* ------------------------------------------------------------------------ // Convolution shader // - ported from o3d sample to WebGL / GLSL // http://o3d.googlecode.com/svn/trunk/samples/convolution.html ------------------------------------------------------------------------ */ 'convolution': { uniforms: { "tDiffuse" : { type: "t", value: 0, texture: null }, "uImageIncrement" : { type: "v2", value: new THREE.Vector2( 0.001953125, 0.0 ) }, "cKernel" : { type: "fv1", value: [] } }, vertexShader: [ "varying vec2 vUv;", "uniform vec2 uImageIncrement;", //"#define KERNEL_SIZE 25.0", "void main(void) {", "vUv = uv - ((KERNEL_SIZE - 1.0) / 2.0) * uImageIncrement;", "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", "}" ].join("\n"), fragmentShader: [ "varying vec2 vUv;", "uniform sampler2D tDiffuse;", "uniform vec2 uImageIncrement;", //"#define KERNEL_SIZE 25", "uniform float cKernel[KERNEL_SIZE];", "void main(void) {", "vec2 imageCoord = vUv;", "vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );", "for( int i=0; i kMaxKernelSize ) kernelSize = kMaxKernelSize; halfWidth = ( kernelSize - 1 ) * 0.5 values = new Array( kernelSize ); sum = 0.0; for ( i = 0; i < kernelSize; ++i ) { values[ i ] = gauss( i - halfWidth, sigma ); sum += values[ i ]; } // normalize the kernel for ( i = 0; i < kernelSize; ++i ) values[ i ] /= sum; return values; } }; };