/** * Webgl Shader Library for three.js * * @author alteredq / http://alteredqualia.com/ * @author mrdoob / http://mrdoob.com/ * @author mikael emtinger / http://gomo.se/ * * * @author croqueteer / http://www.wearality.com * SphereShaderLib.js is equivalent to ShaderLib.js except that the "default_vertex" is replaced with a true * spherical transform. This allows an undistorted single pass spherical field of view up to (but not including) 180 degrees. */ THREE.ShaderChunk[ "sphere_vertex"] = ["vec4 mvPosition;", "#ifdef USE_SKINNING", " mvPosition = modelViewMatrix * skinned;", "#endif", "#if !defined( USE_SKINNING ) && defined( USE_MORPHTARGETS )", " mvPosition = modelViewMatrix * vec4( morphed, 1.0 );", "#endif", "#if !defined( USE_SKINNING ) && ! defined( USE_MORPHTARGETS )", " mvPosition = modelViewMatrix * vec4( position, 1.0 );", "#endif ", " vec4 p = mvPosition; // put the vector into the camera frame", " float len = length(p.xyz); // use the length of the vector - not the z component", " if(p.z<0.0)len = -len; // the length sign should reflect the z sign", " float ctan = projectionMatrix[0][0]; // this is the cotangent of the x-component", " p.y *= projectionMatrix[1][1]/ctan; // set the y aspect ratio", " p.w = -len; // the w component is the negative of the z component", " p.z = len*projectionMatrix[2][2]+projectionMatrix[3][2]; // the z component is really the length of the vector", " p.xy *= sqrt((ctan*ctan)+1.0); // this is the camera field of view - the narrower the fov, the larger this multiplier is", " p.x += projectionMatrix[2][0]*len;", " p.y += projectionMatrix[2][1]*len;", " gl_Position = p; // done" ].join("\n"); THREE.ShaderLib = { 'basic': { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "common" ], THREE.UniformsLib[ "fog" ], THREE.UniformsLib[ "shadowmap" ] ] ), vertexShader: [ THREE.ShaderChunk[ "map_pars_vertex" ], THREE.ShaderChunk[ "lightmap_pars_vertex" ], THREE.ShaderChunk[ "envmap_pars_vertex" ], THREE.ShaderChunk[ "color_pars_vertex" ], THREE.ShaderChunk[ "morphtarget_pars_vertex" ], THREE.ShaderChunk[ "skinning_pars_vertex" ], THREE.ShaderChunk[ "shadowmap_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "map_vertex" ], THREE.ShaderChunk[ "lightmap_vertex" ], THREE.ShaderChunk[ "color_vertex" ], THREE.ShaderChunk[ "skinbase_vertex" ], " #ifdef USE_ENVMAP", THREE.ShaderChunk[ "morphnormal_vertex" ], THREE.ShaderChunk[ "skinnormal_vertex" ], THREE.ShaderChunk[ "defaultnormal_vertex" ], " #endif", THREE.ShaderChunk[ "morphtarget_vertex" ], THREE.ShaderChunk[ "skinning_vertex" ], THREE.ShaderChunk[ "sphere_vertex" ], THREE.ShaderChunk[ "logdepthbuf_vertex" ], THREE.ShaderChunk[ "worldpos_vertex" ], THREE.ShaderChunk[ "envmap_vertex" ], THREE.ShaderChunk[ "shadowmap_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform vec3 diffuse;", "uniform float opacity;", THREE.ShaderChunk[ "color_pars_fragment" ], THREE.ShaderChunk[ "map_pars_fragment" ], THREE.ShaderChunk[ "alphamap_pars_fragment" ], THREE.ShaderChunk[ "lightmap_pars_fragment" ], THREE.ShaderChunk[ "envmap_pars_fragment" ], THREE.ShaderChunk[ "fog_pars_fragment" ], THREE.ShaderChunk[ "shadowmap_pars_fragment" ], THREE.ShaderChunk[ "specularmap_pars_fragment" ], THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " gl_FragColor = vec4( diffuse, opacity );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], THREE.ShaderChunk[ "map_fragment" ], THREE.ShaderChunk[ "alphamap_fragment" ], THREE.ShaderChunk[ "alphatest_fragment" ], THREE.ShaderChunk[ "specularmap_fragment" ], THREE.ShaderChunk[ "lightmap_fragment" ], THREE.ShaderChunk[ "color_fragment" ], THREE.ShaderChunk[ "envmap_fragment" ], THREE.ShaderChunk[ "shadowmap_fragment" ], THREE.ShaderChunk[ "linear_to_gamma_fragment" ], THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n") }, 'lambert': { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "common" ], THREE.UniformsLib[ "fog" ], THREE.UniformsLib[ "lights" ], THREE.UniformsLib[ "shadowmap" ], { "ambient" : { type: "c", value: new THREE.Color( 0xffffff ) }, "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) }, "wrapRGB" : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) } } ] ), vertexShader: [ "#define LAMBERT", "varying vec3 vLightFront;", "#ifdef DOUBLE_SIDED", " varying vec3 vLightBack;", "#endif", THREE.ShaderChunk[ "map_pars_vertex" ], THREE.ShaderChunk[ "lightmap_pars_vertex" ], THREE.ShaderChunk[ "envmap_pars_vertex" ], THREE.ShaderChunk[ "lights_lambert_pars_vertex" ], THREE.ShaderChunk[ "color_pars_vertex" ], THREE.ShaderChunk[ "morphtarget_pars_vertex" ], THREE.ShaderChunk[ "skinning_pars_vertex" ], THREE.ShaderChunk[ "shadowmap_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "map_vertex" ], THREE.ShaderChunk[ "lightmap_vertex" ], THREE.ShaderChunk[ "color_vertex" ], THREE.ShaderChunk[ "morphnormal_vertex" ], THREE.ShaderChunk[ "skinbase_vertex" ], THREE.ShaderChunk[ "skinnormal_vertex" ], THREE.ShaderChunk[ "defaultnormal_vertex" ], THREE.ShaderChunk[ "morphtarget_vertex" ], THREE.ShaderChunk[ "skinning_vertex" ], THREE.ShaderChunk[ "sphere_vertex" ], THREE.ShaderChunk[ "logdepthbuf_vertex" ], THREE.ShaderChunk[ "worldpos_vertex" ], THREE.ShaderChunk[ "envmap_vertex" ], THREE.ShaderChunk[ "lights_lambert_vertex" ], THREE.ShaderChunk[ "shadowmap_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform float opacity;", "varying vec3 vLightFront;", "#ifdef DOUBLE_SIDED", " varying vec3 vLightBack;", "#endif", THREE.ShaderChunk[ "color_pars_fragment" ], THREE.ShaderChunk[ "map_pars_fragment" ], THREE.ShaderChunk[ "alphamap_pars_fragment" ], THREE.ShaderChunk[ "lightmap_pars_fragment" ], THREE.ShaderChunk[ "envmap_pars_fragment" ], THREE.ShaderChunk[ "fog_pars_fragment" ], THREE.ShaderChunk[ "shadowmap_pars_fragment" ], THREE.ShaderChunk[ "specularmap_pars_fragment" ], THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " gl_FragColor = vec4( vec3( 1.0 ), opacity );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], THREE.ShaderChunk[ "map_fragment" ], THREE.ShaderChunk[ "alphamap_fragment" ], THREE.ShaderChunk[ "alphatest_fragment" ], THREE.ShaderChunk[ "specularmap_fragment" ], " #ifdef DOUBLE_SIDED", //"float isFront = float( gl_FrontFacing );", //"gl_FragColor.xyz *= isFront * vLightFront + ( 1.0 - isFront ) * vLightBack;", " if ( gl_FrontFacing )", " gl_FragColor.xyz *= vLightFront;", " else", " gl_FragColor.xyz *= vLightBack;", " #else", " gl_FragColor.xyz *= vLightFront;", " #endif", THREE.ShaderChunk[ "lightmap_fragment" ], THREE.ShaderChunk[ "color_fragment" ], THREE.ShaderChunk[ "envmap_fragment" ], THREE.ShaderChunk[ "shadowmap_fragment" ], THREE.ShaderChunk[ "linear_to_gamma_fragment" ], THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n") }, 'phong': { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "common" ], THREE.UniformsLib[ "bump" ], THREE.UniformsLib[ "normalmap" ], THREE.UniformsLib[ "fog" ], THREE.UniformsLib[ "lights" ], THREE.UniformsLib[ "shadowmap" ], { "ambient" : { type: "c", value: new THREE.Color( 0xffffff ) }, "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) }, "specular" : { type: "c", value: new THREE.Color( 0x111111 ) }, "shininess": { type: "f", value: 30 }, "wrapRGB" : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) } } ] ), vertexShader: [ "#define PHONG", "varying vec3 vViewPosition;", "varying vec3 vNormal;", THREE.ShaderChunk[ "map_pars_vertex" ], THREE.ShaderChunk[ "lightmap_pars_vertex" ], THREE.ShaderChunk[ "envmap_pars_vertex" ], THREE.ShaderChunk[ "lights_phong_pars_vertex" ], THREE.ShaderChunk[ "color_pars_vertex" ], THREE.ShaderChunk[ "morphtarget_pars_vertex" ], THREE.ShaderChunk[ "skinning_pars_vertex" ], THREE.ShaderChunk[ "shadowmap_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "map_vertex" ], THREE.ShaderChunk[ "lightmap_vertex" ], THREE.ShaderChunk[ "color_vertex" ], THREE.ShaderChunk[ "morphnormal_vertex" ], THREE.ShaderChunk[ "skinbase_vertex" ], THREE.ShaderChunk[ "skinnormal_vertex" ], THREE.ShaderChunk[ "defaultnormal_vertex" ], " vNormal = normalize( transformedNormal );", THREE.ShaderChunk[ "morphtarget_vertex" ], THREE.ShaderChunk[ "skinning_vertex" ], THREE.ShaderChunk[ "sphere_vertex" ], THREE.ShaderChunk[ "logdepthbuf_vertex" ], " vViewPosition = -mvPosition.xyz;", THREE.ShaderChunk[ "worldpos_vertex" ], THREE.ShaderChunk[ "envmap_vertex" ], THREE.ShaderChunk[ "lights_phong_vertex" ], THREE.ShaderChunk[ "shadowmap_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform vec3 diffuse;", "uniform float opacity;", "uniform vec3 ambient;", "uniform vec3 emissive;", "uniform vec3 specular;", "uniform float shininess;", THREE.ShaderChunk[ "color_pars_fragment" ], THREE.ShaderChunk[ "map_pars_fragment" ], THREE.ShaderChunk[ "alphamap_pars_fragment" ], THREE.ShaderChunk[ "lightmap_pars_fragment" ], THREE.ShaderChunk[ "envmap_pars_fragment" ], THREE.ShaderChunk[ "fog_pars_fragment" ], THREE.ShaderChunk[ "lights_phong_pars_fragment" ], THREE.ShaderChunk[ "shadowmap_pars_fragment" ], THREE.ShaderChunk[ "bumpmap_pars_fragment" ], THREE.ShaderChunk[ "normalmap_pars_fragment" ], THREE.ShaderChunk[ "specularmap_pars_fragment" ], THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " gl_FragColor = vec4( vec3( 1.0 ), opacity );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], THREE.ShaderChunk[ "map_fragment" ], THREE.ShaderChunk[ "alphamap_fragment" ], THREE.ShaderChunk[ "alphatest_fragment" ], THREE.ShaderChunk[ "specularmap_fragment" ], THREE.ShaderChunk[ "lights_phong_fragment" ], THREE.ShaderChunk[ "lightmap_fragment" ], THREE.ShaderChunk[ "color_fragment" ], THREE.ShaderChunk[ "envmap_fragment" ], THREE.ShaderChunk[ "shadowmap_fragment" ], THREE.ShaderChunk[ "linear_to_gamma_fragment" ], THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n") }, 'particle_basic': { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "particle" ], THREE.UniformsLib[ "shadowmap" ] ] ), vertexShader: [ "uniform float size;", "uniform float scale;", THREE.ShaderChunk[ "color_pars_vertex" ], THREE.ShaderChunk[ "shadowmap_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "color_vertex" ], " vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", " #ifdef USE_SIZEATTENUATION", " gl_PointSize = size * ( scale / length( mvPosition.xyz ) );", " #else", " gl_PointSize = size;", " #endif", " gl_Position = projectionMatrix * mvPosition;", THREE.ShaderChunk[ "logdepthbuf_vertex" ], THREE.ShaderChunk[ "worldpos_vertex" ], THREE.ShaderChunk[ "shadowmap_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform vec3 psColor;", "uniform float opacity;", THREE.ShaderChunk[ "color_pars_fragment" ], THREE.ShaderChunk[ "map_particle_pars_fragment" ], THREE.ShaderChunk[ "fog_pars_fragment" ], THREE.ShaderChunk[ "shadowmap_pars_fragment" ], THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " gl_FragColor = vec4( psColor, opacity );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], THREE.ShaderChunk[ "map_particle_fragment" ], THREE.ShaderChunk[ "alphatest_fragment" ], THREE.ShaderChunk[ "color_fragment" ], THREE.ShaderChunk[ "shadowmap_fragment" ], THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n") }, 'dashed': { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "common" ], THREE.UniformsLib[ "fog" ], { "scale" : { type: "f", value: 1 }, "dashSize" : { type: "f", value: 1 }, "totalSize": { type: "f", value: 2 } } ] ), vertexShader: [ "uniform float scale;", "attribute float lineDistance;", "varying float vLineDistance;", THREE.ShaderChunk[ "color_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "color_vertex" ], " vLineDistance = scale * lineDistance;", " vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", " gl_Position = projectionMatrix * mvPosition;", THREE.ShaderChunk[ "logdepthbuf_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform vec3 diffuse;", "uniform float opacity;", "uniform float dashSize;", "uniform float totalSize;", "varying float vLineDistance;", THREE.ShaderChunk[ "color_pars_fragment" ], THREE.ShaderChunk[ "fog_pars_fragment" ], THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " if ( mod( vLineDistance, totalSize ) > dashSize ) {", " discard;", " }", " gl_FragColor = vec4( diffuse, opacity );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], THREE.ShaderChunk[ "color_fragment" ], THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n") }, 'depth': { uniforms: { "mNear": { type: "f", value: 1.0 }, "mFar" : { type: "f", value: 2000.0 }, "opacity" : { type: "f", value: 1.0 } }, vertexShader: [ THREE.ShaderChunk[ "morphtarget_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "morphtarget_vertex" ], THREE.ShaderChunk[ "sphere_vertex" ], THREE.ShaderChunk[ "logdepthbuf_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform float mNear;", "uniform float mFar;", "uniform float opacity;", THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", THREE.ShaderChunk[ "logdepthbuf_fragment" ], " #ifdef USE_LOGDEPTHBUF_EXT", " float depth = gl_FragDepthEXT / gl_FragCoord.w;", " #else", " float depth = gl_FragCoord.z / gl_FragCoord.w;", " #endif", " float color = 1.0 - smoothstep( mNear, mFar, depth );", " gl_FragColor = vec4( vec3( color ), opacity );", "}" ].join("\n") }, 'normal': { uniforms: { "opacity" : { type: "f", value: 1.0 } }, vertexShader: [ "varying vec3 vNormal;", THREE.ShaderChunk[ "morphtarget_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", " vNormal = normalize( normalMatrix * normal );", THREE.ShaderChunk[ "morphtarget_vertex" ], THREE.ShaderChunk[ "sphere_vertex" ], THREE.ShaderChunk[ "logdepthbuf_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform float opacity;", "varying vec3 vNormal;", THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " gl_FragColor = vec4( 0.5 * normalize( vNormal ) + 0.5, opacity );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], "}" ].join("\n") }, /* ------------------------------------------------------------------------- // Normal map shader // - Blinn-Phong // - normal + diffuse + specular + AO + displacement + reflection + shadow maps // - point and directional lights (use with "lights: true" material option) ------------------------------------------------------------------------- */ 'normalmap' : { uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib[ "fog" ], THREE.UniformsLib[ "lights" ], THREE.UniformsLib[ "shadowmap" ], { "enableAO" : { type: "i", value: 0 }, "enableDiffuse" : { type: "i", value: 0 }, "enableSpecular" : { type: "i", value: 0 }, "enableReflection" : { type: "i", value: 0 }, "enableDisplacement": { type: "i", value: 0 }, "tDisplacement": { type: "t", value: null }, // must go first as this is vertex texture "tDiffuse" : { type: "t", value: null }, "tCube" : { type: "t", value: null }, "tNormal" : { type: "t", value: null }, "tSpecular" : { type: "t", value: null }, "tAO" : { type: "t", value: null }, "uNormalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) }, "uDisplacementBias": { type: "f", value: 0.0 }, "uDisplacementScale": { type: "f", value: 1.0 }, "diffuse": { type: "c", value: new THREE.Color( 0xffffff ) }, "specular": { type: "c", value: new THREE.Color( 0x111111 ) }, "ambient": { type: "c", value: new THREE.Color( 0xffffff ) }, "shininess": { type: "f", value: 30 }, "opacity": { type: "f", value: 1 }, "useRefract": { type: "i", value: 0 }, "refractionRatio": { type: "f", value: 0.98 }, "reflectivity": { type: "f", value: 0.5 }, "uOffset" : { type: "v2", value: new THREE.Vector2( 0, 0 ) }, "uRepeat" : { type: "v2", value: new THREE.Vector2( 1, 1 ) }, "wrapRGB" : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) } } ] ), fragmentShader: [ "uniform vec3 ambient;", "uniform vec3 diffuse;", "uniform vec3 specular;", "uniform float shininess;", "uniform float opacity;", "uniform bool enableDiffuse;", "uniform bool enableSpecular;", "uniform bool enableAO;", "uniform bool enableReflection;", "uniform sampler2D tDiffuse;", "uniform sampler2D tNormal;", "uniform sampler2D tSpecular;", "uniform sampler2D tAO;", "uniform samplerCube tCube;", "uniform vec2 uNormalScale;", "uniform bool useRefract;", "uniform float refractionRatio;", "uniform float reflectivity;", "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_HEMI_LIGHTS > 0", " uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];", " uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];", " uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];", "#endif", "#if MAX_POINT_LIGHTS > 0", " uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];", " uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];", " uniform float pointLightDistance[ MAX_POINT_LIGHTS ];", "#endif", "#if MAX_SPOT_LIGHTS > 0", " uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];", " uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];", " uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];", " uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];", " uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];", " uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];", "#endif", "#ifdef WRAP_AROUND", " uniform vec3 wrapRGB;", "#endif", "varying vec3 vWorldPosition;", "varying vec3 vViewPosition;", THREE.ShaderChunk[ "shadowmap_pars_fragment" ], THREE.ShaderChunk[ "fog_pars_fragment" ], THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", THREE.ShaderChunk[ "logdepthbuf_fragment" ], " gl_FragColor = vec4( vec3( 1.0 ), opacity );", " vec3 specularTex = vec3( 1.0 );", " vec3 normalTex = texture2D( tNormal, vUv ).xyz * 2.0 - 1.0;", " normalTex.xy *= uNormalScale;", " normalTex = normalize( normalTex );", " if( enableDiffuse ) {", " #ifdef GAMMA_INPUT", " vec4 texelColor = texture2D( tDiffuse, vUv );", " texelColor.xyz *= texelColor.xyz;", " gl_FragColor = gl_FragColor * texelColor;", " #else", " gl_FragColor = gl_FragColor * texture2D( tDiffuse, vUv );", " #endif", " }", " if( enableAO ) {", " #ifdef GAMMA_INPUT", " vec4 aoColor = texture2D( tAO, vUv );", " aoColor.xyz *= aoColor.xyz;", " gl_FragColor.xyz = gl_FragColor.xyz * aoColor.xyz;", " #else", " gl_FragColor.xyz = gl_FragColor.xyz * texture2D( tAO, vUv ).xyz;", " #endif", " }", THREE.ShaderChunk[ "alphatest_fragment" ], " if( enableSpecular )", " specularTex = texture2D( tSpecular, vUv ).xyz;", " mat3 tsb = mat3( normalize( vTangent ), normalize( vBinormal ), normalize( vNormal ) );", " vec3 finalNormal = tsb * normalTex;", " #ifdef FLIP_SIDED", " finalNormal = -finalNormal;", " #endif", " vec3 normal = normalize( finalNormal );", " vec3 viewPosition = normalize( vViewPosition );", // point lights " #if MAX_POINT_LIGHTS > 0", " vec3 pointDiffuse = vec3( 0.0 );", " vec3 pointSpecular = vec3( 0.0 );", " for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {", " vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );", " vec3 pointVector = lPosition.xyz + vViewPosition.xyz;", " float pointDistance = 1.0;", " if ( pointLightDistance[ i ] > 0.0 )", " pointDistance = 1.0 - min( ( length( pointVector ) / pointLightDistance[ i ] ), 1.0 );", " pointVector = normalize( pointVector );", // diffuse " #ifdef WRAP_AROUND", " float pointDiffuseWeightFull = max( dot( normal, pointVector ), 0.0 );", " float pointDiffuseWeightHalf = max( 0.5 * dot( normal, pointVector ) + 0.5, 0.0 );", " vec3 pointDiffuseWeight = mix( vec3( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), wrapRGB );", " #else", " float pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );", " #endif", " pointDiffuse += pointDistance * pointLightColor[ i ] * diffuse * pointDiffuseWeight;", // specular " vec3 pointHalfVector = normalize( pointVector + viewPosition );", " float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );", " float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, shininess ), 0.0 );", " float specularNormalization = ( shininess + 2.0 ) / 8.0;", " vec3 schlick = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( pointVector, pointHalfVector ), 0.0 ), 5.0 );", " pointSpecular += schlick * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * pointDistance * specularNormalization;", " }", " #endif", // spot lights " #if MAX_SPOT_LIGHTS > 0", " vec3 spotDiffuse = vec3( 0.0 );", " vec3 spotSpecular = vec3( 0.0 );", " for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {", " vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );", " vec3 spotVector = lPosition.xyz + vViewPosition.xyz;", " float spotDistance = 1.0;", " if ( spotLightDistance[ i ] > 0.0 )", " spotDistance = 1.0 - min( ( length( spotVector ) / spotLightDistance[ i ] ), 1.0 );", " spotVector = normalize( spotVector );", " float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - vWorldPosition ) );", " if ( spotEffect > spotLightAngleCos[ i ] ) {", " spotEffect = max( pow( max( spotEffect, 0.0 ), spotLightExponent[ i ] ), 0.0 );", // diffuse " #ifdef WRAP_AROUND", " float spotDiffuseWeightFull = max( dot( normal, spotVector ), 0.0 );", " float spotDiffuseWeightHalf = max( 0.5 * dot( normal, spotVector ) + 0.5, 0.0 );", " vec3 spotDiffuseWeight = mix( vec3( spotDiffuseWeightFull ), vec3( spotDiffuseWeightHalf ), wrapRGB );", " #else", " float spotDiffuseWeight = max( dot( normal, spotVector ), 0.0 );", " #endif", " spotDiffuse += spotDistance * spotLightColor[ i ] * diffuse * spotDiffuseWeight * spotEffect;", // specular " vec3 spotHalfVector = normalize( spotVector + viewPosition );", " float spotDotNormalHalf = max( dot( normal, spotHalfVector ), 0.0 );", " float spotSpecularWeight = specularTex.r * max( pow( spotDotNormalHalf, shininess ), 0.0 );", " float specularNormalization = ( shininess + 2.0 ) / 8.0;", " vec3 schlick = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( spotVector, spotHalfVector ), 0.0 ), 5.0 );", " spotSpecular += schlick * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * spotDistance * specularNormalization * spotEffect;", " }", " }", " #endif", // directional lights " #if MAX_DIR_LIGHTS > 0", " vec3 dirDiffuse = vec3( 0.0 );", " vec3 dirSpecular = vec3( 0.0 );", " for( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {", " vec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );", " vec3 dirVector = normalize( lDirection.xyz );", // diffuse " #ifdef WRAP_AROUND", " float directionalLightWeightingFull = max( dot( normal, dirVector ), 0.0 );", " float directionalLightWeightingHalf = max( 0.5 * dot( normal, dirVector ) + 0.5, 0.0 );", " vec3 dirDiffuseWeight = mix( vec3( directionalLightWeightingFull ), vec3( directionalLightWeightingHalf ), wrapRGB );", " #else", " float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );", " #endif", " dirDiffuse += directionalLightColor[ i ] * diffuse * dirDiffuseWeight;", // specular " vec3 dirHalfVector = normalize( dirVector + viewPosition );", " float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );", " float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, shininess ), 0.0 );", " float specularNormalization = ( shininess + 2.0 ) / 8.0;", " vec3 schlick = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( dirVector, dirHalfVector ), 0.0 ), 5.0 );", " dirSpecular += schlick * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization;", " }", " #endif", // hemisphere lights " #if MAX_HEMI_LIGHTS > 0", " vec3 hemiDiffuse = vec3( 0.0 );", " vec3 hemiSpecular = vec3( 0.0 );" , " for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {", " vec4 lDirection = viewMatrix * vec4( hemisphereLightDirection[ i ], 0.0 );", " vec3 lVector = normalize( lDirection.xyz );", // diffuse " float dotProduct = dot( normal, lVector );", " float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;", " vec3 hemiColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );", " hemiDiffuse += diffuse * hemiColor;", // specular (sky light) " vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );", " float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;", " float hemiSpecularWeightSky = specularTex.r * max( pow( max( hemiDotNormalHalfSky, 0.0 ), shininess ), 0.0 );", // specular (ground light) " vec3 lVectorGround = -lVector;", " vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );", " float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;", " float hemiSpecularWeightGround = specularTex.r * max( pow( max( hemiDotNormalHalfGround, 0.0 ), shininess ), 0.0 );", " float dotProductGround = dot( normal, lVectorGround );", " float specularNormalization = ( shininess + 2.0 ) / 8.0;", " vec3 schlickSky = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( lVector, hemiHalfVectorSky ), 0.0 ), 5.0 );", " vec3 schlickGround = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( lVectorGround, hemiHalfVectorGround ), 0.0 ), 5.0 );", " hemiSpecular += hemiColor * specularNormalization * ( schlickSky * hemiSpecularWeightSky * max( dotProduct, 0.0 ) + schlickGround * hemiSpecularWeightGround * max( dotProductGround, 0.0 ) );", " }", " #endif", // all lights contribution summation " vec3 totalDiffuse = vec3( 0.0 );", " vec3 totalSpecular = vec3( 0.0 );", " #if MAX_DIR_LIGHTS > 0", " totalDiffuse += dirDiffuse;", " totalSpecular += dirSpecular;", " #endif", " #if MAX_HEMI_LIGHTS > 0", " totalDiffuse += hemiDiffuse;", " totalSpecular += hemiSpecular;", " #endif", " #if MAX_POINT_LIGHTS > 0", " totalDiffuse += pointDiffuse;", " totalSpecular += pointSpecular;", " #endif", " #if MAX_SPOT_LIGHTS > 0", " totalDiffuse += spotDiffuse;", " totalSpecular += spotSpecular;", " #endif", " #ifdef METAL", " gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * ambient + totalSpecular );", " #else", " gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * ambient ) + totalSpecular;", " #endif", " if ( enableReflection ) {", " vec3 vReflect;", " vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );", " if ( useRefract ) {", " vReflect = refract( cameraToVertex, normal, refractionRatio );", " } else {", " vReflect = reflect( cameraToVertex, normal );", " }", " vec4 cubeColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );", " #ifdef GAMMA_INPUT", " cubeColor.xyz *= cubeColor.xyz;", " #endif", " gl_FragColor.xyz = mix( gl_FragColor.xyz, cubeColor.xyz, specularTex.r * reflectivity );", " }", THREE.ShaderChunk[ "shadowmap_fragment" ], THREE.ShaderChunk[ "linear_to_gamma_fragment" ], THREE.ShaderChunk[ "fog_fragment" ], "}" ].join("\n"), vertexShader: [ "attribute vec4 tangent;", "uniform vec2 uOffset;", "uniform vec2 uRepeat;", "uniform bool enableDisplacement;", "#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;", "varying vec3 vWorldPosition;", "varying vec3 vViewPosition;", THREE.ShaderChunk[ "skinning_pars_vertex" ], THREE.ShaderChunk[ "shadowmap_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "skinbase_vertex" ], THREE.ShaderChunk[ "skinnormal_vertex" ], // normal, tangent and binormal vectors " #ifdef USE_SKINNING", " vNormal = normalize( normalMatrix * skinnedNormal.xyz );", " vec4 skinnedTangent = skinMatrix * vec4( tangent.xyz, 0.0 );", " vTangent = normalize( normalMatrix * skinnedTangent.xyz );", " #else", " vNormal = normalize( normalMatrix * normal );", " vTangent = normalize( normalMatrix * tangent.xyz );", " #endif", " vBinormal = normalize( cross( vNormal, vTangent ) * tangent.w );", " vUv = uv * uRepeat + uOffset;", // displacement mapping " vec3 displacedPosition;", " #ifdef VERTEX_TEXTURES", " if ( enableDisplacement ) {", " vec3 dv = texture2D( tDisplacement, uv ).xyz;", " float df = uDisplacementScale * dv.x + uDisplacementBias;", " displacedPosition = position + normalize( normal ) * df;", " } else {", " #ifdef USE_SKINNING", " vec4 skinVertex = bindMatrix * vec4( position, 1.0 );", " vec4 skinned = vec4( 0.0 );", " skinned += boneMatX * skinVertex * skinWeight.x;", " skinned += boneMatY * skinVertex * skinWeight.y;", " skinned += boneMatZ * skinVertex * skinWeight.z;", " skinned += boneMatW * skinVertex * skinWeight.w;", " skinned = bindMatrixInverse * skinned;", " displacedPosition = skinned.xyz;", " #else", " displacedPosition = position;", " #endif", " }", " #else", " #ifdef USE_SKINNING", " vec4 skinVertex = bindMatrix * vec4( position, 1.0 );", " vec4 skinned = vec4( 0.0 );", " skinned += boneMatX * skinVertex * skinWeight.x;", " skinned += boneMatY * skinVertex * skinWeight.y;", " skinned += boneMatZ * skinVertex * skinWeight.z;", " skinned += boneMatW * skinVertex * skinWeight.w;", " skinned = bindMatrixInverse * skinned;", " displacedPosition = skinned.xyz;", " #else", " displacedPosition = position;", " #endif", " #endif", // " vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );", " vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );", " gl_Position = projectionMatrix * mvPosition;", THREE.ShaderChunk[ "logdepthbuf_vertex" ], // " vWorldPosition = worldPosition.xyz;", " vViewPosition = -mvPosition.xyz;", // shadows " #ifdef USE_SHADOWMAP", " for( int i = 0; i < MAX_SHADOWS; i ++ ) {", " vShadowCoord[ i ] = shadowMatrix[ i ] * worldPosition;", " }", " #endif", "}" ].join("\n") }, /* ------------------------------------------------------------------------- // Cube map shader ------------------------------------------------------------------------- */ 'cube': { uniforms: { "tCube": { type: "t", value: null }, "tFlip": { type: "f", value: - 1 } }, vertexShader: [ "varying vec3 vWorldPosition;", THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", " vec4 worldPosition = modelMatrix * vec4( position, 1.0 );", " vWorldPosition = worldPosition.xyz;", " gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", THREE.ShaderChunk[ "logdepthbuf_vertex" ], "}" ].join("\n"), fragmentShader: [ "uniform samplerCube tCube;", "uniform float tFlip;", "varying vec3 vWorldPosition;", THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "void main() {", " gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );", THREE.ShaderChunk[ "logdepthbuf_fragment" ], "}" ].join("\n") }, /* Depth encoding into RGBA texture * * based on SpiderGL shadow map example * http://spidergl.org/example.php?id=6 * * originally from * http://www.gamedev.net/topic/442138-packing-a-float-into-a-a8r8g8b8-texture-shader/page__whichpage__1%25EF%25BF%25BD * * see also * http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/ */ 'depthRGBA': { uniforms: {}, vertexShader: [ THREE.ShaderChunk[ "morphtarget_pars_vertex" ], THREE.ShaderChunk[ "skinning_pars_vertex" ], THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], "void main() {", THREE.ShaderChunk[ "skinbase_vertex" ], THREE.ShaderChunk[ "morphtarget_vertex" ], THREE.ShaderChunk[ "skinning_vertex" ], THREE.ShaderChunk[ "sphere_vertex" ], THREE.ShaderChunk[ "logdepthbuf_vertex" ], "}" ].join("\n"), fragmentShader: [ THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], "vec4 pack_depth( const in float depth ) {", " const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );", " const vec4 bit_mask = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );", " vec4 res = mod( depth * bit_shift * vec4( 255 ), vec4( 256 ) ) / vec4( 255 );", // " vec4 res = fract( depth * bit_shift );", " res -= res.xxyz * bit_mask;", " return res;", "}", "void main() {", THREE.ShaderChunk[ "logdepthbuf_fragment" ], " #ifdef USE_LOGDEPTHBUF_EXT", " gl_FragData[ 0 ] = pack_depth( gl_FragDepthEXT );", " #else", " gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z );", " #endif", //"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z / gl_FragCoord.w );", //"float z = ( ( gl_FragCoord.z / gl_FragCoord.w ) - 3.0 ) / ( 4000.0 - 3.0 );", //"gl_FragData[ 0 ] = pack_depth( z );", //"gl_FragData[ 0 ] = vec4( z, z, z, 1.0 );", "}" ].join("\n") } };