Sorry your browser is not supported!

attribute vec3 position;
attribute vec2 uv;
  
varying vec2 uv0Varying;
varying vec2 uv1Varying;

uniform vec4 uvBounds0;
uniform vec4 uvBounds1;
 
uniform mat4 agk_World;
uniform mat4 agk_ViewProj;
 
void main()
{
	vec4 pos = agk_World * vec4(position,1);
	gl_Position = agk_ViewProj * pos;
	uv0Varying = uv * uvBounds0.xy + uvBounds0.zw;
	uv1Varying = uv * uvBounds1.xy + uvBounds1.zw;
}

// 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()
{
	vec4 colorResult0  = texture2D(texture0, uv0Varying);
	vec4 colorResult1  = texture2D(texture1, uv1Varying); // you can change here the second uvlayer by texture2D(texture1, texCoord1) if you use different uvchanel for each texture

	gl_FragColor = mix(colorResult0, colorResult1, colorResult1.a); // mix with the alpha of the second texture. You can mix with a third texture if you want to use seamless texture and repeat it.
}

// create a sphere to see the texture
CreateObjectBox(1,20,20,20)
 
// position and orientate the camera
SetCameraPosition(1,0,100,-200)
SetCameraLookAt(1,0,0,0,0)
SetGenerateMipmaps(1)
 
LoadImage(1,"texture0.jpg") // no need for alpha with this one
LoadImage(2,"texture1.png") // with alpha ;)

CreatePointLight(1,-5,5,5,500,200,200,200)
 
// initial rotation values
angle_x# = 0.0
 
// main loop
SetObjectRotation(1,-60,-60,0.0)
SetObjectScale(1,4,2,2)
LoadShader(3, "blend.vs", "blend.ps")
SetObjectShader(1,3)
SetObjectImage(1,1,0)
SetObjectImage(1,2,1)
SetObjectUVScale(1,1,2.0,2.0)
SetObjectUVOffset(1,1,-0.25,-0.25)
 
do
     
    angle_x# = angle_x# + 1 
    SetObjectRotation(1,0, angle_x#,0.0)
    sync()
 
loop

attribute vec3 position;
attribute vec2 uv;
  
varying vec2 uv0Varying;
varying vec2 uv1Varying;

uniform vec4 uvBounds0;
uniform vec4 uvBounds1;
uniform float uvAngle;
 
uniform mat4 agk_World;
uniform mat4 agk_ViewProj;
 
void main()
{
	vec4 pos = agk_World * vec4(position,1);
	gl_Position = agk_ViewProj * pos;
	uv0Varying = uv * uvBounds0.xy + uvBounds0.zw;
	
	vec2 uvRotate = uv * uvBounds1.xy + uvBounds1.zw;
	float sinAngle = sin(uvAngle);
	float cosAngle = cos(uvAngle);
	uvRotate = (uvRotate - 0.5) * mat2(cosAngle, sinAngle, -sinAngle, cosAngle);
	uvRotate += 0.5;
	uv1Varying = uvRotate;
}

/*
** Copyright (c) 2012, Romain Dura romain@shazbits.com
** 
** Permission to use, copy, modify, and/or distribute this software for any 
** purpose with or without fee is hereby granted, provided that the above 
** copyright notice and this permission notice appear in all copies.
** 
** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 
** WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
** MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 
** SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
** WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
** ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR 
** IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

/*
** Photoshop & misc math
** Blending modes, RGB/HSL/Contrast/Desaturate, levels control
**
** Romain Dura | Romz
** Blog: http://mouaif.wordpress.com
** Post: http://mouaif.wordpress.com/?p=94
*/



/*
** Desaturation
*/

vec4 Desaturate(vec3 color, float Desaturation)
{
	vec3 grayXfer = vec3(0.3, 0.59, 0.11);
	vec3 gray = vec3(dot(grayXfer, color));
	return vec4(mix(color, gray, Desaturation), 1.0);
}


/*
** Hue, saturation, luminance
*/

vec3 RGBToHSL(vec3 color)
{
	vec3 hsl; // init to 0 to avoid warnings ? (and reverse if + remove first part)
	
	float fmin = min(min(color.r, color.g), color.b);    //Min. value of RGB
	float fmax = max(max(color.r, color.g), color.b);    //Max. value of RGB
	float delta = fmax - fmin;             //Delta RGB value

	hsl.z = (fmax + fmin) / 2.0; // Luminance

	if (delta == 0.0)		//This is a gray, no chroma...
	{
		hsl.x = 0.0;	// Hue
		hsl.y = 0.0;	// Saturation
	}
	else                                    //Chromatic data...
	{
		if (hsl.z < 0.5)
			hsl.y = delta / (fmax + fmin); // Saturation
		else
			hsl.y = delta / (2.0 - fmax - fmin); // Saturation
		
		float deltaR = (((fmax - color.r) / 6.0) + (delta / 2.0)) / delta;
		float deltaG = (((fmax - color.g) / 6.0) + (delta / 2.0)) / delta;
		float deltaB = (((fmax - color.b) / 6.0) + (delta / 2.0)) / delta;

		if (color.r == fmax )
			hsl.x = deltaB - deltaG; // Hue
		else if (color.g == fmax)
			hsl.x = (1.0 / 3.0) + deltaR - deltaB; // Hue
		else if (color.b == fmax)
			hsl.x = (2.0 / 3.0) + deltaG - deltaR; // Hue

		if (hsl.x < 0.0)
			hsl.x += 1.0; // Hue
		else if (hsl.x > 1.0)
			hsl.x -= 1.0; // Hue
	}

	return hsl;
}

float HueToRGB(float f1, float f2, float hue)
{
	if (hue < 0.0)
		hue += 1.0;
	else if (hue > 1.0)
		hue -= 1.0;
	float res;
	if ((6.0 * hue) < 1.0)
		res = f1 + (f2 - f1) * 6.0 * hue;
	else if ((2.0 * hue) < 1.0)
		res = f2;
	else if ((3.0 * hue) < 2.0)
		res = f1 + (f2 - f1) * ((2.0 / 3.0) - hue) * 6.0;
	else
		res = f1;
	return res;
}

vec3 HSLToRGB(vec3 hsl)
{
	vec3 rgb;
	
	if (hsl.y == 0.0)
		rgb = vec3(hsl.z); // Luminance
	else
	{
		float f2;
		
		if (hsl.z < 0.5)
			f2 = hsl.z * (1.0 + hsl.y);
		else
			f2 = (hsl.z + hsl.y) - (hsl.y * hsl.z);
			
		float f1 = 2.0 * hsl.z - f2;
		
		rgb.r = HueToRGB(f1, f2, hsl.x + (1.0/3.0));
		rgb.g = HueToRGB(f1, f2, hsl.x);
		rgb.b= HueToRGB(f1, f2, hsl.x - (1.0/3.0));
	}
	
	return rgb;
}


/*
** Contrast, saturation, brightness
** Code of this function is from TGM's shader pack
** http://irrlicht.sourceforge.net/phpBB2/viewtopic.php?t=21057
*/

// For all settings: 1.0 = 100% 0.5=50% 1.5 = 150%
vec3 ContrastSaturationBrightness(vec3 color, float brt, float sat, float con)
{
	// Increase or decrease theese values to adjust r, g and b color channels seperately
	const float AvgLumR = 0.5;
	const float AvgLumG = 0.5;
	const float AvgLumB = 0.5;
	
	const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
	
	vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
	vec3 brtColor = color * brt;
	vec3 intensity = vec3(dot(brtColor, LumCoeff));
	vec3 satColor = mix(intensity, brtColor, sat);
	vec3 conColor = mix(AvgLumin, satColor, con);
	return conColor;
}


/*
** Float blending modes
** Adapted from here: http://www.nathanm.com/photoshop-blending-math/
** But I modified the HardMix (wrong condition), Overlay, SoftLight, ColorDodge, ColorBurn, VividLight, PinLight (inverted layers) ones to have correct results
*/

#define BlendLinearDodgef 			BlendAddf
#define BlendLinearBurnf 			BlendSubstractf
#define BlendAddf(base, blend) 		min(base + blend, 1.0)
#define BlendSubstractf(base, blend) 	max(base + blend - 1.0, 0.0)
#define BlendLightenf(base, blend) 		max(blend, base)
#define BlendDarkenf(base, blend) 		min(blend, base)
#define BlendLinearLightf(base, blend) 	(blend < 0.5 ? BlendLinearBurnf(base, (2.0 * blend)) : BlendLinearDodgef(base, (2.0 * (blend - 0.5))))
#define BlendScreenf(base, blend) 		(1.0 - ((1.0 - base) * (1.0 - blend)))
#define BlendOverlayf(base, blend) 	(base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)))
#define BlendSoftLightf(base, blend) 	((blend < 0.5) ? (2.0 * base * blend + base * base * (1.0 - 2.0 * blend)) : (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend)))
#define BlendColorDodgef(base, blend) 	((blend == 1.0) ? blend : min(base / (1.0 - blend), 1.0))
#define BlendColorBurnf(base, blend) 	((blend == 0.0) ? blend : max((1.0 - ((1.0 - base) / blend)), 0.0))
#define BlendVividLightf(base, blend) 	((blend < 0.5) ? BlendColorBurnf(base, (2.0 * blend)) : BlendColorDodgef(base, (2.0 * (blend - 0.5))))
#define BlendPinLightf(base, blend) 	((blend < 0.5) ? BlendDarkenf(base, (2.0 * blend)) : BlendLightenf(base, (2.0 *(blend - 0.5))))
#define BlendHardMixf(base, blend) 	((BlendVividLightf(base, blend) < 0.5) ? 0.0 : 1.0)
#define BlendReflectf(base, blend) 		((blend == 1.0) ? blend : min(base * base / (1.0 - blend), 1.0))


/*
** Vector3 blending modes
*/

// Component wise blending
#define Blend(base, blend, funcf) 		vec3(funcf(base.r, blend.r), funcf(base.g, blend.g), funcf(base.b, blend.b))

#define BlendNormal(base, blend) 		(blend)
#define BlendLighten				BlendLightenf
#define BlendDarken				BlendDarkenf
#define BlendMultiply(base, blend) 		(base * blend)
#define BlendAverage(base, blend) 		((base + blend) / 2.0)
#define BlendAdd(base, blend) 		min(base + blend, vec3(1.0))
#define BlendSubstract(base, blend) 	max(base + blend - vec3(1.0), vec3(0.0))
#define BlendDifference(base, blend) 	abs(base - blend)
#define BlendNegation(base, blend) 	(vec3(1.0) - abs(vec3(1.0) - base - blend))
#define BlendExclusion(base, blend) 	(base + blend - 2.0 * base * blend)
#define BlendScreen(base, blend) 		Blend(base, blend, BlendScreenf)
#define BlendOverlay(base, blend) 		Blend(base, blend, BlendOverlayf)
#define BlendSoftLight(base, blend) 	Blend(base, blend, BlendSoftLightf)
#define BlendHardLight(base, blend) 	BlendOverlay(blend, base)
#define BlendColorDodge(base, blend) 	Blend(base, blend, BlendColorDodgef)
#define BlendColorBurn(base, blend) 	Blend(base, blend, BlendColorBurnf)
#define BlendLinearDodge			BlendAdd
#define BlendLinearBurn			BlendSubstract
// Linear Light is another contrast-increasing mode
// If the blend color is darker than midgray, Linear Light darkens the image by decreasing the brightness. If the blend color is lighter than midgray, the result is a brighter image due to increased brightness.
#define BlendLinearLight(base, blend) 	Blend(base, blend, BlendLinearLightf)
#define BlendVividLight(base, blend) 	Blend(base, blend, BlendVividLightf)
#define BlendPinLight(base, blend) 		Blend(base, blend, BlendPinLightf)
#define BlendHardMix(base, blend) 		Blend(base, blend, BlendHardMixf)
#define BlendReflect(base, blend) 		Blend(base, blend, BlendReflectf)
#define BlendGlow(base, blend) 		BlendReflect(blend, base)
#define BlendPhoenix(base, blend) 		(min(base, blend) - max(base, blend) + vec3(1.0))
#define BlendOpacity(base, blend, F, O) 	(F(base, blend) * O + blend * (1.0 - O))


// Hue Blend mode creates the result color by combining the luminance and saturation of the base color with the hue of the blend color.
vec3 BlendHue(vec3 base, vec3 blend)
{
	vec3 baseHSL = RGBToHSL(base);
	return HSLToRGB(vec3(RGBToHSL(blend).r, baseHSL.g, baseHSL.b));
}

// Saturation Blend mode creates the result color by combining the luminance and hue of the base color with the saturation of the blend color.
vec3 BlendSaturation(vec3 base, vec3 blend)
{
	vec3 baseHSL = RGBToHSL(base);
	return HSLToRGB(vec3(baseHSL.r, RGBToHSL(blend).g, baseHSL.b));
}

// Color Mode keeps the brightness of the base color and applies both the hue and saturation of the blend color.
vec3 BlendColor(vec3 base, vec3 blend)
{
	vec3 blendHSL = RGBToHSL(blend);
	return HSLToRGB(vec3(blendHSL.r, blendHSL.g, RGBToHSL(base).b));
}

// Luminosity Blend mode creates the result color by combining the hue and saturation of the base color with the luminance of the blend color.
vec3 BlendLuminosity(vec3 base, vec3 blend)
{
	vec3 baseHSL = RGBToHSL(base);
	return HSLToRGB(vec3(baseHSL.r, baseHSL.g, RGBToHSL(blend).b));
}


/*
** Gamma correction
** Details: http://blog.mouaif.org/2009/01/22/photoshop-gamma-correction-shader/
*/

#define GammaCorrection(color, gamma)								pow(color, 1.0 / gamma)

/*
** Levels control (input (+gamma), output)
** Details: http://blog.mouaif.org/2009/01/28/levels-control-shader/
*/

#define LevelsControlInputRange(color, minInput, maxInput)				min(max(color - vec3(minInput), vec3(0.0)) / (vec3(maxInput) - vec3(minInput)), vec3(1.0))
#define LevelsControlInput(color, minInput, gamma, maxInput)				GammaCorrection(LevelsControlInputRange(color, minInput, maxInput), gamma)
#define LevelsControlOutputRange(color, minOutput, maxOutput) 			mix(vec3(minOutput), vec3(maxOutput), color)
#define LevelsControl(color, minInput, gamma, maxInput, minOutput, maxOutput) 	LevelsControlOutputRange(LevelsControlInput(color, minInput, gamma, maxInput), minOutput, maxOutput)

uniform sampler2D texture0;

varying vec2 uvVarying;

uniform vec2 agk_resolution;

int getPixel(int x, int y)
{
	if (texture2D(texture0, uvVarying + vec2(x, y)/agk_resolution.xy).r > 0.5)
		return 1;
	else
		return 0;
}

void main()
{
    int sum = getPixel(-1, -1) +
              getPixel(-1,  0) +
              getPixel(-1,  1) +
              getPixel( 0, -1) +
              getPixel( 0,  1) +
              getPixel( 1, -1) +
              getPixel( 1,  0) +
              getPixel( 1,  1);

	float current = float(getPixel(0, 0));
	 
	vec4 finalColor = vec4(0.0);
    if (sum == 3)
        finalColor = vec4(1.0);
	else if (sum == 2)
        finalColor = vec4(current, current, current, 1.0);
	else
        finalColor = vec4(0.0, 0.0, 0.0, 1.0);
	
	gl_FragColor = finalColor;
}

// Project: RTS new fow system 
// Created: 15.02.2018

/*

	Alex Schmidt,  online-arts.de

	Fog of War System that only uses one Render Image
	(Inb4 it used four render images...)
	
	The old system broke down during an update of AGK. Based on changes in the display aspect of render passes. 
	I took the chance to improve the performance, even if I fixed the old system...
	
	The new one works really well even with a 512x512 map. 
	It saves over 800 fps on my machine with syncrate = 0 and runs at about 2300fps
	This gives you the change to put more stuff in your game!
	
	Beware:
		Global DisplayX = 1024 
		Global DisplayY = 768
	
	are quite important, as the renderer changes the virtual resolution, you can replace the vars with your own
	
	
	
	Usage:
	
	You can create a Fog of War render pass like that:
	
		fowsys = CreateFogOfWarImageRender(512,512)

	And if you want to render an update, call:
	
		UpdateFogOfWarImageRender(fowsys)
		
	
	In between those commands, you update your unit positions and save their position in an array.
	Then you pass it to the Fog of war system:
	
		list as Vec3_2dUnit_def[0]
		list[0].px# = 100
		list[0].py# = 100
		list[0].size# = 32


		SetFogOfWarUnitDrawList( fowsys, list)
	
	this will be used, right before you call UpdateFogOfWarImageRender(fowsys)

	The list array can contain as much units as you need.
	To improve the render pass, try to remove the "tmp_fad" sprite and do a custom fade, without a helper sprite 
	

*/


// show all errors
SetErrorMode(2)
SetClearColor(0,0,0)


Global DisplayX = 1920
Global DisplayY = 1080

// set window properties
SetWindowTitle( "RTS new fow system" )
SetWindowSize( DisplayX, DisplayY, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( DisplayX, DisplayY ) // doesn't have to match the window
SetOrientationAllowed( 0, 0, 1, 0 ) // allow both portrait and landscape on mobile devices

SetSyncRate(60,1)
SetScissor( 0,0,0,0 ) // use the maximum available screen space, no black borders
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts

type Vec3_2dUnit_def
	px# as float
	py# as float
	size# as float
endtype


type FogOfWar_def
	RenderImg as integer
	tmp_spr_img as integer
	tmp_spr as integer
	tmp_buf as integer
	tmp_fad as integer
	BuffX as integer
	BuffY as integer
	UnitDrawList as Vec3_2dUnit_def[]
	
endtype


// create circle shader

file = OpenToWrite("circle.ps")
WriteLine(file,"varying mediump vec2 uvVarying;varying mediump vec4 colorVarying;void main(){float i = 0.0;if(length(uvVarying*2.0-1.0) < 1.0) i = 1.0;gl_FragColor = vec4(vec3(1.0),colorVarying.a*i)*colorVarying ;}")
CloseFile(file)




fowsys = CreateFogOfWarImageRender(512,512)


list as Vec3_2dUnit_def[32]
for i=0 to 32

	list[i].px# = random(0,512)
	list[i].py# = random(0,512)
	list[i].size# = random(0,64)
next i


list[0].px# = 100
list[0].py# = 100
list[0].size# = 32


SetFogOfWarUnitDrawList( fowsys, list)




// background
sprbg = CreateSprite(CreateImageColor(20,20,100,255))
SetSpriteSize(sprbg,DisplayX,DisplayY)

// display the render image
spr = CreateSprite(FogOfWar_System[fowsys].RenderImg)
SetSpritePosition(spr,100,100)
SetSpriteSize(spr,512,512)




do




	// update first unit in temporary list with new position information
	t#=t#+0.1
	px# = 256+sin(t#*20.0)*(256-32)
	py# = 256+cos(t#*20.0)*(256-32)

if GetRawMouseLeftState()
	px# = GetPointerX()-100
	py# = GetPointerY()-100
endif

	list[0].px# = px#
	list[0].py# = py#
	// SetSpriteVisible(tmp_blend,1)
	SetFogOfWarUnitDrawList( fowsys, list) // update list to Fog of War render data


	UpdateFogOfWarImageRender(fowsys) // render call for the fow system


    Print( ScreenFPS() )
    Sync()
loop




function SetFogOfWarUnitDrawList( pos, unitlist as Vec3_2dUnit_def[] )
	FogOfWar_System[pos].UnitDrawList = unitlist
endfunction


function UpdateFogOfWarImageRender(pos)

	BuffX = FogOfWar_System[pos].BuffX
	BuffY = FogOfWar_System[pos].BuffY
	
	tmp_fad = FogOfWar_System[pos].tmp_fad
	tmp_buf = FogOfWar_System[pos].tmp_buf
	tmp_spr = FogOfWar_System[pos].tmp_spr
	img = FogOfWar_System[pos].RenderImg
	
	SetSpriteVisible(tmp_fad,1)
	SetSpriteVisible(tmp_buf,1)
	SetSpriteVisible(tmp_spr,1)

	SetRenderToImage(img,-1)
	SetVirtualResolution( BuffX,BuffY )

	// SetSpriteImage(tmp_buf,img2)
	SetSpriteAdditionalImage(tmp_buf,img,1)

	SetSpriteShader(tmp_buf,0)
	SetSpriteColor(tmp_buf,255,255,255,1)
	SetSpritePosition(tmp_buf,0,0)
	SetSpriteSize(tmp_buf,BuffX,BuffY)
	SetSpriteTransparency(tmp_buf,1)
	DrawSprite(tmp_fad)
	DrawSprite(tmp_buf)


	// SetSpriteColor(tmp_spr,255,255,255,255)

	for drawcall = 0 to FogOfWar_System[pos].UnitDrawList.length // draws a circle representing each unit view

		size# = FogOfWar_System[pos].UnitDrawList[drawcall].size#
		px# = FogOfWar_System[pos].UnitDrawList[drawcall].px#
		py# = FogOfWar_System[pos].UnitDrawList[drawcall].py#
		SetSpriteSize(tmp_spr,size#,size#)
		SetSpritePosition(tmp_spr,px#-size#/2,py#-size#/2)
		DrawSprite(tmp_spr)

	next drawcall


	SetSpriteVisible(tmp_fad,0)
	SetSpriteVisible(tmp_buf,0)
	SetSpriteVisible(tmp_spr,0)
	
	SetVirtualResolution( DisplayX, DisplayY )
	SetRenderToScreen()
	
	
	
endfunction






function CreateFogOfWarImageRender(BuffX,BuffY)

	if FogOfWar_System.length = -1
		Dim FogOfWar_System[] as FogOfWar_def
	endif
	
	pos = FogOfWar_System.length + 1
	FogOfWar_System.length = pos
	
	circle = LoadSpriteShader("circle.ps")
	img = CreateRenderImage(BuffX,BuffY,0,1)

	tmp_spr_img = CreateImageColor(255,255,255,255)
	tmp_spr = CreateSprite(tmp_spr_img)
	tmp_buf = CreateSprite(CreateImageColor(0,0,0,255))
	tmp_fad = createsprite(tmp_spr_img)
	SetSpriteSize(tmp_buf,BuffX,BuffY)
	SetSpriteSize(tmp_fad,BuffX,BuffY)
	SetSpriteColor(tmp_fad,0,0,0,1)
	SetSpriteSize(tmp_spr,32,32)
	SetSpriteTransparency(tmp_spr,1)
	SetSpriteShader(tmp_spr,circle)

	FogOfWar_System[pos].BuffX = BuffX
	FogOfWar_System[pos].BuffY = BuffY
	FogOfWar_System[pos].RenderImg = img
	FogOfWar_System[pos].tmp_buf =tmp_buf
	FogOfWar_System[pos].tmp_fad = tmp_fad
	FogOfWar_System[pos].tmp_spr = tmp_spr
	FogOfWar_System[pos].tmp_spr_img = tmp_spr_img

endfunction pos

bool onGridline(int distFrom, int spacing);
bool onSplitline(int distFrom, int spacing, int interval);
varying highp vec2 iMouse;
varying mediump vec2 uvVarying;
uniform highp vec2 Scale;

uniform sampler2D texture0;
 
varying highp vec3 posVarying;
varying mediump vec3 normalVarying;

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);

	// Colours , used to return to fragColor depending on criteria.
	const vec4 cBackground = vec4(0.0,0.0,0.0,0.0);			// Background colour.
	const vec4 cOrigin = vec4(0.0,0.392,0.392,1.0);			// Frag is directly in line with mouse's X or Y.
	const vec4 cLargeSplit = vec4(0.392,0.18,0.004,1.0);	// Frag is on a large split line.
	const vec4 cMedSplit = vec4(0.449,0.449,0.449,1.0);		// Frag is on a medium split line.
	const vec4 cGridline = vec4(0.293,0.293,0.293,1.0);		// Frag is on a grid line.
	
	// Grid lines
	const int spacingStd = 10;			// Spacing of normal grid lines
	const int intervalLargeSplit = 10;	// On how many gridlines a large split occurs.
	const int intervalMedSplit = 5;		// On how many gridlines a medium split occurs.
	const float zoom = 1.0;			// Zoom level of the grid.
	
	// Effective spacing
	// This is the standard grid spacing, as an integer, once zoom has been applied.
	// We do this here and use this value later to avoid float rounding errors.
	int effGrid = int(floor((float(spacingStd) * zoom) + 0.2));
	
	// Convenience integer values for resolution and frag position.
	int fragX = int((uvVarying.x-0.5)*Scale.x*10.0+(uvVarying.x-0.5));
	int fragY = int((uvVarying.y-0.5)*Scale.y*10.0+(uvVarying.y-0.5));

	
	// The offsets to the original mouse position were found by trial and error.
	int mouseX = int(iMouse.x);
	int mouseY = int(iMouse.y);
	
	// Distance this frag is from the mouse position, in each axis.
	int xDistFrom = int(abs(float(mouseX - fragX)));
	int yDistFrom = int(abs(float(mouseY - fragY)));
	
	// ============================================================
	
	// If on same X or Y as mouse, paint with origin colour.
	if ( fragX == mouseX || fragY == mouseY )
	{
		gl_FragColor = gl_FragColor*cOrigin;
		return;
	}
	
	// If on grid line, decide which colour to paint.
	else if ( onGridline(xDistFrom, effGrid) || onGridline(yDistFrom, effGrid) )
	{
		// If on large split line, choose this first.
		if ( onSplitline(xDistFrom, effGrid, intervalLargeSplit) ||
		     onSplitline(yDistFrom, effGrid, intervalLargeSplit))
		{
			gl_FragColor = gl_FragColor*cLargeSplit;
			return;
		}
		
		// Then check medium split line.
		else if ( onSplitline(xDistFrom, effGrid, intervalMedSplit) ||
		     onSplitline(yDistFrom, effGrid, intervalMedSplit))
		{
			gl_FragColor = gl_FragColor*cMedSplit;
			return;
		}
		
		// Otherwise, return normal grid line colour.
		else
		{
			gl_FragColor = gl_FragColor*cGridline;
			return;
		}
	}
	
	// Fragment is not in line with any grid line - paint as background.
	gl_FragColor = gl_FragColor*vec4(0.0, 0.0, 0.0, 0.0);
}


bool onGridline(int distFrom, int spacing)
{
	return mod(float(distFrom), float(spacing)) == 0.0;
}


bool onSplitline(int distFrom, int spacing, int interval)
{
	int newSpacing = spacing * interval;
	
	return mod(float(distFrom), float(newSpacing)) == 0.0;
}

       image = LoadImage("SkyHigh.jpg")
	Geosphere = CreateObjectSphere(100,100.0,100.0)
	SetObjectCullMode(Geosphere,2)
	SetObjectLightMode(Geosphere,0)
	SetObjectColor(Geosphere,0,0,0,255)
        SetobjectImage(Geosphere,image,0)