SetObjectShaderConstantByName	(OBJ_CYLINDER, "MaterialSpecColor", 0.5, 0.5, 0.5, 5.0)

// #version 330

// Input vertex data, different for all executions of this shader.
attribute	vec3	position;
attribute	vec3	normal;
attribute	vec2	uv;

uniform		mat4 	agk_ViewProj; 
uniform		mat3 	agk_WorldNormal; 
uniform		mat4 	agk_WorldViewProj; 
uniform		mat4 	agk_World;
uniform 	mat4	agk_View;

uniform		vec4	uvBounds0;

uniform  	vec3 	agk_LightAmbient;
uniform  	vec3 	agk_DLightDir;
uniform  	vec3 	agk_DLightColor;

// uniform		vec3	MaterialDiffuseColor;
// uniform		vec3	MaterialAmbientColor;
uniform		vec3	agk_MeshDiffuse;
uniform		vec3	agk_MeshAmbient;

// uniform		vec4	LightPos0;			// w component == range

varying		vec3	vs_normal;
// varying		vec3	vs_lpos;
varying		vec3 	vs_position;
varying		vec2	vs_uv;
varying		vec3	vs_adColor;

void main(void)  
{     
	vs_position = (agk_World * vec4(position, 1.0)).xyz;       
	vs_normal = normalize(agk_WorldNormal * normal);
	vs_uv = uv * uvBounds0.xy + uvBounds0.zw;
	
	// vs_adColor	= agk_LightAmbient * MaterialAmbientColor;
	vs_adColor	= agk_LightAmbient * agk_MeshAmbient;
	// vs_adColor	+= (agk_DLightColor * MaterialDiffuseColor) * max(dot(vs_normal,normalize(-agk_DLightDir)), 0.0);
	vs_adColor	+= (agk_DLightColor * agk_MeshDiffuse) * max(dot(vs_normal,normalize(-agk_DLightDir)), 0.0);

	// vs_lpos = (agk_World * vec4(LightPos0.xyz, 1.0)).xyz;
   gl_Position = agk_WorldViewProj * vec4(position, 1.0);  
}
          

#define MAX_PLIGHTS	4

uniform		sampler2D	texture0;
uniform		sampler2D	texture1;
// uniform		sampler2D	texture2;

uniform		mat4 	agk_World;
// uniform		vec3 	CameraPos;

varying		vec3	vs_normal;
varying		vec3	vs_position; 
varying		vec2	vs_uv;
varying		vec3	vs_adColor;

 uniform vec3	agk_CameraPos;
// lights
uniform  vec3 agk_LightAmbient;
uniform  vec3 agk_DLightDir;
uniform  vec3 agk_DLightColor;

uniform  vec4 agk_PSLight1Pos;
uniform  vec3 agk_PSLight1Color;
uniform  vec4 agk_PSLight2Pos;
uniform  vec3 agk_PSLight2Color;
uniform  vec4 agk_PSLight3Pos;
uniform  vec3 agk_PSLight3Color;
uniform  vec4 agk_PSLight4Pos;
uniform  vec3 agk_PSLight4Color;

vec4	LightPos[MAX_PLIGHTS];
vec3	LightColor[MAX_PLIGHTS];


// uniform		vec3	MaterialDiffuseColor;
// uniform		vec3	MaterialAmbientColor;
uniform		vec4	MaterialSpecColor;		// w component == shininess
uniform		vec3	agk_MeshDiffuse;
uniform		vec3	agk_MeshAmbient;

mediump vec3 ApplyFog( mediump vec3 color, highp vec3 pointPos );

// 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;
   if(dot(map, map) == 0.0)
   {
		return N;
   }
   
   // map = map * 255.0/127.0 - 128.0/127.0;
   map = map * 2.0 - 1.0;
   
    mat3 TBN = cotangent_frame(N, -V, texcoord);
    return normalize(TBN * map);
}

vec3 GetPSLightColor(vec3 n, vec3 p, vec3 c)
{
	// vec3 	N		= n;
	vec3	E 		= normalize(agk_CameraPos - p);
	// vec3	E 		= normalize(-p);
	vec3	N		= perturb_normal(n, p, vs_uv);

	vec3 C = c;

	float	specfac		= clamp(dot(reflect(agk_DLightDir, N), E), 0.0, 1.0);
	float 	shininess	= max(1.0, MaterialSpecColor.w);
	vec3	ISpecular	= vec3(0);
	vec3	ISpecularDL	= vec3(0);
	
	if( dot(-agk_DLightDir, N) > 0.0)
		ISpecularDL	= (agk_DLightColor * MaterialSpecColor.rgb) * pow(specfac,shininess);
	
	for(int i=0; i<MAX_PLIGHTS; i++)
	{
		if(dot(LightColor[i], LightColor[i]) == 0.0)
			continue;
		
		vec3	L		= LightPos[i].xyz - p;
		float	dist	= length(L);
		
		L 				= normalize(L);
		vec3	R 		= reflect(-L, N);
	 
		dist *= dist;
		float	dotNL = dot(N, L);
		float	OneRange = 1.0 / (LightPos[i].w * LightPos[i].w);
		float	atten = max(0.0, 1.0 - (dist*dist) * (OneRange*OneRange));
		atten *= atten;
		// float	atten = 1.0;

		// vec3	IDiffuse	= (LightColor[i] * MaterialDiffuseColor) * max(dotNL, 0.0);
		vec3	IDiffuse	= (LightColor[i] * agk_MeshDiffuse) * max(dotNL, 0.0);
		specfac				= dot(E, R);
		
		if(dotNL > 0.0 && specfac > 0.0)
		{
			ISpecular	= (LightColor[i] * MaterialSpecColor.rgb) * pow(specfac,shininess) * atten;// * dotNL;
		}

		C += ((atten*IDiffuse) + ISpecular);
	}
	
	return C + ISpecularDL;
}

void main (void) 
{
	LightColor[0] = agk_PSLight1Color;
	LightColor[1] = agk_PSLight2Color;
	LightColor[2] = agk_PSLight3Color;
	LightColor[3] = agk_PSLight4Color;
	
	LightPos[0] = agk_PSLight1Pos;
	LightPos[1] = agk_PSLight2Pos;
	LightPos[2] = agk_PSLight3Pos;
	LightPos[3] = agk_PSLight4Pos;

	// vec3 	N		= vs_normal;

	// vec3	IAmbient	= agk_LightAmbient * MaterialAmbientColor;
	// IAmbient			+= (agk_DLightColor * MaterialDiffuseColor) * max(dot(N,normalize(-agk_DLightDir)), 0.0);
	
	gl_FragColor = vec4(ApplyFog(GetPSLightColor(vs_normal, vs_position,vs_adColor) * texture2D(texture0, vs_uv).rgb, vs_position), 1.0);
}

	CreatePointLight(3, 5, 5, -10, 120, 255, 100, 50)
	SetPointLightMode(3,1)

SetSyncRate(0, 0)

Edit: Forum delivering as usual I see... christ on a bike

uniform sampler2D texture0;
varying highp vec2 uvVarying;
varying mediump vec4 colorVarying;
uniform float _Grey_Scale; 
void main()
{
		
    vec4 newcolour = texture2D(texture0, uvVarying);
    float gray = dot(newcolour.rgb, vec3(0.3, 0.59, 0.11)) ;
    vec4 newcolour2 = mix ( newcolour, vec4 ( gray,gray,gray,1.0 ),_Grey_Scale );
    gl_FragColor =vec4( newcolour2.r, newcolour2.g, newcolour2.b, newcolour.a )*colorVarying;

}