自学教程：C++ texture2D函数代码示例

            void main(void)            {                vec4 origColor = texture2D(otex, gl_TexCoord[0].st);                vec4 raysColor = texture2D(rtex, gl_TexCoord[0].st);                if (lightDirDOTviewDir>0.0){                    float exposure	= 0.1/float(NUM_SAMPLES);                    float decay		= 1.0 ;                    float density	= 0.5;                    float weight	= 6.0;                    float illuminationDecay = 1.0;                    vec2 deltaTextCoord = vec2( gl_TexCoord[0].st - lightPositionOnScreen);                    vec2 textCoo = gl_TexCoord[0].st;                    deltaTextCoord *= 1.0 / float(NUM_SAMPLES) * density;                    for(int i=0; i < NUM_SAMPLES ; i++)                    {                        textCoo -= deltaTextCoord;                        vec4 tsample = texture2D(rtex, textCoo );                        tsample *= illuminationDecay * weight;                        raysColor += tsample;                        illuminationDecay *= decay;                    }                    raysColor *= exposure * lightDirDOTviewDir;                    float p = 0.3 *raysColor.g + 0.59*raysColor.r + 0.11*raysColor.b;                    gl_FragColor = origColor + p;                } else {                    gl_FragColor = origColor;                }            }

void main()	{		vec4 heightRT = texture2D( u_Texture0, v_TexCoords );	vec4 normRT = texture2D( u_Texture1, v_TexCoords );	vec3 baseNorm = (normRT.rgb-0.5)*2.0;	baseNorm.z = 0.0;	baseNorm = normalize(baseNorm);	vec3 faceNorm = vec3(0.0,0.0,1.0);	float curDis = heightRT.b;	float maxDis = 128.0/255.0;	float startZ = 0.0;	float endZ = 1.0;	float lerpPow = 2.0;	float lerpAmount = max(maxDis-curDis,0.0)/maxDis;		/*	// sharp bevel	lerpAmount = 0.5;	if (curDis >= 80.0/255.0) {		lerpAmount = 0.0;	}*/	if (curDis <= 16.0/255.0) {		lerpAmount = 1.0;	}	vec3 finalNorm = mix(faceNorm, baseNorm, lerpAmount );	finalNorm = normalize(finalNorm);	float alphaVal = heightRT.g;		if (alphaVal == 0.0) {		discard;	}		vec4 gIdRGBA;	float groupId = v_Data0.z;	gIdRGBA.rg = pack16(groupId);	//gIdRGBA.r = floor(groupId/256.0)/255.0;	//gIdRGBA.g = mod(groupId,256.0)/255.0;	float matId = v_Data0.w;	gIdRGBA.ba = pack16(matId);	//gIdRGBA.b = floor(matId/256.0)/255.0;	//gIdRGBA.a = mod(matId,256.0)/255.0;		gl_FragColor = gIdRGBA;		}

void main() {    // pages    vec4 tex0 = texture2D(Texture0, TexCoord0 );    vec4 tex1 = texture2D(Texture1, TexCoord0 );    // geom    vec4 tex2 = texture2D(Texture2, TexCoord0 );    vec4 tex3 = texture2D(Texture3, TexCoord0 );    float bh1 = unpack16(tex0.rg);    float bh2 = unpack16(tex2.rg);    vec4 res0 = vec4(0.0);    vec4 res1 = vec4(0.0);    if (bh2 > bh1) {        res0 = tex2;        res1 = tex3;    }    else {        res0 = tex0;        res1 = tex1;    }    gl_FragData[0] = res0;    gl_FragData[1] = res1;}

void main()/n/{/n/	vec4 diffuse = texture2D(texture1, st);/n/	vec4 position = texture2D(texture2, st);/n/	vec4 normal = texture2D(texture3, st);/n/	vec3 light = vec3(50,100,50);/n/	vec3 lightDir = light - position.xyz ;/n/	/n/	float blurSize_x = 1.0/100.0;/n/	float blurSize_y = 1.0/80.0;/n//n/	vec4 sum = vec4(0);/n/	vec2 size = vec2(800,600);/n/int samples = 20; /n/float quality =4.0; /n/  int diff = (samples - 1) / 2;/n/  vec2 sizeFactor = vec2(1) / size * quality;/n/  /n/  for (int x = -diff; x <= diff; x++)/n/  {/n/    for (int y = -diff; y <= diff; y++)/n/    {/n/      vec2 coordinate = st + vec2(x, y) * sizeFactor;/n/      coordinate.x = clamp(coordinate.x, 0.0, 1.0);/n/      coordinate.y = clamp(coordinate.y, 0.0, 1.0);/n/      sum += texture2D(texture4, coordinate);/n/    }/n/  }/n/  sum = sum / (samples*samples);/n//n/	diffuse = diffuse*(1.0 - sum.a);/n/	finalColor = diffuse+sum;/n/}";

void main () {        vec4  texel  = texture2D(sampler, gl_FragCoord.xy / resolution);    vec2 coords  = vec2(gl_FragCoord.x, (resolution.y - gl_FragCoord.y)) / resolution;        if( (coords.x >= clip.s && coords.y >= clip.t) &&        (coords.x <= clip.p && coords.y <= clip.q) )    {        vec4 clap = clip; clap.tq -= offset.y / count.t;                vec2 coords  = (coords - clap.st) / (clap.pq - clap.st);                vec4 glyph   = texture2D(text, vec2(            coords.x,            (coords.y * ( count.t / count.p))        ));                texel        = texture2D(glyphs, vec2(                        ( glyph.p - glyph.s ) * fract( (coords.x + offset.x) * count.s ) + glyph.s,                        ( glyph.q - glyph.t ) * fract( coords.y * count.t ) + glyph.t                      ));                gl_FragColor = vec4(1., 1., 1., texel.a);            }    else        gl_FragColor = texture2D(texture, gl_FragCoord.xy / resolution);    }

    const char *fragmentShader() const {        return QT_STRINGIFY(            const int numberOfLights = 5;            varying mediump vec2 qt_TexCoord0;            varying mediump vec3 lightVecTangent[numberOfLights];            uniform mediump float qt_Opacity;            uniform mediump float lightIntensities[numberOfLights];            uniform sampler2D sourceImage;            uniform sampler2D normalsImage;            void main(void) {                mediump vec2 pixPos = qt_TexCoord0;                mediump vec4 pix = texture2D(sourceImage, pixPos.st);                mediump vec4 pix2 = texture2D(normalsImage, pixPos.st);                mediump vec3 normal = vec3(pix2.rg * 2.0 - 1.0, pix2.b);                mediump float diffuse = 0.66;                // Unroll the loop, my HD3000 doesn't like non-const array lookups.                mediump vec3 relVec;                relVec = normalize(lightVecTangent[0]);                diffuse += lightIntensities[0] * 0.4 * dot(normal, relVec);                relVec = normalize(lightVecTangent[1]);                diffuse += lightIntensities[1] * 0.4 * dot(normal, relVec);                relVec = normalize(lightVecTangent[2]);                diffuse += lightIntensities[2] * 0.4 * dot(normal, relVec);                relVec = normalize(lightVecTangent[3]);                diffuse += lightIntensities[3] * 0.4 * dot(normal, relVec);                relVec = normalize(lightVecTangent[4]);                diffuse += lightIntensities[4] * 0.4 * dot(normal, relVec);                diffuse = clamp(diffuse, 0.0, 1.0);                mediump vec4 color = vec4(diffuse * pix.rgb, pix.a);                gl_FragColor = color * qt_Opacity;            }

string GaussianBlurFilter::_getFragSrc() {    return GLSL_STRING(120,        uniform sampler2D texture0;        uniform float blurSize;        uniform float bloom;        uniform float texelWidthOffset;        uniform float texelHeightOffset;        void main() {        float v;        float pi = 3.141592653589793;        float radius = blurSize;        if ( radius < 0 ) radius = 0;        int steps = int(min(radius * 0.7, sqrt(radius) * pi));        float r = radius / steps;        float t = bloom / (steps * 2 + 1);        float x = gl_TexCoord[0].x;        float y = gl_TexCoord[0].y;        vec4 sum = texture2D(texture0, vec2(x, y)) * t;        int i;        for(i = 1; i <= steps; i++){            v = (cos(i / (steps + 1) / pi) + 1) * 0.5;            sum += texture2D(texture0, vec2(x + i * texelWidthOffset * r, y + i * texelHeightOffset * r)) * v * t;            sum += texture2D(texture0, vec2(x - i * texelWidthOffset * r, y - i * texelHeightOffset * r)) * v * t;        }        gl_FragColor = sum;    }

            void main(void){                float dxtex = 1.0 / textureSizeX;                float dytex = 1.0 / textureSizeY;                vec2 st = gl_TexCoord[0].st;                // access center pixel and 4 surrounded pixel                vec3 center = getNormal(st).rgb;                vec3 left = getNormal(st + vec2(dxtex, 0.0)).rgb;                vec3 right = getNormal(st + vec2(-dxtex, 0.0)).rgb;                vec3 up = getNormal(st + vec2(0.0, -dytex)).rgb;                vec3 down = getNormal(st + vec2(0.0, dytex)).rgb;                // discrete Laplace operator                vec3 laplace = abs(-4.0*center + left + right + up + down);                // if one rgb-component of convolution result is over threshold => edge                vec4 line = texture2D(normalImage, st);                if(laplace.r > normalEdgeThreshold                || laplace.g > normalEdgeThreshold                || laplace.b > normalEdgeThreshold){                    line = vec4(0.0, 0.0, 0.0, 1.0); // => color the pixel green                } else {                    line = vec4(1.0, 1.0, 1.0, 1.0); // black                }                //end Line;                //start Phong                //vec3 lightPosition = vec3(100.0, 100.0, 50.0);                vec3 lightPosition = gl_LightSource[0].position.xyz;                vec3 L = normalize(lightPosition - v);                vec3 E = normalize(-v);                vec3 R = normalize(-reflect(L,N));                // ambient term                vec4 Iamb = ambient;                // diffuse term                vec4 Idiff = texture2D( normalImage, gl_TexCoord[0].st) * diffuse;                //vec4 Idiff = vec4(1.0, 1.0, 1.0, 1.0) * diffuse;                Idiff *= max(dot(N,L), 0.0);                Idiff = clamp(Idiff, 0.0, 1.0);                // specular term                vec4 Ispec = specular;                Ispec *= pow(max(dot(R,E),0.0), shinyness);                Ispec = clamp(Ispec, 0.0, 1.0);                                 vec4 color = Iamb + Idiff;                if ( bSpecular == 1 ) color += Ispec;                // store previous alpha value                float alpha = color.a;                // quantize process: multiply by factor, round and divde by factor                color = floor(0.5 + (qLevel * color)) / qLevel;                // set fragment/pixel color                color.a = alpha;                gl_FragColor = color * line;            }

void main(void)/{/ vec4 shared=texture2D(TexUnit2, vec2(gl_TexCoord[2]));/ vec4 pantalla=texture2D(TexUnit0, vec2(gl_TexCoord[0]));/ vec4 blur=texture2D(TexUnit1, vec2(gl_TexCoord[1]))*producto*shared.rrrr;/ gl_FragColor = pantalla*blur*addormultiply + ((pantalla+blur)*(1.0-addormultiply));/}";

void main (void) {  vec4 texcolor=gl_Color;  vec4 finalcolor;  float fShadowFactor=1.0;  float specfactor=1.0;  #ifdef ENABLE_TEXTURES  #ifdef ENABLE_WATER  ApplyWaterEffect(Texture0,gl_TexCoord[0].xy,texcolor.xyz);  #else    texcolor*= texture2D(Texture0, gl_TexCoord[0].xy);  #endif	#if TEXTURE_UNITS > 1		#ifdef ENABLE_WATER			vec3 temptexunit1;			ApplyWaterEffect(Texture1,gl_TexCoord[1].xy,temptexunit1);			texcolor.rgb*=temptexunit1;		#else		texcolor*= texture2D(Texture1, gl_TexCoord[1].xy);		#endif	#endif#endif    #ifdef ENABLE_SHADOWS	fShadowFactor=shadow2DProj(ShadowMap, gl_TexCoord[SHADOW_TEXTURE_LEVEL]).r;	#ifdef ENABLE_SOFT_SHADOWS		float offset=3.0;		fShadowFactor+=shadow2DProj(ShadowMap,gl_TexCoord[SHADOW_TEXTURE_LEVEL]+vec4(-offset,-offset,0,0)).g;		fShadowFactor+=shadow2DProj(ShadowMap,gl_TexCoord[SHADOW_TEXTURE_LEVEL]+vec4(offset,-offset,0,0)).g;		fShadowFactor+=shadow2DProj(ShadowMap,gl_TexCoord[SHADOW_TEXTURE_LEVEL]+vec4(-offset,offset,0,0)).g;		fShadowFactor+=shadow2DProj(ShadowMap,gl_TexCoord[SHADOW_TEXTURE_LEVEL]+vec4(offset,offset,0,0)).g;		fShadowFactor/=5.0;	#endif  #endif	  #ifdef ENABLE_LIGHTING	  vec4 sunambdiffspec=g_sunambdiffspec;      #ifdef ENABLE_SKY_SHADOW		sunambdiffspec*=1.0-(texture2D(SkyShadowMap, gl_TexCoord[SKY_TEXTURE_LEVEL].xy)*SkyData.a);	  #endif	  finalcolor.rgb=clamp(g_ambdiffspec.rgb+sunambdiffspec.rgb*fShadowFactor,0.0,LIGHTING_SATURATION);	  finalcolor.rgb*=texcolor.rgb;	  finalcolor.a=texcolor.a;  #else	#ifdef ENABLE_SKY_SHADOW	  fShadowFactor*=1.0-(texture2D(SkyShadowMap, gl_TexCoord[SKY_TEXTURE_LEVEL].xy)*SkyData.a).r;	#endif	finalcolor=texcolor*fShadowFactor;  #endif	    #ifdef ENABLE_FOG	finalcolor= vec4(clamp(finalcolor.rgb, 0.0, 1.0),finalcolor.a);	finalcolor.rgb=mix(finalcolor.rgb,gl_Fog.color.rgb,g_fFogFactor);  #endif	gl_FragColor=finalcolor;}

// Derivative maps - bump mapping unparametrized surfaces by Morten Mikkelsen//	http://mmikkelsen3d.blogspot.sk/2011/07/derivative-maps.html// Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)vec2 dHdxy_fwd() {  vec2 dSTdx = dFdx( vUv );  vec2 dSTdy = dFdy( vUv );  float hll = bumpScale * texture2D( tDisplacement, vUv ).x;  float dBx = bumpScale * texture2D( tDisplacement, vUv + dSTdx ).x - hll;  float dBy = bumpScale * texture2D( tDisplacement, vUv + dSTdy ).x - hll;  return vec2( dBx, dBy );}

	void main()	{		vec4 redColor   = texture2D(texture, fragmentTextureCoordinate.xy - redOffset   + vec2(0.5,0.5));		vec4 greenColor = texture2D(texture, fragmentTextureCoordinate.xy - greenOffset + vec2(0.5,0.5));		vec4 blueColor  = texture2D(texture, fragmentTextureCoordinate.xy - blueOffset  + vec2(0.5,0.5));		gl_FragColor = vec4(redColor.r, greenColor.g, blueColor.b, (redColor.a + greenColor.a + blueColor.a)/3.);	}

void main(void){    float toneFactor = 1.0;///2.0;        vec4 mapC = texture2D(uMapKd, vTexCoordinate);    vec4 shad = texture2D(uMapShadow, vTexCoordinate)*toneFactor;       gl_FragColor = mapC * shad + shad * (shad.w - 1.0)*mapC.w; } 

	void main(void)	{		vec4 color = texture2D(texture, fragmentTextureCoordinate.xy);		vec4 maskColor = texture2D(mask, fragmentTextureCoordinate.xy);		float maskAmount = maskColor.a * rgbToHsl(maskColor.rgb).z;		color.rgb *= maskAmount;		color.a = maskAmount;		gl_FragColor = color;	}

void main(void){     vec4 tv4Position = texture2D(uMapPosition, vTexCoordinate);            vec4 shadowProj =  uShadowMatrix * vec4(tv4Position.xyz, 1.0);        shadowProj /= shadowProj.w;				if ( abs(shadowProj.x) < 1.0 && abs(shadowProj.y) < 1.0 && abs(shadowProj.z) < 1.0 )	{        vec2 shadowSample = vec2( (shadowProj.x+1.0)/2.0, (shadowProj.y+1.0)/2.0 );        float shadowVal = 0.0;        float count = 0.0;        //float x, y;                for (float y = -1.5; y <= 1.5; y += 1.0)        {            for (float x = -1.5; x <= 1.5; x += 1.0)            {                vec4 t4Shadow    = texture2D(uMapShadow,                                              vec2( shadowSample.x + x/1024.0,                                                    shadowSample.y + y/1024.0) ); // assuming a 1024 by 1024 shadow map                                if ( t4Shadow.x - shadowProj.z > -0.0000 )                {                    shadowVal += 1.0;                 }                 else                {                    float variance = t4Shadow.y - (t4Shadow.x*t4Shadow.x);                    variance = max(variance,0.0000002);                                        float d = shadowProj.z - t4Shadow.x;                    float p_max = variance / (variance + d*d);                                    shadowVal += p_max;                }                                 count += 1.0;            }        }                shadowVal = shadowVal/count;                gl_FragColor = vec4(shadowVal);    }    else    {        vec4 pingColor   = texture2D( uMapPing,    vTexCoordinate);        gl_FragColor = pingColor;    }} 

void main()	{	vec2 newTC = mod(v_TexCoords*4.0,2.0)/2.0;	vec2 newTC2 = v_TexCoords;	newTC2.y = 1.0-newTC2.y;	vec4 baseval = texture2D( u_Texture0, newTC );	vec4 basevalo = texture2D( u_Texture0, v_TexCoords );		float res;	vec4 res2;	if (u_Section == 0.0) {		if (newTC2.x < 0.5 && newTC2.y < 0.5 ) {			res = baseval.r;			res2 = vec4(1.0,0.0,0.0,1.0);		}		if (newTC2.x >= 0.5 && newTC2.y < 0.5 ) {			res = baseval.g;			res2 = vec4(0.0,1.0,0.0,1.0);		}		if (newTC2.x < 0.5 && newTC2.y >= 0.5 ) {			res = baseval.b;			res2 = vec4(0.0,0.0,1.0,1.0);		}		if (newTC2.x >= 0.5 && newTC2.y >= 0.5 ) {			res = baseval.a;			res2 = vec4(1.0,1.0,0.0,1.0);		}		gl_FragColor = mix(vec4(res,res,res,1.0),res2,0.3);	}	if (u_Section == 1.0) {		gl_FragColor = vec4(basevalo.rrr,1.0);	}	if (u_Section == 2.0) {		gl_FragColor = vec4(basevalo.ggg,1.0);	}	if (u_Section == 3.0) {		gl_FragColor = vec4(basevalo.bbb,1.0);	}	if (u_Section == 4.0) {		gl_FragColor = vec4(basevalo.aaa,1.0);	}	if (u_Section == 5.0) {		gl_FragColor = vec4(basevalo.rgb,1.0);	}		}

void main(){																											/n/																														/n/	vec2 diff=gl_TexCoord[0].st-origin;																					/n/	float distSq=dot(diff,diff);																						/n/	float t=radius*radius*texScaled*texScaled;																			/n/	if(distSq<t){																										/n/		gl_FragColor=vec4(impulseColor*impulseStrength+texture2D(tex,gl_TexCoord[0].st).xyz*(1.0-impulseStrength),1.0);	/n/	}else{																												/n/		gl_FragColor=vec4(texture2D(tex,gl_TexCoord[0].st).xyz,1.0);													/n/	}																													/n/}																														/n/

void main()	{	vec4 baseval00 = texture2D( u_Texture0, v_TexCoords );	vec4 baseval01 = texture2D( u_Texture0, v_TexCoords+vec2(0.0/u_TexResolution.x,1.0/u_TexResolution.y) );	vec4 baseval10 = texture2D( u_Texture0, v_TexCoords+vec2(1.0/u_TexResolution.x,0.0/u_TexResolution.y) );	vec4 baseval11 = texture2D( u_Texture0, v_TexCoords+vec2(1.0/u_TexResolution.x,1.0/u_TexResolution.y) );    gl_FragColor = (baseval00+baseval01+baseval10+baseval11)/4.0;}

void main() {    vec3 pos = texture2D(tPositions, vUv).xyz;    vec3 vel = texture2D(tVelocities, vUv).xyz;    pos.x += vel.x;    pos.y += vel.y;    pos.z += vel.z;    // Write new position out    gl_FragColor = vec4(pos, 1.0);}

	void main()	{		vec4 base = texture2D(background, fragmentTextureCoordinate.xy);		vec4 blend = texture2D(foreground, fragmentTextureCoordinate.xy);		vec3 result = vec3( mix(base.r, blend.r, blend.a),							mix(base.g, blend.g, blend.a),							mix(base.b, blend.b, blend.a) );		gl_FragColor = vec4( mix(base.rgb, result, foregroundOpacity), base.a + blend.a * foregroundOpacity);	}

void main() {        vec4 tex0 = texture2D( Texture0, (TexCoord0.xy + paramArrMap[8].xy) );    vec4 tex1 = texture2D( Texture1, (TexCoord0.xy + paramArrMap[9].xy)*mapSampScale );    vec4 tex2 = texture2D( Texture2, (TexCoord0.xy + paramArrMap[10].xy)*mapSampScale );    float[6] sv;    float[6] vals;    vals[0] = tex1.r;    vals[1] = tex1.g;    vals[2] = tex1.b;    vals[3] = tex2.r;    vals[4] = tex2.g;    vals[5] = tex2.b;    int i;    int j;    int curInd = -1;    for (i = 0; i < 6; i++) {        sv[i] = vals[int(paramArrMap[i].x)];    }    float v0 = sv[0]*tex0.r;//*tex0.r;    float v1 = sv[1]*tex0.g;//*tex0.g;    float v2 = sv[2]*tex0.b;//*tex0.b;    //float h = sqrt(v0 + v1 + v2);    float h = pow(max(max(v0,v1),v2),0.4);    //h *= 2.0;    //(v0*v1*v2)*0.75+0.25;//            // if (h > 1.0) {    //     h = 2.0-h;    // }    h = pow(h,1.5);    h = clamp(h, 0.0, 1.0);        gl_FragData[0] = vec4(h,0.0,0.0,0.0);}

 void main() {/     if (isDepth) {/         float n = clipPlanes.x;/         float f = clipPlanes.y;/         float z = texture2D(texture, texCoord).x;/         z = (2.0 * n) / (f + n - z * (f - n));/         gl_FragColor = vec4(z,z,z,1.0);/     }/     else {/         gl_FragColor = texture2D(texture, texCoord);/     }/ }/0";

void main(void)/n/{/n/    vec3 yuv;/n/    vec3 rgb;/n/    yuv.x = texture2D(tex_y, vec2(TexCoordOut.x*yborder,TexCoordOut.y)).r;/n/    yuv.y = texture2D(tex_u, vec2(TexCoordOut.x*uborder,TexCoordOut.y)).r - 0.5;/n/    yuv.z = texture2D(tex_v, vec2(TexCoordOut.x*vborder,TexCoordOut.y)).r - 0.5;/n/    rgb = mat3( 1,       1,         1,/n/               0,       -0.39465,  2.03211,/n/               1.13983, -0.58060,  0) * yuv;/n/    gl_FragColor = vec4(rgb, 1);/n/}";

 void main() / { /     mediump vec3 yuv; /     lowp vec3 rgb; /     yuv.x = texture2D(u_texture,   v_texCoord).r; /     yuv.yz = texture2D(u_texture_u, v_texCoord).ar - 0.5; /     rgb = mat3( 1,        1,       1, /                 0,       -0.39465, 2.03211, /                 1.13983, -0.58060, 0) * yuv; /     gl_FragColor = vec4(rgb, 1); /     gl_FragColor *= u_modulation; / } /

string DisplacementFilter::_getFragSrc() {    return GLSL_STRING(120,                       uniform float texelWidth;                       uniform float texelHeight;                                              uniform sampler2D inputImageTexture;                       uniform sampler2D inputImageTexture2;                                              void main() {                           vec2 uv = gl_TexCoord[0].xy;                           vec2 offset = texture2D(inputImageTexture2, uv ).xy * vec2(texelWidth, texelHeight);                           gl_FragColor = texture2D(inputImageTexture, uv + offset.xy);                       }

			void main()															   /n/			{																	   /n/				if (g_useLighting)												   /n/				{																   /n/					float l = length(v_position.xyz - g_light);					   /n/					float atten = min(2.0, 10.0 / (1.0 + l*1.0 + 0.8*l*l));		   /n/					gl_FragColor = texture2D(s_texture, v_texcoord) * atten;	   /n/				}																   /n/				else															   /n/				{																   /n/					gl_FragColor = texture2D(s_texture, v_texcoord);			   /n/				}																   /n/			}";

void main(void){    float toneFactor = 1.0/6.0;///2.0;        vec4 mapC = texture2D(uMapKd, vTexCoordinate);    vec4 light= texture2D(uMapLight, vTexCoordinate);    vec4 shad = texture2D(uMapShadow, vTexCoordinate);        vec4 ambient = mapC * shad * 0.2;        vec4 lightf = light * toneFactor * shad;       gl_FragColor = mapC * lightf + light * (light.w - 1.0)*mapC.w*toneFactor + ambient; } 

void main(void)/{/  if (v[0][1] < 0.5) {/    vec2 n=vec2(fract(sin(dot(z.xy+v[0][0],vec2(12.9898,78.233)))*43758.5453));/	gl_FragColor=texture2D(t,.5*z.xy+.5+.0007*n)+n.x*.02;/  } else {/	vec2 pos = vTexCoord + vec2(-0.000, 0.0);/	gl_FragColor = vec4(0.0);/	for (int i = -0; i <= 0; i++) {/		gl_FragColor += texture2D(t, pos)/1.0;/		pos += vec2(0.000/1.0, 0.0);/	}/  }/}";

string SobelEdgeDetectionFilter::_getFragSrc() {    return GLSL_STRING(120,                       varying vec2 textureCoordinate;                       varying vec2 leftTextureCoordinate;                       varying vec2 rightTextureCoordinate;                                              varying vec2 topTextureCoordinate;                       varying vec2 topLeftTextureCoordinate;                       varying vec2 topRightTextureCoordinate;                                              varying vec2 bottomTextureCoordinate;                       varying vec2 bottomLeftTextureCoordinate;                       varying vec2 bottomRightTextureCoordinate;                                              uniform sampler2D inputImageTexture;                       uniform float edgeStrength;                                              void main() {                           float bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;                           float topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;                           float topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;                           float bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;                           float leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;                           float rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;                           float bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;                           float topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;                           float h = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;                           float v = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;                                                      float mag = length(vec2(h, v)) * edgeStrength;                                                      gl_FragColor = vec4(vec3(mag), 1.0);                       }

void main(){  vec4 splatRec = texture2D(splat, gl_TexCoord[0].xy);  vec3 splatColor = splatRec.rgb/(splatRec.a);  vec4 directRec = texture2D(direct, gl_TexCoord[0].xy);    //vec4 outCol = 0.75*directRec + vec4(splatColor, 1.0);  //gl_FragColor = vec4(outCol.rgb, 1.0);  gl_FragColor = vec4(splatColor, 1.0) + .5*directRec;}