Sorry your browser is not supported!

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

uniform mat4 agk_WorldViewProj; 

uniform vec4 uvBounds0;
uniform vec4 uvBounds1;

varying vec2 uvVarying;
varying vec3 normalVarying;
varying vec3 posVarying;
 
void main()
{
  gl_Position = agk_WorldViewProj * vec4(position,1);
  
  uvVarying = uv * uvBounds0.xy + uvBounds0.zw;  
  normalVarying = uv * uvBounds1.xy + uvBounds1.zw;

}

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 mat3 agk_WorldNormal;
uniform vec2 tiling;


	
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+tiling) + uvBounds0.zw;
}

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 mat3 agk_WorldNormal;
uniform vec2 tiling;


	
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+tiling) + uvBounds0.zw;
}

gl_FragColor = clamp((texture2D(texture0, uvVarying ) * vec4(color,1) * agk_ObjColor * defaultLight ) / distance , ambientMin , ambientMax );

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 mat3 agk_WorldNormal;
uniform vec2 tiling;


	
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+tiling) + uvBounds0.zw;
}

uniform vec4 agk_PLightPos;
uniform vec4 agk_PLightColor;

uniform vec3 agk_DLightDir;
uniform vec4 agk_DLightColor;

uniform vec4 agk_ObjColor;

uniform sampler2D texture0;
uniform sampler2D texture1;

uniform float ambientPower;	
uniform float ambientMin;
uniform float ambientMax;
uniform vec3 defaultLight;

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

void main()
{
    vec2 onePixel = vec2(1.0 / 480.0, 1.0 / 480.0);    
    vec2 texCoord = uvVarying;
    vec4 bump;
    bump.rgb = vec3(0.5);
    bump -= texture2D(texture1, texCoord - onePixel) * 16.0;
    bump += texture2D(texture1, texCoord + onePixel) * 16.0;
    bump.rgb = vec3((bump.r + bump.g + bump.b) / 8.0);
    
    vec3 dir = agk_PLightPos.xyz - posVarying;
    vec3 norm = normalize(normalVarying);
    float distance = length(dir)/ambientPower;    
    float atten = dot(dir,dir);
    atten = clamp(agk_PLightPos.w/atten,0.0,1.0);
    float intensity = dot(normalize(dir),norm);
    intensity = clamp(intensity,0.0,1.0);
    vec3 color = (agk_PLightColor.rgb+bump.rgb) * intensity * atten;    
    color = color + clamp(dot(-agk_DLightDir,norm)*agk_DLightColor.rgb,0.0,0.2);
    gl_fragcolor = clamp((texture2D(texture0, uvVarying ) * vec4(color,1) * agk_ObjColor * defaultLight)/ distance, ambientMin , ambientMax);
}

setvirtualresolution(640,480)

gold=loadimage("img/gold.png")
bump=loadimage("img/bump.png")

frontgun=loadobject("obj/frontgun.obj"):setobjectimage(frontgun,gold,0):setobjectimage(frontgun,bump,1)

createlightdirectional(1,0,0,0,255,255,255)
createlightpoint(1,0,40,-20,100,255,255,0)

setcameraposition(1,40,30,-50): setcameralookat(1,0,30,0,0)

bumpeffect=loadshader("fx/bump.vs","fx/bump.ps")
setobjectshader(frontgun,bumpeffect)

do
 Sync()
loop

uniform mat4 agk_World;
uniform vec4 uvBounds0;
uniform vec4 uvBounds1;

attribute vec3 position;
attribute vec2 uv;

varying vec2 uvVarying;
varying vec2 spVarying;
varying vec3 posVarying;

	
void main()
{
    vec4 pos = agk_World * vec4(position,1);
    
    posVarying = pos.xyz;
    uvVarying = uv * (uvBounds0.xy) + uvBounds0.zw;
    spVarying = uv*(uvBounds1.xy) + uvBounds1.zw;
}

uniform sampler2D texture0;
uniform sampler2D texture1;

varying vec2 uvVarying;
varying vec2 spVarying;
varying vec3 posVarying;

void main()
{
	gl_FragColor = texture2D(texture0, uvVarying.xy)  + texture2D(texture1, 

spVarying.xy);
}

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 mat3 agk_WorldNormal;
uniform vec2 tiling;


	
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+tiling) + uvBounds0.zw;
}

// Check if its android/iphone and not desktop open gl to make it cross platform
// things like lowp,mediump and highp only works on mobile version
#ifdef GL_ES
   precision lowp float;
   uniform lowp vec4 agk_ObjColor;
   uniform lowp vec4 agk_PLightColor;
   uniform lowp vec4 agk_PLightColor2;
   uniform lowp vec4 agk_DLightColor;
#else
   uniform vec4 agk_ObjColor;
   uniform vec4 agk_PLightColor;
   uniform vec4 agk_PLightColor2;
   uniform vec4 agk_DLightColor;
#endif

// Check if its android/iphone and not desktop open gl to make it cross platform
// things like lowp,mediump and highp only works on mobile version
// normalize is very costly on iphone and android and only used when its really neaded
#ifdef GL_ES
   precision lowp float;
   uniform lowp vec4 agk_ObjColor;

   uniform lowp vec4 agk_PLightPos;   
   uniform lowp vec4 agk_PLightColor;
   
   uniform lowp vec4 agk_PLightPos2;
   uniform lowp vec4 agk_PLightColor2;
   
   uniform lowp vec3 agk_DLightDir;
   uniform lowp vec4 agk_DLightColor;

   varying lowp vec2 uvVarying;
   varying lowp vec3 normalVarying;
   varying lowp vec4 posVarying;

   uniform sampler2D texture0;
   uniform sampler2D texture1;

void main()
{
    lowp vec2 onePixel = vec2(1.0 / 480.0, 1.0 / 480.0);    
    vec4 bump;
    bump.rgb = vec3(0.5);
    bump -= texture2D(texture1, uvVarying.xy - onePixel) * 8.0;
    bump += texture2D(texture1, uvVarying.xy + onePixel) * 8.0;
    bump.rgb = clamp(vec3((bump.r + bump.g + bump.b) / 8.0),0.22,1.0);

    lowp vec3 dir = agk_PLightPos.xyz - posVarying.xyz;
    lowp float atten = dot(dir,dir);
    atten = clamp(agk_PLightPos.w/atten,0.01,1.0);
    lowp float intensity = dot(normalize(dir),normalVarying);
    intensity = clamp(intensity,0.5,1.0);
       
    lowp float distance = clamp(length(dir),74.0,10000.0)/640.0;    

    lowp vec3 dir2 = agk_PLightPos2.xyz - posVarying.xyz;
    lowp float atten2 = dot(dir2,dir2);
    atten2 = clamp(agk_PLightPos2.w/atten2,0.01,1.0);
    lowp float intensity2 = dot(normalize(dir2),normalVarying);
    intensity2 = clamp(intensity2,0.01,1.0);
    lowp vec3 color = clamp(clamp(agk_PLightColor.rgb * intensity * atten,0.01,4.0) + clamp(agk_PLightColor2.rgb * intensity2 * atten2,0.01,1.6)*bump.rgb,0.01,0.5);
        
    gl_FragColor = (texture2D(texture0, uvVarying.xy ) * vec4(( color + clamp(dot(-agk_DLightDir,normalVarying)*agk_DLightColor.rgb,0.0,0.2) ),1) * agk_ObjColor)/distance;
}
#else
   uniform vec4 agk_ObjColor;
   
   uniform vec4 agk_PLightPos;  
   uniform vec4 agk_PLightColor;
   
   uniform vec4 agk_PLightPos2;
   uniform vec4 agk_PLightColor2;
   
   uniform vec3 agk_DLightDir;
   uniform vec4 agk_DLightColor;

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

   uniform sampler2D texture0;
   uniform sampler2D texture1;

void main()
{
    vec2 onePixel = vec2(1.0 / 480.0, 1.0 / 480.0);    
    vec4 bump;
    bump.rgb = vec3(0.5);
    bump -= texture2D(texture1, uvVarying.xy - onePixel) * 8.0;
    bump += texture2D(texture1, uvVarying.xy + onePixel) * 8.0;
    bump.rgb = clamp(vec3((bump.r + bump.g + bump.b) / 8.0),0.22,1.0);

    vec3 dir = agk_PLightPos.xyz - posVarying.xyz;
    vec3 norm = normalize(normalVarying);
    float atten = dot(dir,dir);
    atten = clamp(agk_PLightPos.w/atten,0.01,1.0);
    float intensity = dot(normalize(dir),norm);
    intensity = clamp(intensity,0.5,1.0);
       
    float distance = clamp(length(dir),74.0,10000.0)/640.0;    

    vec3 dir2 = agk_PLightPos2.xyz - posVarying.xyz;
    float atten2 = dot(dir2,dir2);
    atten2 = clamp(agk_PLightPos2.w/atten2,0.01,1.0);
    float intensity2 = dot(normalize(dir2),norm);
    intensity2 = clamp(intensity2,0.01,1.0);
    vec3 color = clamp(clamp(agk_PLightColor.rgb * intensity * atten,0.01,4.0) + clamp(agk_PLightColor2.rgb * intensity2 * atten2,0.01,1.6)*bump.rgb,0.01,0.5);
        
    gl_FragColor = (texture2D(texture0, uvVarying.xy ) * vec4(( color + clamp(dot(-agk_DLightDir,norm)*agk_DLightColor.rgb,0.0,0.2) ),1) * agk_ObjColor)/distance;
}
#endif

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

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

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

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

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

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

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

varying vec3 normalVarying;
varying vec3 posVarying;

uniform mat4 agk_World;
uniform mat4 agk_ViewProj;
uniform mat3 agk_WorldNormal;
	
void main()
{
    vec4 pos = agk_World * vec4(position,1);
    gl_Position = agk_ViewProj * pos;

    normalVarying = agk_WorldNormal * normal;
    posVarying = pos.xyz;
}

uniform vec3 agk_DLightDir;
uniform vec4 agk_DLightColor;

uniform vec4 agk_ObjColor;

uniform float toon;

varying vec3 normalVarying;
varying vec3 posVarying;

void main()
{
	vec3 norm = normalize(normalVarying);
	vec3 dir = normalize(-agk_DLightDir);
	float intensity = dot(norm,dir);
	float int_range= ceil(intensity/toon);
	intensity = int_range*toon;

	gl_FragColor = vec4(1.0*agk_DLightColor.x*agk_ObjColor.x*intensity, 0.5*agk_DLightColor.y*agk_ObjColor.y*intensity, 0.5*agk_DLightColor.z*agk_ObjColor.z*intensity, 1.0);
}

uniform sampler2D texture0;
varying vec2 texcoord;
varying vec4 col;

void main()
{ 
vec4 diffuse = texture2D(texture0, texcoord.xy);
if (diffuse.a < 0.1) discard;   
else gl_FragColor = diffuse*col;
   
}

vertex shader general_vertex.vs and pixel shader wavy_grass_shader.ps failed to link, make sure any varying used in the pixel shader are output in the vertex shader at line 5 in shaders.agc

#ifdef GL_ES
precision highp float;
#endif

uniform sampler2D texture0; 

uniform float time;

varying vec2 uv0Varying;

const float speed = 2.0;
const float bendFactor = 0.2;


void main()
{
  float height = 1.0 - uv0Varying.y;
  
  float offset = pow(height, 2.5);
 
  offset *= (sin(time * speed) * bendFactor);
 
  vec3 normalColor = texture2D(texture0, fract(vec2(uv0Varying.x + offset, uv0Varying.y))).rgb;
  if (normalColor.a < 0.1) discard;
  gl_FragColor = vec4(normalColor, 1);

}

// The attribute keyword tells the compiler that this is an 
// input variable that comes with each vertex data structure.
// Types vec2 and vec4 declare that the data is a vector of 
// floats; vec can have 2-4 components.

attribute vec3 position;
attribute vec3 normal;
attribute vec2 uv;

// When you need some external variables passed to the 
// shader from your source code, you need to declare them 
// as uniform. Type mat4 declares that the data is a 
// 4×4 matrix of floats. 

uniform mat4 agk_WorldViewProj; 

// This is object texture 0
uniform vec4 uvBounds0;

// This is object texture 1
uniform vec4 uvBounds1;

// Scale Input by AGK Tier1 : ex: SetShaderConstantByName( shaderindex, "ScaleMap",0.1 ,0.1,0, 0 )
uniform vec2 ScaleMap;

// The vertex shader needs to send some data to the 
// pixel shader. To notate variables that you pass from 
// a vertex shader to a pixel shader, you use the 
// varying keyword.

varying vec2 uv0Varying;
varying vec2 uv1Varying;
 
void main()
{
  // Vertex shaders need to fill the built-in variable 
  // gl_Position with the transformed vertex position.
  gl_Position = agk_WorldViewProj * vec4(position,1);
  
  // This passes the input coordinates of the color texture to the pixel shader 
  // unchanged by assigning them to the varying variable.  
  uv0Varying = uv * uvBounds0.xy + uvBounds0.zw;

  
  // This passes the input coordinates of the (Detail/Light) Map to the pixel shader 
  // changed by assigning them with the inversed Scale Value to the varying variable.  
  uv1Varying = uv * (uvBounds1.xy+(1.0/ScaleMap)) + uvBounds1.zw;  

}

// highp and lowp. They define the importance of the quality 
// of calculations/data storage. The higher precision means 
// more precise data types will be used, and the calculations 
// will be slower.
#ifdef GL_ES
precision highp float;
#endif

// constant values sent through from AGK code.
uniform sampler2D texture0; 
uniform sampler2D texture1; 


// Anything that the vertex shader passes as output needs to 
// be defined here as input. The vertex shader is passing the 
// texture coordinate, so it is defined again here.
varying vec2 uv0Varying;
varying vec2 uv1Varying;

void main()
{
  // copy the textures coords
  vec2 texCoord0 = uv0Varying;
  vec2 texCoord1 = uv1Varying;

  // temporary colorResult variable (rgba)
  vec4 colorResult;  
  
  // Multiply the two textures pixel components (rgba) 
  colorResult = texture2D(texture0, texCoord0) * texture2D(texture1, texCoord1);
  
  // Multiply Result color by 2 to restore the correct brightness and return it.
  gl_FragColor = colorResult*2.0;
}

agk_World * vec4(position,1);