Sorry your browser is not supported!

// Project: Animated Texture
// Created: 2016-05-04

// set window properties
SetWindowTitle( "Animated Texture" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )



tex= LoadImage("test.png")
box= CreateObjectBox(5,5,5)

shader=LoadShader("anitex.vs","anitex.ps")

SetObjectColor(box,255,100,100,255)

SetObjectImage(box,tex,0)
 SetImageWrapU(tex,1)
 SetImageWrapV(tex,1)

SetObjectShader(box,shader)
// image tiles for the shader
tx = 4
ty = 4


SetObjectShaderConstantByName( box, "Animation", tx, ty, tx*ty, 1.0-(1.0/(tx*ty)) ) 
SetObjectShaderConstantByName( box, "m_Speed",1,0,0,0) 

do
print(timer())	
      
    SetObjectShaderConstantByName( box, "Time",timer(),0,0,0) 

    Print( ScreenFPS() )
    Sync()
loop

uniform sampler2D texture0;
 
varying highp vec3 posVarying;
varying mediump vec3 normalVarying;
varying mediump vec2 uvVarying;
varying mediump vec3 lightVarying;

mediump vec3 GetPSLighting( mediump vec3 normal, highp vec3 pos );
mediump vec3 ApplyFog( mediump vec3 color, highp vec3 pointPos );
 
void main()
{ 
    mediump vec3 norm = normalize(normalVarying);
    mediump vec3 light = lightVarying + GetPSLighting( norm, posVarying ); 
    
    mediump vec3 color = texture2D(texture0, uvVarying).rgb * light;
    color = ApplyFog( color, posVarying );
   
    gl_FragColor = vec4(color,1.0);
}

attribute highp vec3 position;
attribute mediump vec3 normal;
attribute mediump vec2 uv;
 
varying highp vec3 posVarying;
varying mediump vec3 normalVarying;

varying mediump vec2 uvVarying;

varying mediump vec3 lightVarying;



uniform highp mat3 agk_WorldNormal;
uniform highp mat4 agk_World;
uniform highp mat4 agk_ViewProj;
uniform mediump vec4 uvBounds0;

uniform mediump vec4 Animation; 

mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );

uniform float Time;
uniform float m_Speed;



 
void main()
{ 
 



   

	int iNumTilesU = int(Animation.x);
	int iNumTilesV = int(Animation.y);

	int numTilesTotal = int(Animation.z);
	int selectedTile = 1;
	

        selectedTile += int(Time*float(m_Speed));

// calculate the offset (fract is here, to keep the calcuations inside 0.0 - 1.0)
uvVarying.x = - (1.0 - float((uv.x + mod(float(selectedTile),  float(iNumTilesU))) / float(iNumTilesU))); ///selectedTile;
uvVarying.y = (-uv.y - float(selectedTile / iNumTilesU)) / float(iNumTilesV)*-1.0; ///selectedTile;



    highp vec4 pos = agk_World * vec4(position,1.0);
    gl_Position = agk_ViewProj * pos;
    mediump vec3 norm = normalize(agk_WorldNormal * normal);
    posVarying = pos.xyz;
    normalVarying = norm;
    lightVarying = GetVSLighting( norm, posVarying );
}

uvVarying.x =  (uv.x + mod(float(selectedTile),  Animation.x)) / Animation.x;  
uvVarying.y = (uv.y + mod(float(selectedTile / int(Animation.x)),Animation.y) ) / Animation.y;

// Project: BillboardingShader 
// Created: 2016-05-11

// set window properties
SetWindowTitle( "BillboardingShader" )
SetWindowSize( 1024, 768, 0 )

// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )

#constant KEY_LEFT   		37
#constant KEY_UP     		38
#constant KEY_RIGHT  		39
#constant KEY_DOWN   		40 
#constant KEY_W            	87
#constant KEY_A            	65
#constant KEY_S            	83
#constant KEY_D            	68
#constant KEY_SHIFT			16



// here, the magic happens:


img=LoadImage("tree.png")

shader=LoadShader("vs.vs","ps.ps")
plane=CreateObjectPlane(5,5)
SetObjectShader(plane,shader)
SetObjectPosition(plane,0,2.5,0)
SetObjectImage(plane,img,0)
SetObjectTransparency(plane,1)

ground=CreateObjectPlane(20,20)
SetObjectRotation(ground,90,0,0)



SetObjectShaderConstantByName(plane,"spherical",0.0,0,0,0)

do
    UpdateCameraArrowControl()

    Print( ScreenFPS() )
    Sync()
loop


function UpdateCameraArrowControl()

	if GetRawKeyState(KEY_SHIFT)=1
		movspd#=3	
	else
		movspd#=1
	endif
	
	// movement
	if GetRawKeyState(KEY_W)=1 then MoveCameraLocalZ(1,movspd#)
	if GetRawKeyState(KEY_S)=1 then MoveCameraLocalZ(1,-movspd#)
	if GetRawKeyState(KEY_A)=1 then MoveCameraLocalX(1,-movspd#)
	if GetRawKeyState(KEY_D)=1 then MoveCameraLocalX(1,movspd#)
	// rotation
	if GetRawKeyState(KEY_UP)=1 then RotateCameraLocalX( 1,-2)
	if GetRawKeyState(KEY_DOWN)=1 then RotateCameraLocalX( 1,2)
	if GetRawKeyState(KEY_LEFT)=1 then RotateCameraGlobalY( 1,-2)
	if GetRawKeyState(KEY_RIGHT)=1 then RotateCameraGlobalY( 1,2)

endfunction

// AGK GLSL Shader - Billboarding - Alex Schmidt - movies.online-arts.de

attribute highp vec3 position;
attribute mediump vec3 normal;
attribute mediump vec2 uv;
 
varying highp vec3 posVarying;
varying mediump vec3 normalVarying;
varying mediump vec2 uvVarying;
varying mediump vec3 lightVarying;
 
uniform highp mat3 agk_WorldNormal;
uniform highp mat4 agk_Proj;
uniform highp mat4 agk_World;
uniform highp mat4 agk_View;

uniform mediump vec4 uvBounds0;
 
mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );
uniform int spherical; // this integer will hold the information about the billboarding type 0=rotate on y axis to camera, 1=always point camera




void main()
{ 

// yes, thats right, AGK_View*AGK_World is the model matrix, but dont forget to change agk_ViewProj in agk_Proj  in the gl_position line
  mat4 modelView = agk_View*agk_World;
 

  // First colunm.
   modelView[0][0] = 1.0; 
   modelView[0][1] = 0.0; 
   modelView[0][2] = 0.0; 
  
   if (spherical == 1)
   {
    // Second colunm.
     modelView[1][0] = 0.0; 
     modelView[1][1] = 1.0; 
     modelView[1][2] = 0.0; 
   }
  
  // Thrid colunm.
   modelView[2][0] = 0.0; 
   modelView[2][1] = 0.0; 
  modelView[2][2] = 1.0;  
  
  
    uvVarying = uv * uvBounds0.xy + uvBounds0.zw;
    highp vec4 pos = modelView * vec4(position,1.0);
    gl_Position = agk_Proj * pos;
	
    mediump vec3 norm = normalize(agk_WorldNormal * normal);
    posVarying = pos.xyz;
    normalVarying = norm;
    lightVarying = GetVSLighting( norm, posVarying );
}
 
 
 
 
  

uniform sampler2D texture0;
 
varying highp vec3 posVarying;
varying mediump vec3 normalVarying;
varying mediump vec2 uvVarying;
varying mediump vec3 lightVarying;
 
mediump vec3 GetPSLighting( mediump vec3 normal, highp vec3 pos );
mediump vec3 ApplyFog( mediump vec3 color, highp vec3 pointPos );
 
void main()
{ 
    mediump vec3 norm = normalize(normalVarying);
    mediump vec3 light = lightVarying + GetPSLighting( norm, posVarying ); 
    
    mediump vec3 color = texture2D(texture0, uvVarying).rgb * light;
    color = ApplyFog( color, posVarying );
    
    gl_FragColor = vec4(color,texture2D(texture0, uvVarying).a);
}

float dist	= length(L);	
L /= dist;

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;

}

#ifdef GL_ES
	#ifdef GL_FRAGMENT_PRECISION_HIGH   
		precision highp float;
	#else
		precision mediump float;
	#endif
#endif

uniform sampler2D texture0;
varying vec2 uvVarying;

uniform vec2 screenSize;
uniform float noise;

float rand(vec2 n)
{
  return 0.5 + 0.5 * 
     fract(sin(dot(n.xy, vec2(12.9898, 78.233)))* 43758.5453);
}

void main()
{
	float y = floor(uvVarying.y * screenSize.y);
	float ran = (rand(uvVarying.xy) - 1.0) * 0.5;
	if (noise < 0.1)
	{
		ran = 0.0;
	}
	float delta = mod(y, 4.0) * 0.5;
	gl_FragColor = texture2D(texture0, uvVarying.xy) * (delta + ran);
}

// Project: scanline 
// Created: 2016-10-04

// show all errors
SetErrorMode(2)

// set display properties
SetWindowTitle( "scanline" )
SetWindowSize( 1024, 768, 0 )
SetVirtualResolution( 1024, 768 )
SetSyncRate( 60, 0 )
SetPrintSize(16)

// load media
img = LoadImage("scanline.png")

// load shader
shader = LoadFullScreenShader("scanline.ps")
SetShaderConstantByName(shader, "screenSize", 1024, 768, 0, 0)
// set 1 to 0 to remove noise
SetShaderConstantByName(shader, "noise", 1, 0, 0, 0)

// create quad object
renderImage = CreateRenderImage(1024, 768, 0, 0)
quad = CreateObjectQuad()
SetObjectShader(quad, shader)

// create sprite
SetImageMagFilter(img, 0)
spr = CreateSprite(img)
SetSpriteScale(spr, 2, 2)
SetSpritePositionByOffset(spr, 512, 384)

do
    
    // do actions on mouse button pressed
    // reset state
	MODE = 0
	change = 0
	
	// set state based on mouse pressed
    if GetPointerState()>0
		if MODE=0 then change = 1
		MODE = 1
	else
		if MODE=1 then change = 2
		MODE = 0
	endif
	
	// set shader visible as needed
	select change
		case 1
			SetObjectShader(quad, shader)
		endcase
		case 2
			SetObjectShader(quad, 0)
		endcase
	endselect
	
	select MODE
		case 0
			Print("Press mouse button to see shader")
			Sync()
		endcase
		case 1
			// render to the render image
			SetRenderToImage(renderImage, -1)
			ClearScreen()
			Update(GetFrameTime())
			print("Showing shader")
			Render2DBack()
			Render2DFront()
			SetObjectImage(quad, renderImage, 0)
			
			// render to the screen
			SetRenderToScreen()
			ClearScreen()
			DrawObject(quad)
			Swap()
		endcase
	endselect
loop

function Norm2D_Init(AmbientRed#,AmbientGreen#,AmbientBlue#)
	global Norm2D_Light as NORM2D_LIGHTDATA[]
	
	global Norm2D_ShaderID
	Norm2D_ShaderID=LoadSpriteShader("Normalmapping2DAlpha.ps")
	SetShaderConstantByName(Norm2D_ShaderID,"AmbientColor",AmbientRed#/255, AmbientGreen#/255, AmbientBlue#/255, 0)
	SetShaderConstantByName(Norm2D_ShaderID,"Falloff", 0.1,0.01,0.001,0.0)
endfunction

uniform sampler2D texture0;
uniform sampler2D texture1;
varying vec2 uvVarying;

uniform vec2 agk_resolution;
uniform vec4 AmbientColor;
uniform vec3 Falloff;

uniform float LightCount;
uniform vec3 LightPosition[8];
uniform vec4 LightColor[8];

vec3 light(vec3 LightPos, vec4 LightColor)
{
	LightPos.y = agk_resolution.y - LightPos.y;
	
	vec3 normal = texture2D(texture1, uvVarying.xy).rgb;
	
    vec3 LightDir = vec3(LightPos.xy - gl_FragCoord.xy, LightPos.z);
	
    vec3 LDIR=normalize(LightDir);
	
	normal = normal * 2.0 - 1.0;
	vec3 NDIR=normalize(normal);
	
	float dist = length(LightDir);
	float Attenuation = clamp((1.0 / (Falloff.x +(Falloff.y * dist) +(Falloff.z * dist * dist))) * LightColor.w,0.0,1.0);
	
	return LightColor.rgb * max(dot(NDIR, LDIR), 0.0) * Attenuation;
}

void main()
{
	
    vec4 diffuse = texture2D(texture0, uvVarying.xy);
	vec3 Light;
	for(int i=0; i < int(LightCount); i++)
	{
		Light = Light + light(LightPosition[i], LightColor[i]);
	}

	//gl_FragColor = diffuse * (AmbientColor + vec4(Light,0.0));  // previous fragcolor - no alpha
	gl_FragColor = (AmbientColor + diffuse) * vec4(diffuse.rgb * AmbientColor, diffuse.a) + vec4(Light,0.0) * diffuse.rgb; // new fragcolor with alpha. SetSpriteTransparency(SpriteID, 1) in your agk code
}

//update elements
	Update(0)
	
	//Create HUDs texture
	SetHUDsVisible( 1 )
	//SetMapVisible( 0 )
	//SetSpriteVisible( SptBackground, 0 )
	SetRenderToImage( ImgHUD, 0 )
	ClearScreen()
	Render()

	//Create MAP texture
	SetHUDsVisible( 0 )
	SetMapVisible( 1 )
	SetSpriteVisible( SptBackground, 1 )
	
	SetRenderToImage( ImgNoBlur, 0 )
	ClearScreen()
	Render()
	
	//apply blur
	SetMapVisible( 0 )
	SetSpriteVisible( SptBackground, 0 )
	
	SetObjectShader( ObjScreen, ShdVertBlur )
	SetRenderToImage( ImgVBlur, 0 )
	SetObjectImage( ObjScreen, ImgNoBlur, 0 )
	ClearScreen()
	DrawObject( ObjScreen )
	//Render()
	
	SetObjectShader( ObjScreen, ShdHorzBlur )
	SetRenderToImage( ImgTiltShift, 0 )
	SetObjectImage( ObjScreen, ImgVBlur, 0 )
	ClearScreen()
	DrawObject( ObjScreen )
	//Render()
	
	SetObjectShader( ObjScreen, ShdCombine )
	SetObjectImage( ObjScreen, ImgTiltShift, 0 )
	SetObjectImage( ObjScreen, ImgHUD, 1 )
	//SetHUDsVisible( 1 )
	SetRenderToScreen()
	ClearScreen()
	DrawObject( ObjScreen )
	//Render()
	
	//ClearScreen()
	
	//remend
	
	Swap()