git-svn-id: svn://db.shs.com.ru/libs@626 a8b55f48-bf90-11e4-a774-851b48703e85

qglengine/shaders/ds_geom.glsl

@@ -0,0 +1,64 @@
+// vert //
+
+out vec3 geom_normal;
+out mat3 TBN;
+out vec4 object_color;
+
+void main(void) {
+	qgl_MaterialIndex = qgl_Material;
+	qgl_FragTexture = qgl_Texture;
+	gl_Position = qgl_ftransform();
+	
+	mat3 nmat = qgl_getNormalMatrix();
+	geom_normal = normalize(nmat * qgl_Normal);
+	TBN = nmat * mat3(qgl_Tangent, qgl_Bitangent, qgl_Normal);
+	object_color = qgl_ObjectColor;
+}
+
+
+// frag //
+
+in vec3 geom_normal;
+in mat3 TBN;
+in vec4 object_color;
+
+uniform vec2 dt;
+uniform float z_near;
+
+const vec3 luma = vec3(0.299, 0.587, 0.114);
+
+void main(void) {
+	vec2 tc = qgl_FragTexture.xy;
+
+	vec4 diffuse = qgl_materialTexture(QGL_MAP_DIFFUSE, tc, vec4(0)) * qgl_material[qgl_MaterialIndex].color_diffuse * object_color;
+
+	vec3 normal, dn;
+	dn = qgl_materialTexture(QGL_MAP_NORMAL, tc, -vec4(0.5, 0.5, 1., 0.)).xyz;
+	//dn.y = -dn.y;
+	float dn_sl = length(dn);
+	dn = TBN * dn;
+	dn *= dn_sl / (length(dn) + 1E-6);
+	normal = normalize(geom_normal + dn);
+	
+	vec4 specular = qgl_materialTexture(QGL_MAP_SPECULAR, tc, vec4(0)) * qgl_material[qgl_MaterialIndex].color_specular;
+	
+	float roughness = dot(qgl_materialTexture(QGL_MAP_ROUGHNESS, tc, vec4(0)).rgb, luma);
+	roughness = clamp(roughness, 0.0001, 0.9999);
+	
+	float reflectivity = clamp(qgl_material[qgl_MaterialIndex].reflectivity, 0., 1.);
+
+	vec4 emission = qgl_materialTexture(QGL_MAP_EMISSION, tc, vec4(0));
+	emission *= qgl_material[qgl_MaterialIndex].color_emission;
+
+	float height = dot(qgl_materialTexture(QGL_MAP_RELIEF, tc, vec4(0)).rgb, luma);
+
+	qgl_FragData[0] = vec4(diffuse .rgb, roughness   );
+	qgl_FragData[1] = vec4(normal  .xyz, reflectivity);
+	qgl_FragData[2] = vec4(specular.rgb, height      );
+	qgl_FragData[3] = vec4(emission.rgb, 0/*bn.x*/);
+	//qgl_FragData[4] = vec4(speed.xy, bn.yz);
+
+	//ivec2 itc = ivec2(gl_FragCoord.xy);
+	//qgl_FragData[0].rgb = vec3(dot(n,vec3(0,0,1)));
+	//qgl_FragData[0].rgb = diffuse.rgb * dot(n,vec3(0,0,1));
+}

qglengine/shaders/ds_light.glsl

@@ -0,0 +1,144 @@
+// vert //
+
+out vec3 view_dir;
+
+uniform vec4 view_corners[4];
+
+void main(void) {
+	gl_Position = qgl_ftransform();
+	view_dir = view_corners[gl_VertexID].xyz;
+}
+
+
+// frag //
+
+in vec3 view_dir;
+
+uniform vec2 dt;
+uniform float z_near;
+uniform sampler2D tex_0, tex_1, tex_2, tex_3, tex_4;
+uniform sampler2D tex_d;
+uniform int lights_count;
+
+const vec3 luma = vec3(0.299, 0.587, 0.114);
+const float _pe = 2.4e-7;
+
+vec4 pos, lpos, shp;
+vec3 li, si, ldir, halfV, bn, bn2, lwdir;
+//vec3 vds, vds2;
+float shm_diff, shm_spec, dist, NdotL, NdotH, spot, ldist, diff, sdist, shadow;
+
+void calcLight(in int index, in vec3 n, in vec3 v) {
+	lpos = qgl_light_position[index].position;
+	ldir = lpos.xyz - (pos.xyz * lpos.w);
+	ldist = length(ldir);
+	ldir = normalize(ldir);
+	halfV = normalize(ldir + v);
+	NdotL = max(dot(n, ldir), 1E-6);
+	NdotH = max(dot(n, halfV), 1E-6);
+	spot = step(1.01E-6, NdotL) * qgl_light_parameter[index].intensity;
+	/*if (qgl_Light[index].endAngle <= 90.) {
+		float scos = max(dot(-ldir, qgl_Light[index].direction.xyz), 0.);
+		spot *= scos * step(qgl_Light[index].endAngleCos, scos);
+		spot *= smoothstep(qgl_Light[index].endAngleCos, qgl_Light[index].startAngleCos, scos);
+		//lwdir = mat3(mat_viewi) * qgl_Light[index].direction.xyz;
+		//bn = normalize(cross(lwdir, vec3(1, 0, 0)));
+		//bn2 = normalize(cross(lwdir, bn));
+		float ds = ldist/200.;//max(abs(sdist) / 5000, 0.02);
+		//spot *= clamp(1. - sdist, 0, 1);
+		vds = ds * bn.xyz;
+		vds2 = ds * bn2.xyz;
+		float shadow  = getShadow(index, pos.xyz, vec3(0)) * 3.;
+			  shadow += getShadow(index, pos.xyz,   vds                    ) * 2.;
+			  shadow += getShadow(index, pos.xyz, - vds                    ) * 2.;
+			  shadow += getShadow(index, pos.xyz,             - vds2       ) * 2.;
+			  shadow += getShadow(index, pos.xyz,             + vds2       ) * 2.;
+			  //shadow += getShadow(index, pos.xyz,   vds       - vds2       ) * 1.5;
+			  //shadow += getShadow(index, pos.xyz,   vds       + vds2       ) * 1.5;
+			  //shadow += getShadow(index, pos.xyz, - vds       - vds2       ) * 1.5;
+			  //shadow += getShadow(index, pos.xyz, - vds       + vds2       ) * 1.5;
+			  //shadow += getShadow(index, pos.xyz,   vds + vds              );
+			  //shadow += getShadow(index, pos.xyz, - vds - vds              );
+			  //shadow += getShadow(index, pos.xyz,             - vds2 - vds2);
+			  //shadow += getShadow(index, pos.xyz,             + vds2 + vds2);
+			  //shadow += getShadow(index, pos.xyz,   vds + vds - vds2       );
+			  //shadow += getShadow(index, pos.xyz, - vds - vds - vds2       );
+			  //shadow += getShadow(index, pos.xyz,   vds + vds + vds2       );
+			  //shadow += getShadow(index, pos.xyz, - vds - vds + vds2       );
+			  //shadow += getShadow(index, pos.xyz,   vds       - vds2 - vds2);
+			  //shadow += getShadow(index, pos.xyz,   vds       + vds2 + vds2);
+			  //shadow += getShadow(index, pos.xyz, - vds       - vds2 - vds2);
+			  //shadow += getShadow(index, pos.xyz, - vds       + vds2 + vds2);
+			  //shadow += shadow += getShadow(index, pos.xyz, vds+vds2)*10;
+		spot *= mix(1., shadow / 11., shadow_on);
+	}*/
+	//spot /= (qgl_Light[index].constantAttenuation + ldist * (qgl_Light[index].linearAttenuation + ldist * qgl_Light[index].quadraticAttenuation));
+	//li += spot * gl_LightSource[index].diffuse.rgb * light_diffuse(0, ldir, n);
+	//si += spot * qgl_Light[index].color.rgb * shm_diff * light_specular(0, ldir, n, halfV, v, sh_pow);
+	float NdotLs = NdotL*NdotL;
+	float NdotHs = NdotH*NdotH;
+	
+	float ndlc = (1. - NdotLs) / NdotLs;
+	float der = NdotLs * (shm_diff + ndlc);
+	diff = 2. / (1. + sqrt(1. + (1. - shm_diff) * ndlc));
+	li += spot * diff * qgl_light_parameter[index].color.rgb;// * light_diffuse(0, ldir, n);
+	
+	ndlc = (1. - NdotHs) / NdotHs;
+	der = NdotHs * (shm_spec + ndlc);
+	si += spot * (shm_spec / (der*der) / 3.1416) * qgl_light_parameter[index].color.rgb;
+}
+
+void main(void) {
+	ivec2 tc = ivec2(gl_FragCoord.xy);
+	float z = texelFetch(tex_d, tc, 0).r;
+	if (z == 1.) {
+		qgl_FragColor = vec4(0);
+		return;
+	}
+	vec4 v0 = texelFetch(tex_0, tc, 0),
+		 v1 = texelFetch(tex_1, tc, 0),
+		 v2 = texelFetch(tex_2, tc, 0),
+		 v3 = texelFetch(tex_3, tc, 0),
+		 v4 = texelFetch(tex_4, tc, 0);
+
+	z = z + z - 1;
+	z = ((_pe - 2.) * z_near) / (z + _pe - 1.); // infinite depth
+
+	pos.w = 1;
+	pos.xyz = view_dir * z;
+	//pos.z = -pos.z;
+	vec3 v = normalize(-pos.xyz);
+
+	//vec2 sp = gl_FragCoord.xy * dt * 2 - vec2(1, 1);
+	vec3 diffuse       = v0.rgb;
+	vec3 normal        = v1.xyz;
+	vec3 specular      = v2.rgb;
+	vec3 emission      = v3.rgb;
+	float roughness    = v0.w;
+	float reflectivity = v1.w;
+	float height       = v2.w;
+	//bn = normalize(vec3(v3.w, v4.zw));
+	//bn2 = normalize(cross(n, bn));
+
+	shm_diff = max(roughness, 0.00001);
+	roughness = roughness*roughness*roughness;
+	shm_spec = max(roughness, 0.00001);
+	//sh_pow = 1. / max(roughness, 0.00001);
+	li = vec3(0.);//qgl_AmbientLight.color.rgb * qgl_AmbientLight.intensity;
+	si = vec3(0.);
+	for (int i = 0; i < lights_count; ++i)
+		calcLight(i, normal, v);
+	//	calcLight(0, n, v, v2);
+
+	//calcLight(0, normal, v);
+	
+	qgl_FragColor.rgb = max(vec3(0), li * diffuse + si * specular + emission);
+	qgl_FragColor.a = 1;
+
+
+	//qgl_FragData[4] = vec4(speed.xy, bn.yz);
+
+	//ivec2 itc = ivec2(gl_FragCoord.xy);
+	//qgl_FragData[0].rgb = vec3(dot(n,vec3(0,0,1)));
+	//qgl_FragData[0].rgb = diffuse.rgb * dot(n,vec3(0,0,1));
+}

qglengine/shaders/selection.glsl

@@ -0,0 +1,19 @@
+// vert //
+
+flat out uint id, select;
+
+void main(void) {
+	id = qgl_ObjectID;
+	select = qgl_ObjectSelected;
+	gl_Position = qgl_ftransform();
+}
+
+
+// frag //
+
+flat in uint id, select;
+
+void main(void) {
+	qgl_FragData[0] = unpackUnorm4x8(id);
+	qgl_FragData[1] = vec4(select);
+}

qglengine/shaders/selection_apply.glsl

@@ -0,0 +1,22 @@
+// vert //
+
+void main(void) {
+	gl_Position = qgl_ftransform();
+}
+
+
+// frag //
+
+uniform sampler2D fb_out, fb_hover, fb_select;
+
+void main(void) {
+	ivec2 tc = ivec2(gl_FragCoord.xy);
+	vec4 src = texelFetch(fb_out   , tc, 0);
+	vec4 hov = texelFetch(fb_hover , tc, 0);
+	vec4 sel = texelFetch(fb_select, tc, 0);
+	src.rgb = mix(src.rgb, sel.rgb, sel.a);
+	src.rgb = mix(src.rgb, hov.rgb, hov.a * 0.667f);
+	//src.rgb = src.rgb + (sel.rgb*sel.a);
+	qgl_FragData[0] = src;
+	//qgl_FragData[0] = vec4(sel.a);
+}

qglengine/shaders/selection_frame.glsl

@@ -0,0 +1,24 @@
+// vert //
+
+void main(void) {
+	qgl_FragTexture = qgl_Texture;
+	gl_Position = qgl_ftransform();
+}
+
+
+// frag //
+
+uniform vec2 dt, size;
+uniform float thickness;
+
+void main(void) {
+	vec2 frame_size = size / dt;
+	vec2 pix_pos = qgl_FragTexture * frame_size;
+	vec2 frame = vec2(1) + step(pix_pos, vec2(thickness)) - step(pix_pos, frame_size - vec2(thickness));
+	vec2 line = frame * step(0.5, fract(pix_pos.yx / thickness / 4.));
+	float fc = max(frame.x, frame.y);
+	float fl = max(line.x , line.y );
+	fl = mix(1, fl, fc);
+	qgl_FragColor = vec4(vec3(fl), fc * 0.8 + 0.2);
+	//qgl_FragColor = vec4(vec3(fl,0),1);
+}

qglengine/shaders/selection_halo.glsl

@@ -0,0 +1,44 @@
+// vert //
+
+void main(void) {
+	gl_Position = qgl_ftransform();
+}
+
+
+// frag //
+
+uniform sampler2D fb_hover, fb_selection;
+uniform vec4 hover_id, hover_color, selection_color;
+uniform float hover_fill, selection_fill, has_hover, has_selection;
+ivec2 tc;
+
+vec4 diffVector(in sampler2D map, in vec4 id) {
+	vec4 ds0 = abs(texelFetchOffset(map, tc, 0, ivec2(-1, 0)) - id);
+	vec4 ds1 = abs(texelFetchOffset(map, tc, 0, ivec2( 1, 0)) - id);
+	vec4 ds2 = abs(texelFetchOffset(map, tc, 0, ivec2(0, -1)) - id);
+	vec4 ds3 = abs(texelFetchOffset(map, tc, 0, ivec2(0,  1)) - id);
+	return vec4(dot(ds0, vec4(1)), dot(ds1, vec4(1)), dot(ds2, vec4(1)), dot(ds3, vec4(1)));
+}
+vec2 diffPair(in vec4 dv) {
+	const float _c = 64;
+	return vec2(step(1e-6, dot(dv, vec4(1))),
+				step(1e-3, (dv.r * _c) * (dv.g * _c) * (dv.b * _c) * (dv.a * _c)));
+}
+float diffAlpha(in vec2 dp, in float fill) {
+	return mix(dp.x - dp.y, dp.x - dp.y - dp.y + 1, fill);
+}
+
+void main(void) {
+	tc = ivec2(gl_FragCoord.xy);
+	float hh = clamp(dot(hover_id, vec4(1)), 0, 1);
+	
+	vec2 dp = diffPair(diffVector(fb_hover, hover_id));
+	float v = diffAlpha(dp, hover_fill);
+	qgl_FragData[2] = has_hover*hh*v*vec4(hover_color.bgr, hover_color.a);
+	
+	dp = diffPair(diffVector(fb_selection, vec4(1)));
+	v = diffAlpha(dp, selection_fill);
+	qgl_FragData[3] = has_selection*v*vec4(selection_color.bgr, selection_color.a);
+	
+	//qgl_FragData[3] = vec4(has_selection);
+}

qglengine/shaders/service.glsl

@@ -0,0 +1,25 @@
+// vert //
+
+out vec3 geom_normal;
+out vec4 object_color;
+
+void main(void) {
+	qgl_FragTexture = qgl_Texture;
+	gl_Position = qgl_ftransform();
+	
+	mat3 nmat = qgl_getNormalMatrix();
+	geom_normal = normalize(nmat * qgl_Normal);
+	object_color = qgl_ObjectColor;
+}
+
+
+// frag //
+
+in vec3 geom_normal;
+in vec4 object_color;
+
+void main(void) {
+	vec3 normal = normalize(geom_normal);
+	float l = max(0, dot(normal, vec3(0,0,1)));
+	qgl_FragColor = object_color * (l * 0.6 + 0.4);
+}