shader reflection color calculation tweak

shaders/conversion.glsl

@@ -0,0 +1,108 @@
+vec3 rgb2yuv(vec3 input)
+{
+	return
+		clamp(
+			vec3(
+				 (0.257 * input.r) + (0.504 * input.g) + (0.098 * input.b) + 0.0625,
+				-(0.148 * input.r) - (0.291 * input.g) + (0.439 * input.b) + 0.5,
+				 (0.439 * input.r) - (0.368 * input.g) - (0.071 * input.b) + 0.5 ),
+			0.0, 1.0);
+}
+
+vec3 yuv2rgb(vec3 input)
+{
+	input -= vec3(0.0625, 0.5, 0.5);
+	return
+		clamp(
+			vec3(
+				(1.164 * input.r) + (1.596 * input.b),
+				(1.164 * input.r) - (0.391 * input.g) - (0.813 * input.b),
+				(1.164 * input.r) + (2.018 * input.g) ),
+			0.0, 1.0);
+}
+
+vec3 rgb2hsl( vec3 col )
+{
+	float red   = col.r;
+	float green = col.g;
+	float blue  = col.b;
+
+	float minc  = min( col.r, min( col.g, col.b ));
+	float maxc  = max( col.r, max( col.g, col.b ));
+	float delta = maxc - minc;
+
+	float lum = (minc + maxc) * 0.5;
+	float sat = 0.0;
+	float hue = 0.0;
+
+	if (lum > 0.0 && lum < 1.0) {
+		float mul = (lum < 0.5)  ?  (lum)  :  (1.0-lum);
+		sat = delta / (mul * 2.0);
+	}
+
+	vec3 masks = vec3(
+		(maxc == red   && maxc != green) ? 1.0 : 0.0,
+		(maxc == green && maxc != blue)  ? 1.0 : 0.0,
+		(maxc == blue  && maxc != red)   ? 1.0 : 0.0
+	);
+
+	vec3 adds = vec3(
+		((green - blue ) / delta),
+		2.0 + ((blue  - red  ) / delta),
+		4.0 + ((red   - green) / delta)
+	);
+
+	float deltaGtz = (delta > 0.0) ? 1.0 : 0.0;
+
+	hue += dot( adds, masks );
+	hue *= deltaGtz;
+	hue /= 6.0;
+
+	if (hue < 0.0)
+		hue += 1.0;
+
+	return vec3( hue, sat, lum );
+}
+
+vec3 hsl2rgb( vec3 col )
+{
+	const float onethird = 1.0 / 3.0;
+	const float twothird = 2.0 / 3.0;
+	const float rcpsixth = 6.0;
+
+	float hue = col.x;
+	float sat = col.y;
+	float lum = col.z;
+
+	vec3 xt = vec3(
+		rcpsixth * (hue - twothird),
+		0.0,
+		rcpsixth * (1.0 - hue)
+	);
+
+	if (hue < twothird) {
+		xt.r = 0.0;
+		xt.g = rcpsixth * (twothird - hue);
+		xt.b = rcpsixth * (hue      - onethird);
+	} 
+
+	if (hue < onethird) {
+		xt.r = rcpsixth * (onethird - hue);
+		xt.g = rcpsixth * hue;
+		xt.b = 0.0;
+	}
+
+	xt = min( xt, 1.0 );
+
+	float sat2   =  2.0 * sat;
+	float satinv =  1.0 - sat;
+	float luminv =  1.0 - lum;
+	float lum2m1 = (2.0 * lum) - 1.0;
+	vec3  ct     = (sat2 * xt) + satinv;
+
+	vec3 rgb;
+	if (lum >= 0.5) { rgb = (luminv * ct) + lum2m1; }
+	else            { rgb =  lum    * ct; }
+
+	return rgb;
+}

shaders/light_common.glsl

@@ -5,6 +5,10 @@ uniform sampler2DArrayShadow shadowmap;
 uniform sampler2D headlightmap;
 
 #include <envmapping.glsl>
+#include <conversion.glsl>
+
+float glossiness = 1.0;
+bool metalic = false;
 
 float length2(vec3 v)
 {
@@ -42,9 +46,6 @@ float calc_shadow()
 #endif
 }
 
-float glossiness = 1.0;
-// [0] - diffuse, [1] - specular
-// do magic here
 vec2 calc_light(vec3 light_dir, vec3 fragnormal)
 {
 	vec3 view_dir = normalize(vec3(0.0f, 0.0f, 0.0f) - f_pos.xyz);
@@ -107,15 +108,27 @@ vec2 calc_headlights(light_s light, vec3 fragnormal)
 	return part * atten * lightintensity;
 }
 
-	bool metalic = false;
+// [0] - diffuse, [1] - specular
-
+// do magic here
 vec3 apply_lights(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float reflectivity, float specularity, float shadowtone)
 {
-	fragcolor *= param[1].x;
+	vec3 basecolor = param[0].rgb;
 
-	vec3 emissioncolor = param[0].rgb * emission;
+	fragcolor *= basecolor;
+
+	vec3 emissioncolor = basecolor * emission;
 	vec3 envcolor = envmap_color(fragnormal);
 
+// yuv path
+	vec3 texturecoloryuv = rgb2yuv(texturecolor);
+	vec3 texturecolorfullv = yuv2rgb(vec3(0.2176, texturecoloryuv.gb));
+// hsl path
+//	vec3 texturecolorhsl = rgb2hsl(texturecolor);
+//	vec3 texturecolorfullv = hsl2rgb(vec3(texturecolorhsl.rg, 0.5));
+
+	vec3 envyuv = rgb2yuv(envcolor);
+	texturecolor = mix(texturecolor, texturecolorfullv, envyuv.r * reflectivity);
+
 	if(lights_count == 0U) 
 		return (fragcolor + emissioncolor + envcolor * reflectivity) * texturecolor;
 
@@ -153,6 +166,7 @@ vec3 apply_lights(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float refl
 	}
 	fragcolor += emissioncolor;
 	vec3 specularcolor = specularamount * lights[0].color;
+
 	if ((param[1].w < 0.0) || (metalic == true))
 	{
 		fragcolor += specularcolor;

shaders/mat_sunlessnormalmap.frag

@@ -32,9 +32,23 @@ uniform sampler2D normalmap;
 
 vec3 apply_lights_sunless(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float reflectivity, float specularity, float shadowtone)
 {
-	vec3 emissioncolor = param[0].rgb * emission;
+	vec3 basecolor = param[0].rgb;
+
+	fragcolor *= basecolor;
+
+	vec3 emissioncolor = basecolor * emission;
 	vec3 envcolor = envmap_color(fragnormal);
 
+// yuv path
+	vec3 texturecoloryuv = rgb2yuv(texturecolor);
+	vec3 texturecolorfullv = yuv2rgb(vec3(0.2176, texturecoloryuv.gb));
+// hsl path
+//	vec3 texturecolorhsl = rgb2hsl(texturecolor);
+//	vec3 texturecolorfullv = hsl2rgb(vec3(texturecolorhsl.rg, 0.5));
+
+	vec3 envyuv = rgb2yuv(envcolor);
+	texturecolor = mix(texturecolor, texturecolorfullv, envyuv.r * reflectivity);
+
 	if(lights_count == 0U) 
 		return (fragcolor + emissioncolor + envcolor * reflectivity) * texturecolor;
 

shaders/mat_sunlessnormalmap_specgloss.frag

@@ -36,9 +36,23 @@ uniform sampler2D specgloss;
 
 vec3 apply_lights_sunless(vec3 fragcolor, vec3 fragnormal, vec3 texturecolor, float reflectivity, float specularity, float shadowtone)
 {
-	vec3 emissioncolor = param[0].rgb * emission;
+	vec3 basecolor = param[0].rgb;
+
+	fragcolor *= basecolor;
+
+	vec3 emissioncolor = basecolor * emission;
 	vec3 envcolor = envmap_color(fragnormal);
 
+// yuv path
+	vec3 texturecoloryuv = rgb2yuv(texturecolor);
+	vec3 texturecolorfullv = yuv2rgb(vec3(0.2176, texturecoloryuv.gb));
+// hsl path
+//	vec3 texturecolorhsl = rgb2hsl(texturecolor);
+//	vec3 texturecolorfullv = hsl2rgb(vec3(texturecolorhsl.rg, 0.5));
+
+	vec3 envyuv = rgb2yuv(envcolor);
+	texturecolor = mix(texturecolor, texturecolorfullv, envyuv.r * reflectivity);
+
 	if(lights_count == 0U) 
 		return (fragcolor + emissioncolor + envcolor * reflectivity) * texturecolor;