port from perforce

hgplus/ShaderMinifier/tests/real/the orange guy/ball_pixel.glsl

@@ -0,0 +1,56 @@
+const int N_BALLS = 8; /* le nombre de points spirales */
+
+uniform vec4 col[N_BALLS]; /* couleurs des points spirales */
+uniform vec3 pos[N_BALLS]; /* position des points spirales */
+uniform float intensity[N_BALLS]; /* "taille" des points spirales */
+
+
+uniform float localTime;
+uniform float progression;
+
+/* renvoie la couleur de l'image en ce point.
+   On l'appelle plusieurs fois pour faire des symétries (bourrin !) */
+vec3 coul(vec2 p)
+{
+	float prog = progression;
+	float p2 = prog * prog;
+	float time = localTime;
+		
+	vec3 couleur = vec3(0.0,0.0,0.0); 
+	
+	
+	float l = min(0.0, 1.5 * progression - 0.5);
+	
+	float dist_factor = (6.0 + 3.0 * sin(time));
+
+	
+	for (int i = 0; i < N_BALLS; ++i)
+	{
+		vec2 diff = (pos[i].xy - p);
+		float d = dot(diff, diff);  /* d = distance entre le pixel et le point spirale i */
+		
+		float angle = atan(diff.y, diff.x);
+		
+		/* on accumule la contribution de chaque spirale */		
+		
+		float s = cos(5.0 * (angle - (1.0 + float(i) * 0.05 - prog * 1.5 ) * time) + d * dist_factor ); 
+		
+		s *= min(1.0, abs(0.7 + prog * 0.3 - s) * 15.0);
+		
+		float spiral_factor = max(0.0, s  * (1.0 - p2) );
+		float contrib = spiral_factor * intensity[i] * exp(-0.02 * d) + l;
+		
+		 couleur += col[i].rgb * contrib; 
+		
+	}
+	return couleur;
+}
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy * 0.7;
+	
+	vec3 couleur = coul(p);
+	
+	gl_FragColor = vec4( couleur * 1.1, 1.0 );
+}

hgplus/ShaderMinifier/tests/real/the orange guy/ball_vertex.glsl

@@ -0,0 +1,5 @@
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/bloom2_pixel.glsl

@@ -0,0 +1,35 @@
+uniform sampler2D tex;
+uniform float invTexWidth;
+
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	vec2 dp = vec2(invTexWidth, 0.0);
+	
+	/*
+	vec3 a = texture2D(tex, p - 3.0 * dp).rgb;
+	vec3 b = texture2D(tex, p - 2.0 * dp).rgb;
+	vec3 c = texture2D(tex, p - 1.0 * dp).rgb;
+	vec3 d = texture2D(tex, p ).rgb;
+	vec3 e = texture2D(tex, p + 1.0 * dp).rgb;
+	vec3 f = texture2D(tex, p + 2.0 * dp).rgb;
+	vec3 g = texture2D(tex, p + 3.0 * dp).rgb;
+	vec3 final = 0.015625 * (a + g)
+	           + 0.09375  * (b + f)
+	           + 0.234375 * (c + e)
+	           + 0.3125   * d;
+	
+	gl_FragColor = vec4( final, 1.0 );
+	*/
+	
+	
+	vec3 a = texture2D(tex, p - 2.1428571 * dp).rgb;
+	vec3 b = texture2D(tex, p - 0.6 * dp).rgb;
+	vec3 c = texture2D(tex, p + 0.6 * dp).rgb;
+	vec3 d = texture2D(tex, p + 2.1428571 * dp).rgb;
+	vec3 final = (2.0 * 0.21875)  * (a + d)
+	           + (2.0 * 0.78125)  * (b + c);	
+	gl_FragColor = vec4( final, 1.0 );
+	
+}

hgplus/ShaderMinifier/tests/real/the orange guy/bloom2_vertex.glsl

@@ -0,0 +1,5 @@
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/bloom_pixel.glsl

@@ -0,0 +1,40 @@
+uniform sampler2D tex;
+uniform float invTexHeight;
+
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	vec2 dp = vec2(0.0, invTexHeight);
+	
+	const vec3 limit = vec3(0.5,0.5,0.5);
+	const vec3 mini = vec3(0.0,0.0,0.0);
+	
+	/* first version (7 samples) */
+	/*
+	vec3 a = max(mini, texture2D(tex, p - 3.0 * dp).rgb - limit);
+	vec3 b = max(mini, texture2D(tex, p - 2.0 * dp).rgb - limit);
+	vec3 c = max(mini, texture2D(tex, p - 1.0 * dp).rgb - limit);
+	vec3 d = max(mini, texture2D(tex, p ).rgb - limit);
+	vec3 e = max(mini, texture2D(tex, p + 1.0 * dp).rgb - limit);
+	vec3 f = max(mini, texture2D(tex, p + 2.0 * dp).rgb - limit);
+	vec3 g = max(mini, texture2D(tex, p + 3.0 * dp).rgb - limit);
+	vec3 final = 0.015625 * (a + g)
+	           + 0.09375  * (b + f)
+	           + 0.234375 * (c + e)
+	           + 0.3125   * d;
+	
+	gl_FragColor = vec4( final * 2.0, 1.0 );
+	*/
+	
+	/* second version (4 samples) */
+	
+	vec3 a = max(mini, texture2D(tex, p - 2.1428571 * dp).rgb - limit);
+	vec3 b = max(mini, texture2D(tex, p - 0.6 * dp).rgb - limit);
+	vec3 c = max(mini, texture2D(tex, p + 0.6 * dp).rgb - limit);
+	vec3 d = max(mini, texture2D(tex, p + 2.1428571 * dp).rgb - limit);
+	vec3 final = (2.0 * 0.21875)  * (a + d)
+	           + (2.0 * 0.78125)  * (b + c);	
+	gl_FragColor = vec4( final, 1.0 );
+	
+}

hgplus/ShaderMinifier/tests/real/the orange guy/bloom_vertex.glsl

@@ -0,0 +1,5 @@
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/dfc_pixel.glsl

@@ -0,0 +1,67 @@
+const float PI = 3.1415926;
+
+
+uniform float localTime;
+
+vec3 coul2(float x, float y)
+{
+	 float h = (x + 1.0) * 350.0;
+	 float w = (y + 1.0) * 350.0;
+	 
+ 	 float hi = (h - 350.0) / 20.0;
+     float wi = (w - 350.0) / 20.0;
+    
+	 float xo = hi;
+	 float yo = wi + localTime;/*cos(hi/5.0) + wi + 0.1; */
+	    
+	 float xa = cos(hi/5.0);
+	 float ya = cos(wi/5.0);
+		
+	 float cosxa = cos(xa);
+	 float sinxa = sin(xa);
+	 float cosya = cos(ya);
+	 float sinya = sin(ya);
+		
+    vec3 res = vec3(0.0,0.0,0.0);
+    
+    for (int l = 0; l <= 30; l++)
+    {
+    	float li = (float(l) - 15.0) * 2.0;
+    	
+		float zo = li;
+		
+		float za = cos(li / 20.0); 
+		
+		float tmp = yo * cosxa + zo * sinxa;		
+		zo = zo * cosxa - yo * sinxa;
+		yo = tmp;
+		
+		float tmp2 = xo * cosya + zo * sinya;
+		zo = zo * cosya - xo * sinya;
+		xo = tmp2;
+	/*	
+		float tmp3 = xo * cos(za) + yo * sin(za);
+		yo = yo * cos(za) - xo * sin(za);
+		xo = tmp3;
+	*/	
+		vec3 color = vec3(128.0) + vec3(128.0) * vec3(cos(zo), cos(zo + PI * 2.0 / 3.0), cos(zo - PI * 2.0 / 3.0));
+		
+		float length = sqrt( xo * xo + yo * yo + zo * zo ) - 30.0;
+		float contrib = 0.25 / (1.0 + 400.0 * length * length);
+		
+		res = res * (1.0 - contrib) + color * contrib;
+	/*	res += contrib * color; */
+ 	 }
+ 	 
+ 	 return res;
+ }
+
+void main()
+{	
+	vec2 p = 0.5 * gl_TexCoord[0].xy + vec2(0.1,0.1);
+	
+	
+	gl_FragColor = vec4( 0.15 * coul2(p.x, p.y) , 1.0);
+}
+
+

hgplus/ShaderMinifier/tests/real/the orange guy/dfc_vertex.glsl

@@ -0,0 +1,6 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/final_pixel.glsl

@@ -0,0 +1,18 @@
+uniform sampler2D tonemappedTexture;
+uniform sampler2D bloomTexture;
+uniform sampler2D paperTexture;
+uniform int paper;
+uniform float paperInvSize;
+
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	
+	vec4 main = texture2D(tonemappedTexture, p);
+	vec4 bloom = texture2D(bloomTexture, p);
+	
+	vec4 paper = float(paper) * 1.8 *  texture2D(paperTexture, gl_FragCoord.xy * paperInvSize) + vec4(1.0,1.0,1.0,1.0) * (1.0 - float(paper));
+	
+	gl_FragColor = paper * (main * 0.8 + 0.2 * bloom); 	
+}

hgplus/ShaderMinifier/tests/real/the orange guy/final_vertex.glsl

@@ -0,0 +1,5 @@
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/font_pixel.glsl

@@ -0,0 +1,11 @@
+uniform sampler2D tex;
+uniform sampler2D fill;
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	vec4 letter = texture2D(tex, p);
+	vec4 fill = texture2D(fill, p * 3.0);
+
+	gl_FragColor = letter * fill * gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/font_vertex.glsl

@@ -0,0 +1,7 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+	gl_FrontColor = gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/logofinal_pixel.glsl

@@ -0,0 +1,8 @@
+uniform sampler2D tex;
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	vec4 sample0 = texture2D(tex, p);
+	gl_FragColor = gl_Color * sample0;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/logofinal_vertex.glsl

@@ -0,0 +1,7 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+	gl_FrontColor = gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/orange_pixel.glsl

@@ -0,0 +1,38 @@
+uniform sampler2D tex;
+uniform sampler2D grain;
+
+const int NPOINTS = 5;
+
+uniform float env;
+
+uniform vec3 pos[NPOINTS];
+uniform float intensity[NPOINTS];
+uniform float localTime;
+uniform float zoom;
+
+
+const float PI = 3.14159265;
+
+void main()
+{
+	float x = gl_TexCoord[0].s * zoom;
+	float y = gl_TexCoord[0].t * zoom;
+	float u = localTime * 0.25; 
+	
+	vec4 color = vec4(0.0);
+	
+	for (int i = 0; i < 5; i++)
+	{
+		vec3 diff = vec3(x, y, 0.0) - pos[i];
+		float angle = atan(diff.y, diff.x);
+		float d = env * 1.0; /* length(pos[i]);*/
+		float t = (d + localTime) * 0.03 ;
+		float s = u + angle / PI + (float(i) * 0.1);
+		float dist = length(diff);
+		vec4 grain = texture2D(grain, vec2(0.5, 0.3 * dist));		
+		
+		color += (texture2D(tex, vec2(s,t)) * grain) * (intensity[i] / (1.0 + 0.2 * dist));	
+	}
+	
+	gl_FragColor = vec4(color.rgb * 0.6 + 0.4 * env, 1.0); 
+}

hgplus/ShaderMinifier/tests/real/the orange guy/orange_vertex.glsl

@@ -0,0 +1,6 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/particle_pixel.glsl

@@ -0,0 +1,15 @@
+uniform sampler2D tex;
+
+uniform float intensity;
+uniform float alpha;
+
+void main()
+{
+	vec4 color = texture2D(tex, gl_TexCoord[0].xy);	
+	float opacity = dot(color.rgb, vec3(0.33,0.33,0.33)) * color.a * alpha;
+	
+	
+	if (opacity < 0.05) discard; 
+		
+	gl_FragData[0] = vec4(color.rgb * intensity, opacity);	
+}

hgplus/ShaderMinifier/tests/real/the orange guy/particle_vertex.glsl

@@ -0,0 +1,8 @@
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	
+	gl_Position = ftransform();		
+	
+	gl_FrontColor  = gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/put_pixel.glsl

@@ -0,0 +1,4 @@
+void main()
+{	
+	gl_FragColor = gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/put_vertex.glsl

@@ -0,0 +1,7 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+	gl_FrontColor = gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/puttexture_pixel.glsl

@@ -0,0 +1,20 @@
+uniform sampler2D tex0;
+uniform sampler2D tex1;
+uniform sampler2D tex2;
+uniform sampler2D tex3;
+
+uniform float amountTex0;
+uniform float amountTex1;
+uniform float amountTex2;
+uniform float amountTex3;
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	vec4 sample0 = texture2D(tex0, p);
+	vec4 sample1 = texture2D(tex1, p);
+	vec4 sample2 = texture2D(tex2, p);
+	vec4 sample3 = texture2D(tex3, p);
+	gl_FragColor = gl_Color * (amountTex0 * sample0 + sample1 * amountTex1 
+	                         + amountTex2 * sample2 + sample3 * amountTex3 );
+}

hgplus/ShaderMinifier/tests/real/the orange guy/puttexture_vertex.glsl

@@ -0,0 +1,7 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+	gl_FrontColor = gl_Color;
+}

hgplus/ShaderMinifier/tests/real/the orange guy/scene10_pixel.glsl

@@ -0,0 +1,30 @@
+const int N_SPIRALES = 12; /* le nombre de points spirales */
+
+uniform vec4 pos[N_SPIRALES]; /* position des points spirales, rayon, intensite */
+uniform float musicVolume;
+
+static const vec3 WHITE = vec3(1.0,1.0,1.0);
+
+vec3 coul(vec2 p)
+{
+	float f = 0.0;
+	for (int i = 0; i < N_SPIRALES; ++i)
+	{
+		vec2 diff = pos[i].xy - p;
+		float dist = pow(dot(diff, diff), 1.0 / 4.0);
+		float s = abs(dist - pos[i].z); 
+		
+		f = f + pos[i].w * exp(-s * (50.0 - musicVolume * 20.0));
+	}
+	
+	return WHITE * max(0.0, 1.2 - f); 
+}
+
+void main()
+{	
+	vec2 p = gl_TexCoord[0].xy;
+	
+	vec3 couleur = coul(p);
+	
+	gl_FragColor = vec4( couleur * (1.0 + musicVolume), 1.0 );
+}

hgplus/ShaderMinifier/tests/real/the orange guy/scene10_vertex.glsl

@@ -0,0 +1,6 @@
+
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/tonemapping_pixel.glsl

@@ -0,0 +1,18 @@
+uniform sampler2D tex;
+
+void main()
+{	
+	vec3 color = texture2D(tex, gl_TexCoord[0].xy).rgb;
+	float luminance = dot( vec3(0.3, 0.59, 0.11), color);
+	
+	/*float luminance = dot( vec3(0.33, 0.33, 0.33), color);*/
+	
+	 /* [0 .. infinity] is mapped to [0 .. 1] */
+	 
+	float factor = luminance / (1.0 + luminance);
+	
+	/* interesting bug : make black area */
+	/* float factor = sin((luminance * 3.141596 * 0.5) / (1.0 + luminance));*/
+	
+	gl_FragColor = vec4( factor * color, 1.0 );
+}

hgplus/ShaderMinifier/tests/real/the orange guy/tonemapping_vertex.glsl

@@ -0,0 +1,5 @@
+void main()
+{	
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();		
+}

hgplus/ShaderMinifier/tests/real/the orange guy/tunnel_pixel.glsl

@@ -0,0 +1,20 @@
+
+varying vec2 st;
+uniform float alpha;
+uniform sampler2D tex;
+uniform float time;
+uniform vec4 color;
+varying float prof;
+
+void main()
+{
+	
+	vec3 texcolor = texture2D(tex, st).rgb;
+	
+	float opacity = alpha < 0.9 ? 1.0 : 1.0 - 0.7 * dot(vec3(0.33,0.33,0.33), texcolor);
+	
+	opacity *= exp(-0.10 * abs(prof));
+	
+	gl_FragData[0] = color * vec4(texcolor * 1.6,  opacity);	
+	
+}

hgplus/ShaderMinifier/tests/real/the orange guy/tunnel_vertex.glsl

@@ -0,0 +1,13 @@
+varying vec2 st;
+varying float prof;
+
+
+void main()
+{	
+	st = gl_MultiTexCoord0.xy;
+	
+	vec4 p = ftransform();
+	prof = gl_Color.x * 50.0;
+	
+	gl_Position = p;
+}