3D Normal Shader using 5 lights and a texture atlas - working I think

Author

Message

AJCodes

9

Years of Service

User Offline

Joined: 6th Jan 2015

Location:

Posted: 13th Jan 2015 05:13

Link

OK...I'm really new to shaders and I've been working on this for about a week.

The goal: a shader that will handle up to 5 lights, normal mapping, passing the object texture offset (numbers across and down, not the actual offsets) in R and G of the object color, passing the ambient light level in the B parameter, and the object's alpha in A.

I think I've got it, but I'd love someone who knows this stuff to take a look.

Here's the vertex shader:

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;
attribute vec3 tangent;
attribute vec3 binormal;

varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;
varying vec3 vLightP;
varying vec3 vLightP2;
varying vec3 vLightP3;
varying vec3 vLightP4;
varying vec3 vLightP5;

uniform vec4 uvBounds0;

uniform mat4 agk_World;
uniform mat4 agk_ViewProj;
uniform mat3 agk_WorldNormal;
uniform vec3 vPLightPos;
uniform vec3 vPLightPos2;
uniform vec3 vPLightPos3;
uniform vec3 vPLightPos4;
uniform vec3 vPLightPos5;
	
void main()
{ 
	vec4 pos = agk_World * vec4(position,1);
	gl_Position = agk_ViewProj * pos;
	vec3 norm = agk_WorldNormal * normal;
	posVarying = pos.xyz;
	normalVarying = norm;
	uvVarying = uv * uvBounds0.xy + uvBounds0.zw;
	mat3 TBNMatrix = mat3(tangent, binormal, norm);   //changed normal to norm
	vLightP = vPLightPos.xyz - position;
	vLightP *= TBNMatrix;
	vLightP2 = vPLightPos2.xyz - position;
	vLightP2 *= TBNMatrix;
	vLightP3 = vPLightPos3.xyz - position;
	vLightP3 *= TBNMatrix;
	vLightP4 = vPLightPos4.xyz - position;
	vLightP4 *= TBNMatrix;
	vLightP5 = vPLightPos5.xyz - position;
	vLightP5 *= TBNMatrix;
}

+ Code Snippet

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;
attribute vec3 tangent;
attribute vec3 binormal;

varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;
varying vec3 vLightP;
varying vec3 vLightP2;
varying vec3 vLightP3;
varying vec3 vLightP4;
varying vec3 vLightP5;

uniform vec4 uvBounds0;

uniform mat4 agk_World;
uniform mat4 agk_ViewProj;
uniform mat3 agk_WorldNormal;
uniform vec3 vPLightPos;
uniform vec3 vPLightPos2;
uniform vec3 vPLightPos3;
uniform vec3 vPLightPos4;
uniform vec3 vPLightPos5;
	
void main()
{ 
	vec4 pos = agk_World * vec4(position,1);
	gl_Position = agk_ViewProj * pos;
	vec3 norm = agk_WorldNormal * normal;
	posVarying = pos.xyz;
	normalVarying = norm;
	uvVarying = uv * uvBounds0.xy + uvBounds0.zw;
	mat3 TBNMatrix = mat3(tangent, binormal, norm);   //changed normal to norm
	vLightP = vPLightPos.xyz - position;
	vLightP *= TBNMatrix;
	vLightP2 = vPLightPos2.xyz - position;
	vLightP2 *= TBNMatrix;
	vLightP3 = vPLightPos3.xyz - position;
	vLightP3 *= TBNMatrix;
	vLightP4 = vPLightPos4.xyz - position;
	vLightP4 *= TBNMatrix;
	vLightP5 = vPLightPos5.xyz - position;
	vLightP5 *= TBNMatrix;
}

and here's the pixel shader:

uniform sampler2D texture0;
uniform sampler2D texture1;	
varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

varying vec3 vLightP;
uniform vec4 vPLightColor;
varying vec3 vLightP2;
uniform vec4 vPLightColor2;
varying vec3 vLightP3;
uniform vec4 vPLightColor3;
varying vec3 vLightP4;
uniform vec4 vPLightColor4;
varying vec3 vLightP5;
uniform vec4 vPLightColor5;

uniform vec4 Resolution;
uniform float texSize;
uniform float subtexSize;
uniform vec4 agk_ObjColor;			//r = tex x, g = tex y, b = brightness, a = alpha

vec4 hsv_to_rgb(float h, float s, float v, float a)
{
	float c = v * s;
	h = mod((h * 6.0), 6.0);
	float x = c * (1.0 - abs(mod(h, 2.0) - 1.0));
	vec4 color;
	 
	if (0.0 <= h && h < 1.0) {
		color = vec4(c, x, 0.0, a);
	} else if (1.0 <= h && h < 2.0) {
		color = vec4(x, c, 0.0, a);
		} else if (2.0 <= h && h < 3.0) {
			color = vec4(0.0, c, x, a);
			} else if (3.0 <= h && h < 4.0) {
				color = vec4(0.0, x, c, a);
				} else if (4.0 <= h && h < 5.0) {
					color = vec4(x, 0.0, c, a);
					} else if (5.0 <= h && h < 6.0) {
						color = vec4(c, 0.0, x, a);
						} else {
							color = vec4(0.0, 0.0, 0.0, a);
							}
	 
	color.rgb += v - c;
	 
	return color;
}

vec3 light(vec3 vTLightPos,vec4 vTLightColor,vec2 uvOut)
{

vec3 normal = texture2D(texture1, uvOut.xy).rgb;
	
    vec3 LDIR=normalize(vTLightPos);
	
	normal = normal * 2.0 - 1.0;
	vec3 NDIR=normalize(normal);
	
    float intensity = dot(normalize(vTLightPos),normal);
	
    intensity = clamp(intensity,0.0,1.0);
	
	return vTLightColor.rgb * max(dot(NDIR, LDIR), 0.0) * intensity;
}

void main()
{
	vec2 uvOut = uvVarying * (subtexSize-1.0)/(texSize-1.0);	//scale the existing UVs to texSize width and height
	uvOut.x = uvOut.x + 255.0*agk_ObjColor.r * (subtexSize/texSize);
	uvOut.y = uvOut.y + 255.0*agk_ObjColor.g * (subtexSize/texSize);
    
	vec4 diffuse = texture2D(texture0, uvOut.xy);
	vec3 PLight = vec3(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b) + light(vLightP, vPLightColor, uvOut) + light(vLightP2,vPLightColor2,uvOut) + light(vLightP3,vPLightColor3,uvOut) + light(vLightP4,vPLightColor4,uvOut) + light(vLightP5,vPLightColor5,uvOut);
	gl_FragColor =  diffuse * vec4(PLight, agk_ObjColor.a);
}

+ Code Snippet

uniform sampler2D texture0;
uniform sampler2D texture1;	
varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

varying vec3 vLightP;
uniform vec4 vPLightColor;
varying vec3 vLightP2;
uniform vec4 vPLightColor2;
varying vec3 vLightP3;
uniform vec4 vPLightColor3;
varying vec3 vLightP4;
uniform vec4 vPLightColor4;
varying vec3 vLightP5;
uniform vec4 vPLightColor5;

uniform vec4 Resolution;
uniform float texSize;
uniform float subtexSize;
uniform vec4 agk_ObjColor;			//r = tex x, g = tex y, b = brightness, a = alpha


vec4 hsv_to_rgb(float h, float s, float v, float a)
{
	float c = v * s;
	h = mod((h * 6.0), 6.0);
	float x = c * (1.0 - abs(mod(h, 2.0) - 1.0));
	vec4 color;
	 
	if (0.0 <= h && h < 1.0) {
		color = vec4(c, x, 0.0, a);
	} else if (1.0 <= h && h < 2.0) {
		color = vec4(x, c, 0.0, a);
		} else if (2.0 <= h && h < 3.0) {
			color = vec4(0.0, c, x, a);
			} else if (3.0 <= h && h < 4.0) {
				color = vec4(0.0, x, c, a);
				} else if (4.0 <= h && h < 5.0) {
					color = vec4(x, 0.0, c, a);
					} else if (5.0 <= h && h < 6.0) {
						color = vec4(c, 0.0, x, a);
						} else {
							color = vec4(0.0, 0.0, 0.0, a);
							}
	 
	color.rgb += v - c;
	 
	return color;
} 


vec3 light(vec3 vTLightPos,vec4 vTLightColor,vec2 uvOut)
{

	vec3 normal = texture2D(texture1, uvOut.xy).rgb;
	
    vec3 LDIR=normalize(vTLightPos);
	
	normal = normal * 2.0 - 1.0;
	vec3 NDIR=normalize(normal);
	
    float intensity = dot(normalize(vTLightPos),normal);
	
    intensity = clamp(intensity,0.0,1.0);
	
	return vTLightColor.rgb * max(dot(NDIR, LDIR), 0.0) * intensity;
}

void main()
{
	vec2 uvOut = uvVarying * (subtexSize-1.0)/(texSize-1.0);	//scale the existing UVs to texSize width and height
	uvOut.x = uvOut.x + 255.0*agk_ObjColor.r * (subtexSize/texSize);
	uvOut.y = uvOut.y + 255.0*agk_ObjColor.g * (subtexSize/texSize);
    
	vec4 diffuse = texture2D(texture0, uvOut.xy);
	vec3 PLight = vec3(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b) + light(vLightP, vPLightColor, uvOut) + light(vLightP2,vPLightColor2,uvOut) + light(vLightP3,vPLightColor3,uvOut) + light(vLightP4,vPLightColor4,uvOut) + light(vLightP5,vPLightColor5,uvOut);
	gl_FragColor =  diffuse * vec4(PLight, agk_ObjColor.a);
}

Cobbled together and modified from about 1,000 examples here and on the internet. I also use a few "undocumented" things from agk...I just assumed that there'd be a tangent and binormal vector available...and my example seems to indicate that they do exist but I haven't seen any documentation.

I know the attenuation is cheap, but I've been focused hard on correct normal mapping and the 5 light problem.

Here's some agk code to set the shader up:

+ Code Snippet

// the size of each item in the texture atlas
SetShaderConstantByName(shader1,"subtexSize",128,0,0,0)
// the size of the SQUARE texture atlas
SetShaderConstantByName(shader1,"texSize",2048,0,0,0)
// window width and height
SetShaderConstantByName(shader1,"Resolution",width,height,0,0)
// one light position and color
SetShaderConstantByName(shader1,"vPLightPos", lightx, 3,lightz,0)
SetShaderConstantByName(shader1,"vPLightColor",0.8,0.8,0.8,1.0)
// 2nd light position and color
SetShaderConstantByName(shader1,"vPLightPos2", 4, 0,0,0)
SetShaderConstantByName(shader1,"vPLightColor2",0.8,0.0,0.0,0.3)

Oh...and the hsv to rgb code is there as, after I get some validation that this really is normal mapping correctly, I'll be using the object R channel for the texture number and deriving the offsets from that while converting the G to the H part of HSV so I can do some really basic object coloring.

Would appreciate it if anyone that really knows this stuff could check it out to validate that it's really doing normal mapping. And...any comment from the AppGameKit devs as to parameters available to shaders would be great too!

Born. Currently living.

Back to top

Profile PM

AJCodes

9

Years of Service

User Offline

Joined: 6th Jan 2015

Location:

Posted: 13th Jan 2015 07:06

Link

More tests...normal mapping is not working. Apparently I'm not getting those vectors and I just happened onto a perspective that worked during development. Bleh.

Born. Currently living.

Back to top

Profile PM

CJB

Valued Member

20

Years of Service

User Offline

Joined: 10th Feb 2004

Location: Essex, UK

Posted: 13th Jan 2015 10:10

Link

Did you see Janbo's normal mapping thread over in the Showcase board?

http://forum.thegamecreators.com/?m=forum_view&t=212611&b=48

Some fantastic results there. Getting it to work with atlas textures would be sweet! I'll be keeping an eye on this thread!

V2 T1 (Mostly)
Uzmadesign

Back to top

Profile PM Email Website

AJCodes

9

Years of Service

User Offline

Joined: 6th Jan 2015

Location:

Posted: 13th Jan 2015 15:41

Link

Yep...that's for a sprite shader - 2D. Sprite shaders can do normal (bump) mapping with a fixed normal vector(one, facing out to the viewer) which simplifies the handling of the normal texture.

I'm working now on approximating the tangent and binormal needed to do this in 3D using concepts from http://www.geeks3d.com/20130122/normal-mapping-without-precomputed-tangent-space-vectors/.

Now...the method I use to do the texture atlas can be used in either...it's pretty straightforward.

Born. Currently living.

Back to top

Profile PM

AJCodes

9

Years of Service

User Offline

Joined: 6th Jan 2015

Location:

Posted: 18th Jan 2015 05:03

Link

OK...an update. Normal mapping WITHOUT vertex tangents or binormals (bitangents).

One point light. Texture atlas. Normal (bump) mapping.

The base texture goes into texture 0, the normal texture into texture 1. I wrote some code to construct the atlases from individual textures I made in Substance Designer. Remember to set GL normals!

The shader assumes that your atlas (base and normal map) is 16x16. The agk code snippet shows the setup and use of the shader.

Vertex shader:

+ Code Snippet

// vertex shader
attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

uniform vec4 uvBounds0;

uniform mat4 agk_World;
uniform mat4 agk_ViewProj;
uniform mat4 agk_View;
uniform mat3 agk_WorldNormal;
	
void main()
{
	vec4 pos = agk_World * vec4(position,1);
	gl_Position = agk_ViewProj * pos;
	vec3 norm = agk_WorldNormal * normal;
	posVarying = pos.xyz;
	normalVarying = norm;
	uvVarying = uv * uvBounds0.xy + uvBounds0.zw;
}

Pixel shader:

uniform float texSize;
uniform float subtexSize;
uniform vec4 agk_ObjColor;

uniform sampler2D texture0;
uniform sampler2D texture1;

uniform vec3 camLoc;		//camera location
	
varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

uniform vec4 vLightPos;
uniform vec4 vLightColor;

// cotangent and perturb functions adapted from:
// http://www.thetenthplanet.de/archives/1180

mat3 cotangent_frame( vec3 N, vec3 p, vec2 uv )
{
    // get edge vectors of the pixel triangle
    vec3 dp1 = dFdx( p );
    vec3 dp2 = dFdy( p );
    vec2 duv1 = dFdx( uv );
    vec2 duv2 = dFdy( uv );
 
    // solve the linear system
    vec3 dp2perp = cross( dp2, N );
    vec3 dp1perp = cross( N, dp1 );
    vec3 T = dp2perp * duv1.x + dp1perp * duv2.x;
    vec3 B = dp2perp * duv1.y + dp1perp * duv2.y;
 
    // construct a scale-invariant frame 
    float invmax = inversesqrt( max( dot(T,T), dot(B,B) ) );
    return mat3( T * invmax, B * invmax, N );
}

vec3 perturb_normal( vec3 N, vec3 V, vec2 texcoord )
{
    // assume N, the interpolated vertex normal and 
    // V, the view vector (vertex to eye)
    vec3 map = texture2D( texture1, texcoord ).xyz;
	map = (2.0 * map) - 1.0;
    mat3 TBN = cotangent_frame( N, -V, texcoord );
    return normalize( TBN * map );
}

void main()
{ 
	float ux = mod(255.0*agk_ObjColor.r,16.0)*(subtexSize/texSize);
	float uy = floor(255.0*agk_ObjColor.r/16.0)*(subtexSize/texSize);
	
	vec2 uvOut = uvVarying * (subtexSize-1.0)/(texSize-1.0);	//scale the existing UVs to texSize width and height
	uvOut.x = uvOut.x + ux;
	uvOut.y = uvOut.y + uy;
	
	vec3 N = normalize( normalVarying );
	vec3 g_viewvector = camLoc.xyz - posVarying;
	N = perturb_normal( N, g_viewvector, uvOut );
	
	vec3 dir = vLightPos.xyz - posVarying;
	float dist = length(dir);
	dist = vLightColor.a / (dist*dist);
	vec4 ambient = vec4(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b, 0);
	
	vec3 norm = normalize(N).xyz;

float intensity = dist * dot(dir,norm);	
	vec3 color = ambient.rgb * vLightColor.rgb * intensity; // * atten; 
	gl_FragColor = texture2D(texture0, uvOut) * vec4(color,agk_ObjColor.a);
}

+ Code Snippet

uniform float texSize;
uniform float subtexSize;
uniform vec4 agk_ObjColor;

uniform sampler2D texture0;
uniform sampler2D texture1;

uniform vec3 camLoc;		//camera location
	
varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

uniform vec4 vLightPos;
uniform vec4 vLightColor;

// cotangent and perturb functions adapted from:
// http://www.thetenthplanet.de/archives/1180

mat3 cotangent_frame( vec3 N, vec3 p, vec2 uv )
{
    // get edge vectors of the pixel triangle
    vec3 dp1 = dFdx( p );
    vec3 dp2 = dFdy( p );
    vec2 duv1 = dFdx( uv );
    vec2 duv2 = dFdy( uv );
 
    // solve the linear system
    vec3 dp2perp = cross( dp2, N );
    vec3 dp1perp = cross( N, dp1 );
    vec3 T = dp2perp * duv1.x + dp1perp * duv2.x;
    vec3 B = dp2perp * duv1.y + dp1perp * duv2.y;
 
    // construct a scale-invariant frame 
    float invmax = inversesqrt( max( dot(T,T), dot(B,B) ) );
    return mat3( T * invmax, B * invmax, N );
}

vec3 perturb_normal( vec3 N, vec3 V, vec2 texcoord )
{
    // assume N, the interpolated vertex normal and 
    // V, the view vector (vertex to eye)
    vec3 map = texture2D( texture1, texcoord ).xyz;
	map = (2.0 * map) - 1.0;
    mat3 TBN = cotangent_frame( N, -V, texcoord );
    return normalize( TBN * map );
}



void main()
{ 
	float ux = mod(255.0*agk_ObjColor.r,16.0)*(subtexSize/texSize);
	float uy = floor(255.0*agk_ObjColor.r/16.0)*(subtexSize/texSize);
	
	vec2 uvOut = uvVarying * (subtexSize-1.0)/(texSize-1.0);	//scale the existing UVs to texSize width and height
	uvOut.x = uvOut.x + ux;
	uvOut.y = uvOut.y + uy;
	
	vec3 N = normalize( normalVarying );
	vec3 g_viewvector = camLoc.xyz - posVarying;
	N = perturb_normal( N, g_viewvector, uvOut );
	
	vec3 dir = vLightPos.xyz - posVarying;
	float dist = length(dir);
	dist = vLightColor.a / (dist*dist);
	vec4 ambient = vec4(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b, 0);
	
	vec3 norm = normalize(N).xyz;

	float intensity = dist * dot(dir,norm);	
	vec3 color = ambient.rgb * vLightColor.rgb * intensity; // * atten; 
	gl_FragColor = texture2D(texture0, uvOut) * vec4(color,agk_ObjColor.a);
}

And some sample setup code:

+ Code Snippet

    // each subtexture is 128x128
    SetShaderConstantByName(shader1,"subtexSize",128,0,0,0)
    // the whole texture is 2048x2048
    SetShaderConstantByName(shader1,"texSize",2048,0,0,0)
    // pass the light position in world coords
    SetShaderConstantByName(shader1, "vLightPos",px, py + 2.0, pz ,15.5)
    // pass the light color - rgb. a is the strenght
    SetShaderConstantByName(shader1,"vLightColor",200.0/255.0, 200.0/255.0, 200.0/255.0, 5)
    // pass the camera position in world coords
    SetShaderConstantByName(shader1, "camLoc",GetCameraX(1), GetCameraY(1), GetCameraZ(1),0)

    // and for each object:
    // pass the subtexture number in red (0 to 255)
    // green is currently unused...soon to be part of HSV calc
    // blue is the ambient strength
    // alpha is the object alpha - remember if this is less than 255
    // to set the object transparency to true also
    SetObjectColor(objNum,subtextureNum,0,ambientStrength, objAlpha)

There's plenty of room to improve attenuation, etc., but compared to getting normal mapping working that's pretty simple.

Enjoy.

Born. Currently living.

Back to top

Profile PM

janbo

16

Years of Service

User Offline

Joined: 10th Nov 2008

Location: Germany

Posted: 19th Jan 2015 18:38 Edited at: 19th Jan 2015 18:44

Link

Hi,

Good job!

I think you had inverted normals (Depends on the normal map u used) but I fixed it for me... aaand added specular highlights.

Fragment Shader

uniform float texSize;
uniform float subtexSize;
uniform vec4 agk_ObjColor;

uniform sampler2D texture0;
uniform sampler2D texture1;

uniform vec3 camLoc;		//camera location
	
varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

uniform vec4 vLightPos;
uniform vec4 vLightColor;

// cotangent and perturb functions adapted from:
// http://www.thetenthplanet.de/archives/1180

mat3 cotangent_frame( vec3 N, vec3 p, vec2 uv )
{
    // get edge vectors of the pixel triangle
    vec3 dp1 = dFdx( p );
    vec3 dp2 = dFdy( p );
    vec2 duv1 = dFdx( uv );
    vec2 duv2 = dFdy( uv );
 
    // solve the linear system
    vec3 dp2perp = cross( dp2, N );
    vec3 dp1perp = cross( N, dp1 );
    vec3 T = dp2perp * duv1.x + dp1perp * duv2.x;
    vec3 B = dp2perp * duv1.y + dp1perp * duv2.y;
 
    // construct a scale-invariant frame 
    float invmax = inversesqrt( max( dot(T,T), dot(B,B) ) );
    return mat3( T * invmax, B * invmax, N );
}

vec3 perturb_normal( vec3 N, vec3 V, vec2 texcoord )
{
    // assume N, the interpolated vertex normal and 
    // V, the view vector (vertex to eye)
    vec3 map = texture2D( texture1, texcoord ).xyz;
	map = (2.0 * map) - 1.0;
    mat3 TBN = cotangent_frame( N, -V, texcoord );
    return normalize( TBN * map );
}

void main()
{ 
	float ux = mod(255.0*agk_ObjColor.r,16.0)*(subtexSize/texSize);
	float uy = floor(255.0*agk_ObjColor.r/16.0)*(subtexSize/texSize);
	
	vec2 uvOut = uvVarying * (subtexSize-1.0)/(texSize-1.0);	//scale the existing UVs to texSize width and height
	uvOut.x = uvOut.x + ux;
	uvOut.y = uvOut.y + uy;
	
	vec3 N = normalize( normalVarying );
	vec3 g_viewvector = posVarying - camLoc.xyz;
	N = perturb_normal( N, g_viewvector, uvOut );
	
	
	/*
	vec3 dir = vLightPos.xyz - posVarying;
	float dist = length(dir);
	dist = vLightColor.a / (dist*dist);
	vec4 ambient = vec4(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b, 0);
	
	vec3 norm = normalize(N).xyz;

float intensity = dist * dot(dir,norm);	
	vec3 color = ambient.rgb * vLightColor.rgb * intensity; // * atten; 
	gl_FragColor = texture2D(texture0, uvOut) * vec4(color,agk_ObjColor.a);
	*/
	
	vec3 dir = vLightPos.xyz - posVarying;
	float dist = length(dir);
	dist = vLightColor.a / (dist*dist);
	vec4 ambient = vec4(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b, 0);

float intensity = dist * dot(dir,N);	
	
	vec3 diffuseColor = vec3(ambient.rgb);
	vec3 specularColor = vec3(0.0);
	
	vec3 V = normalize(camLoc.xyz - posVarying);
	vec3 L = normalize(vLightPos.xyz - posVarying);
	vec3 H = normalize(V + L);
	
	diffuseColor += vLightColor.a * texture2D(texture0, uvOut).rgb * max(0.0, dot(N, L));
	specularColor += vLightColor.a * pow(max(0.0, dot(N, H)), 40.0);
	
	gl_FragColor = vec4(intensity * vLightColor.rgb * diffuseColor + specularColor, 1.0);
	
}

+ Code Snippet

uniform float texSize;
uniform float subtexSize;
uniform vec4 agk_ObjColor;

uniform sampler2D texture0;
uniform sampler2D texture1;

uniform vec3 camLoc;		//camera location
	
varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;

uniform vec4 vLightPos;
uniform vec4 vLightColor;

// cotangent and perturb functions adapted from:
// http://www.thetenthplanet.de/archives/1180

mat3 cotangent_frame( vec3 N, vec3 p, vec2 uv )
{
    // get edge vectors of the pixel triangle
    vec3 dp1 = dFdx( p );
    vec3 dp2 = dFdy( p );
    vec2 duv1 = dFdx( uv );
    vec2 duv2 = dFdy( uv );
 
    // solve the linear system
    vec3 dp2perp = cross( dp2, N );
    vec3 dp1perp = cross( N, dp1 );
    vec3 T = dp2perp * duv1.x + dp1perp * duv2.x;
    vec3 B = dp2perp * duv1.y + dp1perp * duv2.y;
 
    // construct a scale-invariant frame 
    float invmax = inversesqrt( max( dot(T,T), dot(B,B) ) );
    return mat3( T * invmax, B * invmax, N );
}

vec3 perturb_normal( vec3 N, vec3 V, vec2 texcoord )
{
    // assume N, the interpolated vertex normal and 
    // V, the view vector (vertex to eye)
    vec3 map = texture2D( texture1, texcoord ).xyz;
	map = (2.0 * map) - 1.0;
    mat3 TBN = cotangent_frame( N, -V, texcoord );
    return normalize( TBN * map );
}


void main()
{ 
	float ux = mod(255.0*agk_ObjColor.r,16.0)*(subtexSize/texSize);
	float uy = floor(255.0*agk_ObjColor.r/16.0)*(subtexSize/texSize);
	
	vec2 uvOut = uvVarying * (subtexSize-1.0)/(texSize-1.0);	//scale the existing UVs to texSize width and height
	uvOut.x = uvOut.x + ux;
	uvOut.y = uvOut.y + uy;
	
	vec3 N = normalize( normalVarying );
	vec3 g_viewvector = posVarying - camLoc.xyz;
	N = perturb_normal( N, g_viewvector, uvOut );
	
	
	/*
	vec3 dir = vLightPos.xyz - posVarying;
	float dist = length(dir);
	dist = vLightColor.a / (dist*dist);
	vec4 ambient = vec4(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b, 0);
	
	vec3 norm = normalize(N).xyz;

	float intensity = dist * dot(dir,norm);	
	vec3 color = ambient.rgb * vLightColor.rgb * intensity; // * atten; 
	gl_FragColor = texture2D(texture0, uvOut) * vec4(color,agk_ObjColor.a);
	*/
	
	vec3 dir = vLightPos.xyz - posVarying;
	float dist = length(dir);
	dist = vLightColor.a / (dist*dist);
	vec4 ambient = vec4(agk_ObjColor.b, agk_ObjColor.b, agk_ObjColor.b, 0);

	float intensity = dist * dot(dir,N);	
	
	vec3 diffuseColor = vec3(ambient.rgb);
	vec3 specularColor = vec3(0.0);
	
	vec3 V = normalize(camLoc.xyz - posVarying);
	vec3 L = normalize(vLightPos.xyz - posVarying);
	vec3 H = normalize(V + L);
	
	diffuseColor += vLightColor.a * texture2D(texture0, uvOut).rgb * max(0.0, dot(N, L));
	specularColor += vLightColor.a * pow(max(0.0, dot(N, H)), 40.0);
	
	gl_FragColor = vec4(intensity * vLightColor.rgb * diffuseColor + specularColor, 1.0);
	
}

Sorry your browser is not supported!

AppGameKit Classic Chat / 3D Normal Shader using 5 lights and a texture atlas - working I think

Attachments