Sorry your browser is not supported!

// Project: 1st shader 
// Created: 2018-08-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "1st shader" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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


createshader()

chunk = CreateObjectBox(5,5,5)
vs=LoadShader("chunk.vs","chunk.ps")
SetObjectRotation(chunk,0,45,0)
SetObjectShader(chunk,vs)



do
	time#=timer()
	SetObjectShaderConstantByName(chunk,"u_time",time#,0,0,0)
    

    Print( ScreenFPS() )
    Sync()
loop

function createshader()
	// standard vertex shader from AGK
	
	fw = OpenToWrite("chunk.vs")
	WriteLine(fw,"attribute highp vec3 position;")
	WriteLine(fw,"attribute mediump vec3 normal;")
	WriteLine(fw,"varying highp vec3 posVarying;")
	WriteLine(fw,"varying mediump vec3 normalVarying;")
	WriteLine(fw,"varying mediump vec3 lightVarying;")
	WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
	WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
	WriteLine(fw,"uniform highp mat4 agk_World;")
	WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
	WriteLine(fw,"attribute highp vec2 uv;")
	WriteLine(fw,"varying highp vec2 uvVarying;")
	WriteLine(fw,"uniform highp vec4 uvBounds0;")
	
	WriteLine(fw,"void main()")
	WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
	WriteLine(fw,"}")
	CloseFile(fw)


// My own pixel shader
	fw = OpenToWrite("chunk.ps")
	WriteLine(fw,"#ifdef GL_ES")
	WriteLine(fw,"precision mediump float;")
	WriteLine(fw,"#endif")
	WriteLine(fw,"uniform float u_time;")
	WriteLine(fw,"void main() {")
	WriteLine(fw,"gl_FragColor = vec4(abs(sin(u_time)),0.0,0.0,1.0);")
	WriteLine(fw,"}")
	CloseFile(fw)
	
	
	
endfunction

// Project: 1st shader 
// Created: 2018-08-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "1st shader" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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


createshader()

chunk = CreateObjectBox(5,5,5)
vs=LoadShader("chunk.vs","chunk.ps")
SetObjectRotation(chunk,0,45,0)
SetObjectShader(chunk,vs)

x#=0
y#=0
do
	SetObjectShaderConstantByName(chunk,"u_resolution",x#,y#,0,0)
    
    if fadedown = 1
		dec x#,50
		dec y#,50
	endif
	
	if fadedown = 0
		inc x#,50
		inc y#,50
	endif
	
	if x#>1000
		x#=1000
		fadedown = 1
    endif
    if x#<0 
		x#=0
		fadedown=0
	endif
	
    
    Print( ScreenFPS() )
    Sync()
loop

function createshader()
	// standard vertex shader from AGK
	
	fw = OpenToWrite("chunk.vs")
	WriteLine(fw,"attribute highp vec3 position;")
	WriteLine(fw,"attribute mediump vec3 normal;")
	WriteLine(fw,"varying highp vec3 posVarying;")
	WriteLine(fw,"varying mediump vec3 normalVarying;")
	WriteLine(fw,"varying mediump vec3 lightVarying;")
	WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
	WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
	WriteLine(fw,"uniform highp mat4 agk_World;")
	WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
	WriteLine(fw,"attribute highp vec2 uv;")
	WriteLine(fw,"varying highp vec2 uvVarying;")
	WriteLine(fw,"uniform highp vec4 uvBounds0;")
	
	WriteLine(fw,"void main()")
	WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
	WriteLine(fw,"}")
	CloseFile(fw)


// My own pixel shader
	fw = OpenToWrite("chunk.ps")
	WriteLine(fw,"#ifdef GL_ES")
	WriteLine(fw,"precision mediump float;")
	WriteLine(fw,"#endif")
	WriteLine(fw,"uniform vec2 u_resolution;")
	writeline(fw,"uniform vec2 u_mouse;")
	WriteLine(fw,"uniform float u_time;")
	WriteLine(fw,"void main() {")
	WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_resolution;")
	WriteLine(fw,"gl_FragColor = vec4(st.x,st.y,0.0,1.0);")

	WriteLine(fw,"}")
	CloseFile(fw)
	
	
endfunction

// Project: 1st shader 
// Created: 2018-08-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "1st shader" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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


createshader()

chunk = CreateObjectBox(5,5,5)
vs=LoadShader("chunk.vs","chunk.ps")
SetObjectRotation(chunk,0,45,0)
SetObjectShader(chunk,vs)

x#=0
y#=0
do
	SetObjectShaderConstantByName(chunk,"u_mouse",getpointerx(),getpointery(),0,0)
    
    if fadedown = 1
		dec x#,50
		dec y#,50
	endif
	
	if fadedown = 0
		inc x#,50
		inc y#,50
	endif
	
	if x#>1000
		x#=1000
		fadedown = 1
    endif
    if x#<0 
		x#=0
		fadedown=0
	endif
	
    
    Print( ScreenFPS() )
    Sync()
loop

function createshader()
	// standard vertex shader from AGK
	
	fw = OpenToWrite("chunk.vs")
	WriteLine(fw,"attribute highp vec3 position;")
	WriteLine(fw,"attribute mediump vec3 normal;")
	WriteLine(fw,"varying highp vec3 posVarying;")
	WriteLine(fw,"varying mediump vec3 normalVarying;")
	WriteLine(fw,"varying mediump vec3 lightVarying;")
	WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
	WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
	WriteLine(fw,"uniform highp mat4 agk_World;")
	WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
	WriteLine(fw,"attribute highp vec2 uv;")
	WriteLine(fw,"varying highp vec2 uvVarying;")
	WriteLine(fw,"uniform highp vec4 uvBounds0;")
	
	WriteLine(fw,"void main()")
	WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
	WriteLine(fw,"}")
	CloseFile(fw)


// My own pixel shader
	fw = OpenToWrite("chunk.ps")
	WriteLine(fw,"#ifdef GL_ES")
	WriteLine(fw,"precision mediump float;")
	WriteLine(fw,"#endif")
	WriteLine(fw,"uniform vec2 u_resolution;")
	writeline(fw,"uniform vec2 u_mouse;")
	WriteLine(fw,"uniform float u_time;")
	WriteLine(fw,"void main() {")
	WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_mouse;")
	WriteLine(fw,"gl_FragColor = vec4(st.x,st.y,0.0,1.0);")

	WriteLine(fw,"}")
	CloseFile(fw)
	
	
endfunction

// Project: 1st shader 
// Created: 2018-08-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "1st shader" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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



createshader()

chunk = CreateObjectBox(10,10,10)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("chunk.vs","chunk.ps")
SetObjectRotation(chunk,0,45,0)
SetObjectShader(chunk,vs)
a=1
z#=10
do
    
	x#=x#+5 * sin(a)
	y#=y#+5 * cos(a)

	SetObjectShaderConstantByName(chunk,"u_resolution",x#,y#,z#,0)
    inc a,1
    
    Print( ScreenFPS() )
    Sync()
loop

function createshader()
	// standard vertex shader from AGK
	
	fw = OpenToWrite("chunk.vs")
	WriteLine(fw,"attribute highp vec3 position;")
	WriteLine(fw,"attribute mediump vec3 normal;")
	WriteLine(fw,"varying highp vec3 posVarying;")
	WriteLine(fw,"varying mediump vec3 normalVarying;")
	WriteLine(fw,"varying mediump vec3 lightVarying;")
	WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
	WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
	WriteLine(fw,"uniform highp mat4 agk_World;")
	WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
	WriteLine(fw,"attribute highp vec2 uv;")
	WriteLine(fw,"varying highp vec2 uvVarying;")
	WriteLine(fw,"uniform highp vec4 uvBounds0;")
	
	WriteLine(fw,"void main()")
	WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
	WriteLine(fw,"}")
	CloseFile(fw)

 


// My own pixel shader
	fw = OpenToWrite("chunk.ps")
	
	
	WriteLine(fw,"#ifdef GL_ES")
	WriteLine(fw,"precision mediump float;")
	WriteLine(fw,"#endif")

	WriteLine(fw,"uniform vec2 u_resolution;")
	WriteLine(fw,"uniform vec2 u_mouse;")
	WriteLine(fw,"uniform float u_time;")

	WriteLine(fw,"float random (in vec2 st) {")
    WriteLine(fw,"return fract(sin(dot(st.xy,")
                         WriteLine(fw,"vec2(12.9898,78.233)))*")
    WriteLine(fw,"43758.5453123);")
	WriteLine(fw,"}")

	WriteLine(fw,"float noise (in vec2 st) {")
    WriteLine(fw,"vec2 i = floor(st);")
    WriteLine(fw,"vec2 f = fract(st);")

    // Four corners in 2D of a tile
    WriteLine(fw,"float a = random(i);")
    WriteLine(fw,"float b = random(i + vec2(1.0, 0.0));")
    WriteLine(fw,"float c = random(i + vec2(0.0, 1.0));")
    WriteLine(fw,"float d = random(i + vec2(1.0, 1.0));")

	WriteLine(fw,"    vec2 u = f * f * (3.0 - 2.0 * f);")

	WriteLine(fw,"    return mix(a, b, u.x) +")
    WriteLine(fw,"(c - a)* u.y * (1.0 - u.x) +")
    WriteLine(fw,"(d - b) * u.x * u.y;")
	WriteLine(fw,"}")

	WriteLine(fw,"#define OCTAVES 6")
	WriteLine(fw,"float fbm (in vec2 st) {")
    // Initial values
    WriteLine(fw,"float value = 0.0;")
    WriteLine(fw,"float amplitude = .5;")
    WriteLine(fw,"float frequency = 0.;")
    //
    // Loop of octaves")
    WriteLine(fw,"for (int i = 0; i < OCTAVES; i++) {")
        WriteLine(fw,"value += amplitude * noise(st);")
        WriteLine(fw,"st *= 2.;")
        WriteLine(fw,"amplitude *= .5;")
    WriteLine(fw,"}")
    WriteLine(fw,"return value;")
	WriteLine(fw,"}")

	WriteLine(fw,"void main() {")
    WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_resolution.xy;")
    WriteLine(fw,"st.x *= u_resolution.x/u_resolution.y;")

    WriteLine(fw,"vec3 color = vec3(0.0);")
    WriteLine(fw,"color += fbm(st*3.0);")

    WriteLine(fw,"gl_FragColor = vec4(color,1.0);")
	WriteLine(fw,"}")	
	
	
	
	CloseFile(fw)	
endfunction

// Project: 1st shader 
// Created: 2018-08-10

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "1st shader" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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



//createshader()

chunk = CreateObjectPlane(60,60)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("chunk.vs","chunk.ps")
SetObjectRotation(chunk,0,45,0)
SetObjectShader(chunk,vs)
a=1
x#=400
y#=200
z#=1
do
    
	x#=x#+.5
	y#=200

	SetObjectShaderConstantByName(chunk,"u_resolution",x#,y#,z#,0)
    inc a,10
    print (x#)
    print (y#)
    print (z#)
    Print( ScreenFPS() )
    Sync()
loop

function createshader()
	// standard vertex shader from AGK
	
	fw = OpenToWrite("chunk.vs")
	WriteLine(fw,"attribute highp vec3 position;")
	WriteLine(fw,"attribute mediump vec3 normal;")
	WriteLine(fw,"varying highp vec3 posVarying;")
	WriteLine(fw,"varying mediump vec3 normalVarying;")
	WriteLine(fw,"varying mediump vec3 lightVarying;")
	WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
	WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
	WriteLine(fw,"uniform highp mat4 agk_World;")
	WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
	WriteLine(fw,"attribute highp vec2 uv;")
	WriteLine(fw,"varying highp vec2 uvVarying;")
	WriteLine(fw,"uniform highp vec4 uvBounds0;")
	
	WriteLine(fw,"void main()")
	WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
	WriteLine(fw,"}")
	CloseFile(fw)

 


// My own pixel shader
	fw = OpenToWrite("chunk.ps")
	
	
	WriteLine(fw,"#ifdef GL_ES")
	WriteLine(fw,"precision mediump float;")
	WriteLine(fw,"#endif")

	WriteLine(fw,"uniform vec2 u_resolution;")
	WriteLine(fw,"uniform vec2 u_mouse;")
	WriteLine(fw,"uniform float u_time;")

	WriteLine(fw,"float random (in vec2 st) {")
    WriteLine(fw,"return fract(sin(dot(st.xy,")
                         WriteLine(fw,"vec2(12.9898,78.233)))*")
    WriteLine(fw,"43758.5453123);")
	WriteLine(fw,"}")

	WriteLine(fw,"float noise (in vec2 st) {")
    WriteLine(fw,"vec2 i = floor(st);")
    WriteLine(fw,"vec2 f = fract(st);")

    // Four corners in 2D of a tile
    WriteLine(fw,"float a = random(i);")
    WriteLine(fw,"float b = random(i + vec2(1.0, 0.0));")
    WriteLine(fw,"float c = random(i + vec2(0.0, 1.0));")
    WriteLine(fw,"float d = random(i + vec2(1.0, 1.0));")

	WriteLine(fw,"    vec2 u = f * f * (3.0 - 2.0 * f);")

	WriteLine(fw,"    return mix(a, b, u.x) +")
    WriteLine(fw,"(c - a)* u.y * (1.0 - u.x) +")
    WriteLine(fw,"(d - b) * u.x * u.y;")
	WriteLine(fw,"}")

	WriteLine(fw,"#define OCTAVES 6")
	WriteLine(fw,"float fbm (in vec2 st) {")
    // Initial values
    WriteLine(fw,"float value = 0.0;")
    WriteLine(fw,"float amplitude = .5;")
    WriteLine(fw,"float frequency = 0.;")
    //
    // Loop of octaves")
    WriteLine(fw,"for (int i = 0; i < OCTAVES; i++) {")
        WriteLine(fw,"value += amplitude * noise(st);")
        WriteLine(fw,"st *= 2.;")
        WriteLine(fw,"amplitude *= .5;")
    WriteLine(fw,"}")
    WriteLine(fw,"return value;")
	WriteLine(fw,"}")

	WriteLine(fw,"void main() {")
    WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_resolution.xy;")
    WriteLine(fw,"st.x *= u_resolution.x/u_resolution.y;")

    WriteLine(fw,"vec3 color = vec3(0.0);")
    WriteLine(fw,"color += fbm(st*3.0);")

    WriteLine(fw,"gl_FragColor = vec4(color,1.0);")
	WriteLine(fw,"}")	
	
	
	
	CloseFile(fw)	
endfunction

// Project: skies 
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "skies" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 0, 0 ) // 30fps instead of 60 to save battery
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


createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(100,100)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("skies.vs","skies.ps")
SetObjectRotation(chunk,-60,0,0)
SetObjectShader(chunk,vs)
x#=400
y#=200
do
     
    x#=x#+.1
    SetObjectShaderConstantByName(chunk,"u_resolution",x#,y#,0,0)
    Print( ScreenFPS() )
    Sync()
loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("skies.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()
	
	fw = OpenToWrite("skies.ps")




WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"uniform vec2 u_resolution;")
WriteLine(fw,"uniform vec2 u_mouse;")
WriteLine(fw,"uniform float u_time;")

WriteLine(fw,"float random (in vec2 _st) {")
    WriteLine(fw,"return fract(sin(dot(_st.xy,")
                         WriteLine(fw,"vec2(12.9898,78.233)))*")
        WriteLine(fw,"43758.5453123);")
WriteLine(fw,"}")

// Based on Morgan McGuire @morgan3d
// https://www.shadertoy.com/view/4dS3Wd
WriteLine(fw,"float noise (in vec2 _st) {")
    WriteLine(fw,"vec2 i = floor(_st);")
    WriteLine(fw,"vec2 f = fract(_st);")

    // Four corners in 2D of a tile
    WriteLine(fw,"float a = random(i);")
    WriteLine(fw,"float b = random(i + vec2(1.0, 0.0));")
    WriteLine(fw,"float c = random(i + vec2(0.0, 1.0));")
    WriteLine(fw,"float d = random(i + vec2(1.0, 1.0));")

    WriteLine(fw,"vec2 u = f * f * (3.0 - 2.0 * f);")

    WriteLine(fw,"return mix(a, b, u.x) +")
            WriteLine(fw,"(c - a)* u.y * (1.0 - u.x) +")
            WriteLine(fw,"(d - b) * u.x * u.y;")
WriteLine(fw,"}")

WriteLine(fw,"#define NUM_OCTAVES 5")

WriteLine(fw,"float fbm ( in vec2 _st) {")
    WriteLine(fw,"float v = 0.0;")
    WriteLine(fw,"float a = 0.5;")
    WriteLine(fw,"vec2 shift = vec2(100.0);")
    // Rotate to reduce axial bias
    WriteLine(fw,"mat2 rot = mat2(cos(0.5), sin(0.5),")
                    WriteLine(fw,"-sin(0.5), cos(0.50));")
    WriteLine(fw,"for (int i = 0; i < NUM_OCTAVES; ++i) {")
        WriteLine(fw,"v += a * noise(_st);")
        WriteLine(fw,"_st = rot * _st * 2.0 + shift;")
        WriteLine(fw,"a *= 0.5;")
    WriteLine(fw,"}")
    WriteLine(fw,"return v;")
WriteLine(fw,"}")

WriteLine(fw,"void main() {")
    WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_resolution.xy*3.;")
    // st += st * abs(sin(u_time*0.1)*3.0);
WriteLine(fw,"    vec3 color = vec3(0.0);")

    WriteLine(fw,"vec2 q = vec2(0.);")
    WriteLine(fw,"q.x = fbm( st + 0.00*u_time);")
    WriteLine(fw,"q.y = fbm( st + vec2(1.0));")

WriteLine(fw,"    vec2 r = vec2(0.);")
    WriteLine(fw,"r.x = fbm( st + 1.0*q + vec2(1.7,9.2)+ 0.15*u_time );")
    WriteLine(fw,"r.y = fbm( st + 1.0*q + vec2(8.3,2.8)+ 0.126*u_time);")

    WriteLine(fw,"float f = fbm(st+r);")

    WriteLine(fw,"color = mix(vec3(0.101961,0.619608,0.666667),")
                WriteLine(fw,"vec3(0.666667,0.666667,0.498039),")
                WriteLine(fw,"clamp((f*f)*4.0,0.0,1.0));")

    WriteLine(fw,"color = mix(color,")
                WriteLine(fw,"vec3(0,0,0.164706),")
                WriteLine(fw,"clamp(length(q),0.0,1.0));")

    WriteLine(fw,"color = mix(color,")
                WriteLine(fw,"vec3(0.666667,1,1),")
                WriteLine(fw,"clamp(length(r.x),0.0,1.0));")

    WriteLine(fw,"gl_FragColor = vec4((f*f*f+.6*f*f+.5*f)*color,1.);")
WriteLine(fw,"}")
	

	CloseFile(fw)

endfunction

// Project: cellularnoise 
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "cellularnoise" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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


createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(100,100)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("cellular.vs","cellular.ps")
SetObjectRotation(chunk,-60,0,0)
SetObjectShader(chunk,vs)
do
     
    SetObjectShaderConstantByName(chunk,"u_resolution",getpointerx(),getpointery(),0,0)
    Print( ScreenFPS() )
    Sync()
loop


// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("cellular.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction


function createPSshaderFile()
	
	fw = OpenToWrite("cellular.ps")
	WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"uniform vec2 u_resolution;")
WriteLine(fw,"uniform vec2 u_mouse;")
WriteLine(fw,"uniform float u_time;")

WriteLine(fw,"vec2 random2( vec2 p ) {")
    WriteLine(fw,"return fract(sin(vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3))))*43758.5453);")
WriteLine(fw,"}")

WriteLine(fw,"void main() {")
    WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_resolution.xy;")
    WriteLine(fw,"st.x *= u_resolution.x/u_resolution.y;")
    WriteLine(fw,"vec3 color = vec3(.0);")

    // Scale
WriteLine(fw,"    st *= 3.;")

    // Tile the space
WriteLine(fw,"    vec2 i_st = floor(st);")
    WriteLine(fw,"vec2 f_st = fract(st);")

    WriteLine(fw,"float m_dist = 1.;  // minimun distance")

    WriteLine(fw,"for (int y= -1; y <= 1; y++) {")
        WriteLine(fw,"for (int x= -1; x <= 1; x++) {")
            // Neighbor place in the grid
WriteLine(fw,"            vec2 neighbor = vec2(float(x),float(y));")

            // Random position from current + neighbor place in the grid
            WriteLine(fw,"vec2 point = random2(i_st + neighbor);")

			// Animate the point
            WriteLine(fw,"point = 0.5 + 0.5*sin(u_time + 6.2831*point);")

			// Vector between the pixel and the point
            WriteLine(fw,"vec2 diff = neighbor + point - f_st;")

            // Distance to the point
            WriteLine(fw,"float dist = length(diff);")

            // Keep the closer distance
WriteLine(fw,"            m_dist = min(m_dist, dist);")
    WriteLine(fw,"    }")
    WriteLine(fw,"}")

    // Draw the min distance (distance field)
    WriteLine(fw,"color += m_dist;")

    // Draw cell center
    WriteLine(fw,"color += 1.-step(.02, m_dist);")

    // Draw grid
    WriteLine(fw,"color.r += step(.98, f_st.x) + step(.98, f_st.y);")

    // Show isolines
    // color -= step(.7,abs(sin(27.0*m_dist)))*.5;

    WriteLine(fw,"gl_FragColor = vec4(color,1.0);")
WriteLine(fw,"}")
CloseFile(fw)
endfunction

// Project: noise 
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "noise" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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


createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(100,100)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("noise.vs","noise.ps")
SetObjectShader(chunk,vs)
do
     
    SetObjectShaderConstantByName(chunk,"u_resolution",getpointerx(),getpointery(),0,0)
    Print( ScreenFPS() )
    Sync()
loop

// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("noise.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction



function createPSshaderFile()
	
	fw=OpenToWrite("noise.ps")
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"uniform vec2 u_resolution;")
WriteLine(fw,"uniform vec2 u_mouse;")
WriteLine(fw,"uniform float u_time;")

WriteLine(fw,"void main() {")
    WriteLine(fw,"vec2 st = gl_FragCoord.xy/u_resolution.xy;")
    WriteLine(fw,"st.x *= u_resolution.x/u_resolution.y;")

    WriteLine(fw,"vec3 color = vec3(.0);")

    // Cell positions
    WriteLine(fw,"vec2 point[5];")
    WriteLine(fw,"point[0] = vec2(0.83,0.75);")
    WriteLine(fw,"point[1] = vec2(0.60,0.07);")
    WriteLine(fw,"point[2] = vec2(0.28,0.64);")
    WriteLine(fw,"point[3] =  vec2(0.31,0.26);")
    WriteLine(fw,"point[4] = u_mouse/u_resolution;")

    WriteLine(fw,"float m_dist = 1.;  // minimun distance")
    WriteLine(fw,"vec2 m_point;        // minimum position")

    // Iterate through the points positions
    WriteLine(fw,"for (int i = 0; i < 5; i++) {")
        WriteLine(fw,"float dist = distance(st, point[i]);")
        WriteLine(fw,"if ( dist < m_dist ) {")
            // Keep the closer distance
            WriteLine(fw,"m_dist = dist;")

            // Kepp the position of the closer point
            WriteLine(fw,"m_point = point[i];")
        WriteLine(fw,"}")
    WriteLine(fw,"}")

    // Add distance field to closest point center
WriteLine(fw,"    color += m_dist*2.;")

    // tint acording the closest point position
    WriteLine(fw,"color.rg = m_point;")

    // Show isolines
    WriteLine(fw,"color -= abs(sin(80.0*m_dist))*0.07;")

    // Draw point center
    WriteLine(fw,"color += 1.-step(.02, m_dist);")

    WriteLine(fw,"gl_FragColor = vec4(color,1.0);")
WriteLine(fw,"}")
	CloseFile(fw)
	endfunction

// Project: water 
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "water" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(1000,1000)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("water.vs","water.ps")
SetObjectShader(chunk,vs)

do
	time#=time#+100
    SetObjectShaderConstantByName(chunk,"resolution",time#,time#,0,0)

	if time#>10000 then time#=0
//    SetObjectShaderConstantByName(chunk,"resolution",1000,1000,0,0)
    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("water.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("water.ps")
	
	
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")
WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 resolution;")
WriteLine(fw,"const float count = 10.0;")
WriteLine(fw,"float Hash( vec2 p, in float s ){")
    WriteLine(fw,"return fract(sin(dot(vec3(p.xy,10.0 * abs(sin(s))),vec3(27.1,61.7, 12.4)))*273758.5453123);")
WriteLine(fw,"}")

WriteLine(fw,"float noise(in vec2 p, in float s)")
WriteLine(fw,"{")
    WriteLine(fw,"vec2 i = floor(p);")
    WriteLine(fw,"vec2 f = fract(p);")
    WriteLine(fw,"f *= f * (3.0-2.0*f);")
    WriteLine(fw,"return mix(mix(Hash(i + vec2(0.,0.), s), Hash(i + vec2(1.,0.), s),f.x),mix(Hash(i + vec2(0.,1.), s), Hash(i + vec2(1.,1.), s),f.x),f.y) * s;")
WriteLine(fw,"}")

WriteLine(fw,"float fbm(vec2 p)")
WriteLine(fw,"{")
     WriteLine(fw,"float v = 0.0;")
     WriteLine(fw,"v += noise(p*1., 0.35);")
     WriteLine(fw,"v += noise(p*2., 0.25);")
     WriteLine(fw,"v += noise(p*4., 0.125);")
     WriteLine(fw,"v += noise(p*8., 0.0625);")
     WriteLine(fw,"return v;")
WriteLine(fw,"}")

WriteLine(fw,"void main( void ) ")
WriteLine(fw,"{")

	WriteLine(fw,"vec2 uv = ( gl_FragCoord.xy / resolution.xy ) * 2.0 - 1.0;")
	WriteLine(fw,"uv.x *= resolution.x/resolution.y;")

	WriteLine(fw,"vec3 finalColor = vec3( 0.0 );")
	
		WriteLine(fw,"float t = abs(1.0 / ((uv.x + fbm( uv + time)) * (50.0)));")
		WriteLine(fw,"finalColor +=  t * vec3( 0.375 +0.1, 0.5, 2.0 );")
	
	
WriteLine(fw,"	gl_FragColor = vec4( finalColor, 1.0 );")

WriteLine(fw,"}")	
	
CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(1000,1000)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)


do
    SetObjectShaderConstantByName(chunk,"resolution",1200,1000,100,100)




    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	
	WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")
WriteLine(fw,"uniform float time;")
	WriteLine(fw,"uniform vec3 resolution;")
	WriteLine(fw,"uniform vec2 mouse;")

	WriteLine(fw,"float r (float x) {")
		WriteLine(fw,"return  sin(x)/2. + sin(x/3.)*1.5 + sin(x*3.)/6.;")
	WriteLine(fw,"}")

	WriteLine(fw,"void main(void)")
WriteLine(fw,"{")
    WriteLine(fw,"vec2 p = gl_FragCoord.xy / resolution.xy * 2.0 - 1.0;")
	WriteLine(fw,"p.y *= .7;")

WriteLine(fw,"    vec2 uv = vec2(-1.2+p.x/abs(p.y), 1.0/p.y);")
    WriteLine(fw,"float t = time * 1.;")
    WriteLine(fw,"uv.y -= t;")

WriteLine(fw,"    vec3 col = vec3(0.45, 0.6, 1.0);")
    WriteLine(fw,"float rx = r (uv.y);")
    WriteLine(fw,"float by = -11.;")
    WriteLine(fw,"by -= t;")
    WriteLine(fw,"float rx2 = r (by);")
    WriteLine(fw,"rx += rx2;")
    WriteLine(fw,"rx -= 1.;")
    WriteLine(fw,"float rw = 1.0;")
    WriteLine(fw,"if (p.y < 0.0)")
    WriteLine(fw,"{")
        WriteLine(fw,"mod(uv.y, 2.) >= 1. ? col = vec3(0., 1., 0.) : col = vec3(0., 0.9, 0.);")
	    WriteLine(fw,"if (uv.x >= rx-rw-0.1 && uv.x <= rx+rw+0.1) { mod(uv.y, 0.4) >= 0.2 ? col = vec3(1.) : col = vec3(0.9, 0., 0.); }")
        WriteLine(fw,"if (uv.x >= rx-rw && uv.x <= rx+rw) col = vec3(0.3);")
        WriteLine(fw,"if (uv.x >= rx-0.025 && uv.x <= rx+0.025 && mod(uv.y, 1.) >= 0.5) col = vec3(1.0, 0.8, 0.);")
	WriteLine(fw,"col = mix(vec3(0.45, 0.6, 1.0), col, min(1., abs(pow(p.y*8., 4.))));")
    WriteLine(fw,"}")
    WriteLine(fw,"gl_FragColor = vec4(col, 1.0);")
WriteLine(fw,"}")
CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(1000,1000)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
   SetObjectShaderConstantByName(chunk,"mouse",1,1,0,0)
timex#=0
timey#=0

do
    SetObjectShaderConstantByName(chunk,"resolution",timex#,timey#,0,0)

	timex#=timex#+1
	timey#=timey#+1



    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 resolution;")

WriteLine(fw,"const float Tau		= 3.2832;")
WriteLine(fw,"const float speed	= -.02;")
WriteLine(fw,"const float density	= .04;")
WriteLine(fw,"const float shape	= .04;")

WriteLine(fw,"float random( vec2 seed ) {")
	WriteLine(fw,"return fract(sin(seed.x+seed.y*1e3)*1e5);")
WriteLine(fw,"}")

WriteLine(fw,"float Cell(vec2 coord) {")
	WriteLine(fw,"vec2 cell = fract(coord) * vec2(.5,2.) - vec2(.0,.5);")
	WriteLine(fw,"return (1.-length(cell*2.-1.))*step(random(floor(coord)),density)*2.;")
WriteLine(fw,"}")

WriteLine(fw,"void main( void ) {")

	WriteLine(fw,"vec2 p = gl_FragCoord.xy / resolution  - mouse;")
	
	WriteLine(fw,"float a = fract(atan(p.x, p.y) / Tau);")
	WriteLine(fw,"float d = length(p);")
	
	WriteLine(fw,"vec2 coord = vec2(pow(d, shape), a)*256.;")
	WriteLine(fw,"vec2 delta = vec2(-time*speed*256., .5);")
	
	WriteLine(fw,"float c = 0.;")
	WriteLine(fw,"for(int i=0; i<3; i++) {")
		WriteLine(fw,"coord += delta;")
		WriteLine(fw,"c = max(c, Cell(coord));")
	WriteLine(fw,"}")
	WriteLine(fw,"vec4 final =  vec4(c*d);")
	
	WriteLine(fw,"gl_FragColor = final * vec4(1.0,0.2,0.5,1.0);")
WriteLine(fw,"}")


CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(1000,1000)
SetObjectColor(chunk,255,0,0,255)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
timex#=1000
timey#=500

do
    SetObjectShaderConstantByName(chunk,"resolution",timex#,timey#,0,0)


    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"#extension GL_OES_standard_derivatives : enable")

WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 resolution;")

//-------------------------------------------------------
WriteLine(fw,"#define line(d) smoothstep(.85, .95, cos(d))")
WriteLine(fw,"#define BASE vec3(0., .5, .9)")
WriteLine(fw,"#define BG vec3(0., 0., .3)")

WriteLine(fw,"void main(void) {")
	WriteLine(fw,"float T = time;")
	WriteLine(fw,"vec2  R = resolution;")
	WriteLine(fw,"vec2  I = gl_FragCoord.xy;")
	WriteLine(fw,"vec2 uv = (2. * I - R) / R.y;")
	WriteLine(fw,"float t = 1. / length(uv.y);")
	WriteLine(fw,"vec2 st = uv * t + vec2(0., t + T);")
	WriteLine(fw,"st *= 2.;")
	WriteLine(fw,"vec2 gv = fract(st) - .5;")
	WriteLine(fw,"vec3 color = vec3(.1, 0., .1);")
	WriteLine(fw,"color *= 1. - smoothstep(.5, 1., length(gv));")
	WriteLine(fw,"color += .6 / line(gv.y) * BASE;")
	WriteLine(fw,"color += .5 / line(gv.x) * BASE;")
	WriteLine(fw,"color *= -uv.y;")
	WriteLine(fw,"gl_FragColor = vec4(color, 1.);")
WriteLine(fw,"}")

CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(60,60)
SetObjectColor(chunk,255,0,0,255)
SetObjectRotation(chunk,100,0,0)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
a=1
SetObjectShaderConstantByName(chunk,"mouse",0,0,0,0)

do
	
	x#=10 * sin(a)
	y#=10 * cos(a)
	inc a
	SetObjectShaderConstantByName(chunk,"resolution",500+timer()*x#,500+timer()*y#,0,0)
	
    SetObjectShaderConstantByName(chunk,"time",timer(),0,0,0)

    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision highp float;")
WriteLine(fw,"#endif")

WriteLine(fw,"#extension GL_OES_standard_derivatives : enable")

WriteLine(fw,"#define HOW_CLOUDY 0.4")
WriteLine(fw,"#define SHADOW_THRESHOLD 0.2")
WriteLine(fw,"#define SHADOW 0.2")
WriteLine(fw,"#define SUBSURFACE 1.0")
WriteLine(fw,"#define WIND_DIRECTION 5.0")
WriteLine(fw,"#define TIME_SCALE 0.6")
WriteLine(fw,"#define SCALE 0.3")
WriteLine(fw,"#define ENABLE_SHAFTS")

WriteLine(fw,"#define iGlobalTime time")
WriteLine(fw,"#define iMouse (mouse.xy * resolution.xy)")
WriteLine(fw,"#define iResolution resolution")

WriteLine(fw,"mat2 RM = mat2(cos(WIND_DIRECTION), -sin(WIND_DIRECTION), sin(WIND_DIRECTION), cos(WIND_DIRECTION));")
WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 resolution;")

WriteLine(fw,"float hash( float n )")
WriteLine(fw,"{")
    WriteLine(fw,"return fract(sin(n)*758.5453);")
WriteLine(fw,"}")

WriteLine(fw,"float noise( in vec3 x )")
WriteLine(fw,"{")
    WriteLine(fw,"vec3 p = floor(x);")
    WriteLine(fw,"vec3 f = fract(x); ")
    WriteLine(fw,"float n = p.x + p.y*57.0 + p.z*800.0;")
    WriteLine(fw,"float res = mix(mix(mix( hash(n+  0.0), hash(n+  1.0),f.x), mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y),")
		    WriteLine(fw,"mix(mix( hash(n+800.0), hash(n+801.0),f.x), mix( hash(n+857.0), hash(n+858.0),f.x),f.y),f.z);")
    WriteLine(fw,"return res;")
WriteLine(fw,"}")

WriteLine(fw,"float fbm( vec3 p )")
WriteLine(fw,"{")
    WriteLine(fw,"float f = 0.0;")
    WriteLine(fw,"f += 0.50000*noise( p ); p = p*2.02;")
    WriteLine(fw,"f -= 0.25000*noise( p ); p = p*2.03;")
    WriteLine(fw,"f += 0.12500*noise( p ); p = p*3.01;")
    WriteLine(fw,"f += 0.06250*noise( p ); p = p*3.04;")
    WriteLine(fw,"f += 0.03500*noise( p ); p = p*4.01;")
    WriteLine(fw,"f += 0.01250*noise( p ); p = p*4.04;")
    WriteLine(fw,"f -= 0.00125*noise( p );")
    WriteLine(fw,"return f/0.984375;")
WriteLine(fw,"}")

WriteLine(fw,"float cloud(vec3 p)")
WriteLine(fw,"{")
	WriteLine(fw,"p-=fbm(vec3(p.x,p.y,0.0)*0.5)*1.25;")
	WriteLine(fw,"float a = min((fbm(p*3.0)*2.2-1.1), 0.0);")
	WriteLine(fw,"return a*a;")
WriteLine(fw,"}")

WriteLine(fw,"float shadow = 1.0;")


WriteLine(fw,"float clouds(vec2 p){")
	WriteLine(fw,"float ic = cloud(vec3(p * 2.0, iGlobalTime*0.01 * TIME_SCALE)) / HOW_CLOUDY;")
	WriteLine(fw,"float init = smoothstep(0.1, 1.0, ic) * 10.0;")
	WriteLine(fw,"shadow = smoothstep(0.0, SHADOW_THRESHOLD, ic) * SHADOW + (1.0 - SHADOW);")
	WriteLine(fw,"init = (init * cloud(vec3(p * (6.0), iGlobalTime*0.01 * TIME_SCALE)) * ic);")
	WriteLine(fw,"init = (init * (cloud(vec3(p * (11.0), iGlobalTime*0.01 * TIME_SCALE))*0.5 + 0.4) * init);")
	WriteLine(fw,"return min(1.0, init);")
WriteLine(fw,"}")
WriteLine(fw,"float cloudslowres(vec2 p){")
	WriteLine(fw,"float ic = 1.0 - cloud(vec3(p * 2.0, iGlobalTime*0.01 * TIME_SCALE)) / HOW_CLOUDY;")
	WriteLine(fw,"float init = smoothstep(0.1, 1.0, ic) * 1.0;")
	WriteLine(fw,"return min(5.0, init);")
WriteLine(fw,"}")

WriteLine(fw,"vec2 ratio = vec2(1.0, 1.0);")

WriteLine(fw,"vec3 getresult(){")
	WriteLine(fw,"vec2 surfacePosition = ((( gl_FragCoord.xy / iResolution.xy ) * vec2(iResolution.x / iResolution.y, 1.0)) * 2.0 - 1.0)*SCALE;")
	WriteLine(fw,"vec2 position = RM*( surfacePosition);")
	WriteLine(fw,"vec2 sun = RM * ((iMouse.xy/ iResolution.xy)* vec2(iResolution.x / iResolution.y, 1.0)*2.0-1.0) * SCALE;")
	WriteLine(fw,"float dst = distance(sun * ratio, position * ratio);")
	WriteLine(fw,"float suni = pow(dst + 1.0, -10.0);")
	WriteLine(fw,"float shaft =0.0;")
	WriteLine(fw,"float st = 1.0;")
	WriteLine(fw,"vec2 dir = sun - position;")
	WriteLine(fw,"float c = clouds(position);")
	WriteLine(fw,"#ifdef ENABLE_SHAFTS")
	WriteLine(fw,"for(int i=0;i<20;i++){")
		WriteLine(fw,"float occl = cloudslowres(position + dir * st);")
		WriteLine(fw,"st *= 0.8;")
		WriteLine(fw,"shaft += max(0.0, (1.0 - occl));")
	WriteLine(fw,"}")
	WriteLine(fw,"#endif")
    WriteLine(fw,"shadow = min(1.0, shadow + suni * suni * 0.2 * SUBSURFACE);")
	WriteLine(fw,"suni *= (shaft * 0.1);")
	WriteLine(fw,"return pow(mix(vec3(shadow), pow(vec3(0.23, 0.33, 0.48), vec3(2.2)) + suni, c), vec3(1.0/2.2));		")
WriteLine(fw,"}")
 
WriteLine(fw,"void main( void ) {")
	WriteLine(fw,"gl_FragColor = getresult().xyzz;")
WriteLine(fw,"}")	
	
	CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(60,60)
SetObjectColor(chunk,255,0,0,255)
SetObjectRotation(chunk,0,0,0)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
a=1
SetObjectShaderConstantByName(chunk,"mouse",0,0,0,0)

do
	
	x#=10 * sin(a)
	y#=10 * cos(a)
	inc a
	SetObjectShaderConstantByName(chunk,"resolution",500+timer()*x#,500+timer()*y#,0,0)
	
    SetObjectShaderConstantByName(chunk,"time",timer(),0,0,0)

    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	

WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"#extension GL_OES_standard_derivatives : enable")

WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 resolution;")

WriteLine(fw,"#define m(x) mod(x + 1., 2.) - 1.")

WriteLine(fw,"float atan2(vec2 v) {")
	WriteLine(fw,"return atan(v.y, v.x);")
WriteLine(fw,"}")

WriteLine(fw,"void main(void) {")
	WriteLine(fw,"float t = time, k = .0, a = 0.;")
	WriteLine(fw,"vec2 R = resolution;")
	WriteLine(fw,"vec2 u = (2. * gl_FragCoord.xy - R) / R.y;")
	WriteLine(fw,"vec3 o = vec3(0., 1., t), d = vec3(u, 1.), p;")
	WriteLine(fw,"vec3 color;")
	WriteLine(fw,"for (int c = 0; c < 3; c++) {")
		WriteLine(fw,"t += .1;")
		WriteLine(fw,"for (int i = 0; i < 32; i++) {")
			WriteLine(fw,"p = o + d * k;")
			WriteLine(fw,"a = 1.5 * sin(p.x / 5. + t / 2.) * sin(p.z / 10. + t / 100.);")
			WriteLine(fw,"float y = (.5 * a) * sin(t + 4. * p.z) * sin(t + 2. * p.x);")
			WriteLine(fw,"k += .5 * min(")
				WriteLine(fw,"2. - dot(vec3(p.x, p.y + y, p.z), vec3(0., 1., 0.)),")
				WriteLine(fw,"dot(vec3(p.x, p.y + y, p.z), vec3(0., 1., 0.))")
			WriteLine(fw,");")
		WriteLine(fw,"}")
		WriteLine(fw,"color[c] = (1. / k + float(c) / 3. - k / 100.);")
	WriteLine(fw,"}")
	WriteLine(fw,"color = mix(color, vec3(1. - 1. / k, sin(p.x / 10. + 2. + t), sin(a + t)), k / 50.);")
	WriteLine(fw,"gl_FragColor = vec4(color, 1.);")
WriteLine(fw,"}")	
	CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(60,60)
SetObjectColor(chunk,255,0,0,255)
SetObjectRotation(chunk,0,0,0)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
a=1
SetObjectShaderConstantByName(chunk,"mouse",0,0,0,0)

do
	
	x#=10 * sin(a)
	y#=10 * cos(a)
	inc a
	SetObjectShaderConstantByName(chunk,"resolution",500+timer()*x#,500+timer()*y#,0,0)
	
    SetObjectShaderConstantByName(chunk,"time",timer(),0,0,0)

    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	

WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

// glslsandbox uniforms
WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 resolution;")

// shadertoy globals
WriteLine(fw,"float iTime = 0.0;")
WriteLine(fw,"vec3  iResolution = vec3(0.0);")

// --------[ Original ShaderToy begins here ]---------- //
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"const float dMax = 28.0;")

// Simple noise algorithm contributed by Trisomie21 (Thanks!)
WriteLine(fw,"float snoise( vec2 p ) {")
	WriteLine(fw,"vec2 f = fract(p);")
	WriteLine(fw,"p = floor(p);")
	WriteLine(fw,"float v = p.x+p.y*1000.0;")
	WriteLine(fw,"vec4 r = vec4(v, v+1.0, v+1000.0, v+1001.0);")
	WriteLine(fw,"r = fract(100000.0*sin(r*.001));")
	WriteLine(fw,"f = f*f*(3.0-2.0*f);")
	WriteLine(fw,"return 2.0*(mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y))-1.0;")
WriteLine(fw,"}")

WriteLine(fw,"float terrain( vec2 p, int octaves ) {	")
	WriteLine(fw,"float h = 0.0; // height")
	WriteLine(fw,"float w = 0.5; // octave weight")
	WriteLine(fw,"float m = 0.4; // octave multiplier")
	WriteLine(fw,"for (int i=0; i<16; i++) {")
		WriteLine(fw,"if (i<octaves) {")
			WriteLine(fw,"h += w * snoise((p * m));")
		WriteLine(fw,"}")
		WriteLine(fw,"else break;")
		WriteLine(fw,"w *= 0.5;")
		WriteLine(fw,"m *= 2.0;")
	WriteLine(fw,"}")
	WriteLine(fw,"return h;")
WriteLine(fw,"}")

WriteLine(fw,"vec2 map( vec3 p, int octaves ) {")
	
	WriteLine(fw,"float dMin = dMax; // nearest intersection")
	WriteLine(fw,"float d; // depth")
	WriteLine(fw,"float mID = -1.0; // material ID")
	
	// terrain
	WriteLine(fw,"float h = terrain(p.xz, octaves);")
	WriteLine(fw,"h += smoothstep(-0.3, 1.5, h); // exaggerate the higher terrain")
	WriteLine(fw,"h *= smoothstep(-1.5, -0.3, h); // smooth out the lower terrain")
	WriteLine(fw,"d = p.y - h;	")
	WriteLine(fw,"if (d<dMin) { ")
		WriteLine(fw,"dMin = d;")
		WriteLine(fw,"mID = 0.0;")
	WriteLine(fw,"}")
	
	// trees
	WriteLine(fw,"if (h<0.0) { // no need to check for trees at higher elevations")
		WriteLine(fw,"float f = terrain(p.xz*15.0, octaves);")
		WriteLine(fw,"f = (0.1*f) - 0.3; // limit the altitude of the trees")
		WriteLine(fw,"d = p.y - f;")
		WriteLine(fw,"if (d<dMin) { ")
			WriteLine(fw,"dMin = d;")
			WriteLine(fw,"mID = 1.0;")
		WriteLine(fw,"}")
	WriteLine(fw,"}	")

	WriteLine(fw,"return vec2(dMin, mID);")
WriteLine(fw,"}")

WriteLine(fw,"vec2 castRay( vec3 ro, vec3 rd, int octaves) {")
	WriteLine(fw,"const float p = 0.0001; // precision")
	WriteLine(fw,"float t = 0.0; // distance")
	WriteLine(fw,"float h = p * 2.0; // step")
	WriteLine(fw,"float m = -1.0;")
	WriteLine(fw,"for (int i=0; i<34; i++) {")
		WriteLine(fw,"if (abs(h)>p || t<dMax ) {")
			WriteLine(fw,"t += h; // next step")
			WriteLine(fw,"vec2 res = map(ro + rd*t, octaves); // get intersection")
			WriteLine(fw,"h = res.x; // get distance")
			WriteLine(fw,"m = res.y; // get material")
		WriteLine(fw,"} ")
		WriteLine(fw,"else break;")
	WriteLine(fw,"}")
	WriteLine(fw,"if (t>dMax) m = -1.0; // if no intersection, material ID is -1.0;")
	WriteLine(fw,"return vec2(t, m);")
WriteLine(fw,"}")

WriteLine(fw,"vec3 calcNormal( vec3 p, int octaves) {")
	WriteLine(fw,"const vec3 eps = vec3(0.0005, 0.0, 0.0);")
	WriteLine(fw,"return normalize( vec3(map(p+eps.xyy, octaves).x - map(p-eps.xyy, octaves).x,")
WriteLine(fw,"			       map(p+eps.yxy, octaves).x - map(p-eps.yxy, octaves).x,")
			       WriteLine(fw,"map(p+eps.yyx, octaves).x - map(p-eps.yyx, octaves).x) );")
WriteLine(fw,"}")

WriteLine(fw,"float shadows( vec3 ro, vec3 rd, float tMax, float k, int octaves ) {")
    WriteLine(fw,"float res = 1.0;")
	WriteLine(fw,"float t = 0.001;")
	WriteLine(fw,"for(int i=0; i<5; i++) {")
WriteLine(fw,"        if (t<tMax) {")
			WriteLine(fw,"float h = map(ro + rd*t, octaves).x;")
        	WriteLine(fw,"res = min( res, k*h/t );")
        	WriteLine(fw,"t += h;")
		WriteLine(fw,"}")
		WriteLine(fw,"else break;")
    WriteLine(fw,"}")
    WriteLine(fw,"return clamp(res, 0.0, 1.0);")
WriteLine(fw,"}")

WriteLine(fw,"vec3 render( vec3 ro, vec3 rd ) {")
	WriteLine(fw,"const int geoLOD = 4;")
	
	WriteLine(fw,"vec3 color = vec3(0.5,0.5,0.5); // base color is fog color")
	WriteLine(fw,"vec2 res = castRay(ro, rd, geoLOD);")
	
WriteLine(fw,"	vec3 lPos = normalize( vec3(0.5, 0.5, 0.5) ); // light position")
	WriteLine(fw,"vec3 lCol = vec3(1.0, 0.9, 0.8); // yellowish light")
	
	// mat -1 = background/sky
	WriteLine(fw,"if (res.y < -0.5) {")
		WriteLine(fw,"float sun = clamp(dot(rd,lPos),0.0,1.0);")
		WriteLine(fw,"color += 0.2 * lCol * sun*sun;")
		WriteLine(fw,"return color;")
	WriteLine(fw,"}")
	
	WriteLine(fw,"int norLOD = int(max(2.0, 12.0-11.0*res.x/dMax));")
	
	WriteLine(fw,"vec3 pos = ro + rd*res.x; // terrain pos")
	WriteLine(fw,"vec3 nor = calcNormal(pos, norLOD); // terrain normals")
	
	// mat 0 = terrain
	WriteLine(fw,"if (res.y>-0.5&&res.y<0.5) {")
		
		// base rock colors
		WriteLine(fw,"color = mix( vec3(0.2, 0.2, 0.2), vec3(0.25, 0.2, 0.15), smoothstep(0.7, 1.0, nor.y) );")
		
		// layer noise (to produdce lighter color bands of rock)
		WriteLine(fw,"float n = 0.5*(snoise(pos.xy*vec2(2.0, 40.0))+1.0);")
		// rock layers should show most where nomals are NOT straight up
		WriteLine(fw,"color = mix( n*vec3(0.5, 0.4, 0.4), color, nor.y ); ")
		
		// grass & moss grows thickest where normals are straight up
		WriteLine(fw,"color = mix( color, vec3(0.0, 0.05, -0.05), smoothstep(0.7, 0.9, nor.y) );")
		
		// add in lighting and shadows
		WriteLine(fw,"float lAmb = clamp( 0.5 + 0.5 * nor.y, 0.0, 1.0); // ambient")
		WriteLine(fw,"float lDif = clamp( dot( nor, lPos ), 0.0, 2.0); // diffuse")
		
		// shadow octaves should match geometry octaves used in initial ray cast
		WriteLine(fw,"if (lDif>0.05) lDif *= shadows(pos, lPos, 1.0, 1.0, geoLOD);")
		
		WriteLine(fw,"color += (0.2*lAmb) * lCol;")
		WriteLine(fw,"color *= (1.2*lDif) * lCol;	")
	WriteLine(fw,"}")
	//.mat 1 = trees
	WriteLine(fw,"if (res.y>0.5) {")
		WriteLine(fw,"color = mix( vec3(0.15, 0.05, 0.0), vec3(0.05, 0.1, 0.0), smoothstep(0.0, 0.7, nor.y) );")
		
		// add in lighting and shadows
		WriteLine(fw,"float lAmb = clamp( 0.5 + 0.5 * nor.y, 0.0, 1.0); // ambient")
		WriteLine(fw,"float lDif = clamp( dot( nor, lPos ), 0.0, 2.0); // diffuse")
		
		// shadow octaves should match geometry octaves used in initial ray cast
		WriteLine(fw,"if (lDif>0.05) lDif *= shadows(pos, lPos, 1.0, 1.0, geoLOD);")
		
		WriteLine(fw,"color += (0.2*lAmb) * lCol;")
		WriteLine(fw,"color *= (1.2*lDif) * lCol;")
WriteLine(fw,"	}")
	
	// fog
	WriteLine(fw,"float n = smoothstep(-1.2, -0.2, terrain(pos.xz, 3)); // valley fog")
	WriteLine(fw,"float fog = exp(-0.01 * res.x*res.x); // exponentioal fog equation")
	WriteLine(fw,"color = mix(vec3(0.5,0.5,0.5), color, n*fog); // add fog in valleys and distance")
		
	WriteLine(fw,"return color;")
WriteLine(fw,"}")

WriteLine(fw,"void mainImage( out vec4 fragColor, in vec2 fragCoord ) {")

	WriteLine(fw,"vec2 pos = 2.0 * ( fragCoord.xy / iResolution.xy ) - 1.0; // bound screen coords to [0, 1]")
	WriteLine(fw,"pos.x *= iResolution.x / iResolution.y; // correct for aspect ratio")

	// camera
	WriteLine(fw,"float x = 5.0 + (0.2*iTime);")
	WriteLine(fw,"float y = 0.0;")
	WriteLine(fw,"float z = 0.0 + 3.0*sin(0.1*iTime);")
	WriteLine(fw,"vec3 cPos = vec3(x, y, z); // position")
	WriteLine(fw,"cPos.y = terrain(cPos.xz, 1) + 1.5;")
	
WriteLine(fw,"	const vec3 cUp = vec3(0., 1., 0.); // up ")
	WriteLine(fw,"vec3 cLook = vec3(cPos.x + 1.0, cPos.y*0.7, 0.0); // lookAt")
	
	// camera matrix
	WriteLine(fw,"vec3 ww = normalize( cLook-cPos );")
	WriteLine(fw,"vec3 uu = normalize( cross(ww, cUp) );")
	WriteLine(fw,"vec3 vv = normalize( cross(uu, ww) );")
	
	WriteLine(fw,"vec3 rd = normalize( pos.x*uu + pos.y*vv + 2.0*ww );")
	
	// render")
	WriteLine(fw,"vec3 color = render(cPos, rd);")
	
	WriteLine(fw,"fragColor = vec4( color, 1.0 );")
WriteLine(fw,"}")

WriteLine(fw,"void main(void)")
WriteLine(fw,"{")
    WriteLine(fw,"iTime = time;")
    WriteLine(fw,"iResolution = vec3(resolution, 0.0);")

WriteLine(fw,"    mainImage(gl_FragColor, gl_FragCoord.xy);")
WriteLine(fw,"}")




	CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(60,60)
SetObjectColor(chunk,255,0,0,255)
SetObjectRotation(chunk,0,0,0)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
a=1
SetObjectShaderConstantByName(chunk,"mouse",0,0,0,0)

do
	
	x#=10 * sin(a)
	y#=10 * cos(a)
	inc a
	SetObjectShaderConstantByName(chunk,"resolution",500+timer()*x#,500+timer()*y#,0,0)
	
    SetObjectShaderConstantByName(chunk,"time",timer(),0,0,0)

    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	

WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 resolution;")

WriteLine(fw,"#define OCT 7")
WriteLine(fw,"#define ITER 192")
WriteLine(fw,"#define EPS 0.001")
WriteLine(fw,"#define NEAR .3")
WriteLine(fw,"#define FAR 16.")

WriteLine(fw,"vec3 rotX(vec3 p,float a){return vec3(p.x,p.y*cos(a)-p.z*sin(a),p.y*sin(a)+p.z*cos(a));}")
WriteLine(fw,"vec3 rotY(vec3 p,float a){return vec3(p.x*cos(a)-p.z*sin(a),p.y,p.x*sin(a)+p.z*cos(a));}")
WriteLine(fw,"vec3 rotZ(vec3 p,float a){return vec3(p.x*cos(a)-p.y*sin(a), p.x*sin(a)+p.y*cos(a), p.z);}")
WriteLine(fw,"vec3 hsv(float h,float s,float v){return ((clamp(abs(fract(h+vec3(0.,.666,.333))*6.-3.)-1.,0.,111.)-1.)*s+1.)*v;}")

WriteLine(fw,"float map(vec3 p){float r=1.,lr=0.,s=1.;;p=rotX(p,time*.15);p=rotZ(p,time*.111);p.xy+=vec2(3.4,9.3);p.z+=time;")
	WriteLine(fw,"for(int i=0;i<OCT;i++){vec3 q=clamp(sin(p),.25,1.);r=max(lr,.3-dot(q,q));lr=r;s*=1.11;p*=s;}")
	WriteLine(fw,"return r;}")

WriteLine(fw,"float trace(vec3 ro,vec3 rd,out float n){float t=NEAR,d;")
	WriteLine(fw,"for(int i=0;i<ITER;i++){d=map(ro+rd*t);if(abs(d)<EPS||t>FAR)break;t+=step(d,1.)*d*.2+d*.5;n+=1.;}")
	WriteLine(fw,"return min(t,FAR);}")

WriteLine(fw,"void main(void){")
	WriteLine(fw,"vec2 uv=(gl_FragCoord.xy-.5*resolution.xy)/resolution.y;")
	WriteLine(fw,"vec3 rd=vec3(uv,-.5);")
	WriteLine(fw,"float n=0.,v=1.-trace(vec3(0),rd,n)/FAR;n/=float(ITER);")
	WriteLine(fw,"gl_FragColor=vec4(mix(hsv(v,n,.92),vec3(1),n)*n,1);")
WriteLine(fw,"}")



	CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(60,60)
SetObjectColor(chunk,255,0,0,255)
SetObjectRotation(chunk,90,0,0)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
a=1
SetObjectShaderConstantByName(chunk,"resolution",1024,768,0,0)

    SetObjectShaderConstantByName(chunk,"mouse",359,277,0,0)
	
do
	
	SetObjectShaderConstantByName(chunk,"time",timer(),0,0,0)

	
    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")
	

WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")

WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 resolution;")

//afl_ext 2018

WriteLine(fw,"#define DRAG_MULT 0.048")
WriteLine(fw,"#define ITERATIONS_RAYMARCH 10")
WriteLine(fw,"#define ITERATIONS_NORMAL 48")
WriteLine(fw,"#define WATER_DEPTH 2.1")

WriteLine(fw,"#define Mouse (mouse.xy)")
WriteLine(fw,"#define Resolution (resolution.xy)")
WriteLine(fw,"#define Time (time)")

// returns vec2 with wave height in X and its derivative in Y
WriteLine(fw,"vec2 wavedx(vec2 position, vec2 direction, float speed, float frequency, float timeshift) {")
    WriteLine(fw,"direction = normalize(direction);")
    WriteLine(fw,"float x = dot(direction, position) * frequency + timeshift * speed;")
    WriteLine(fw,"float wave = exp(sin(x) - 1.0);")
    WriteLine(fw,"float dx = wave * cos(x);")
    WriteLine(fw,"return vec2(wave, - dx);")
WriteLine(fw,"}")

// dynamic loops not supported on glslsandbox")
WriteLine(fw,"float getwavesLowRes(vec2 position, int iterations){")
    WriteLine(fw,"position *= 0.1;")
	WriteLine(fw,"float iter = 0.0;")
    WriteLine(fw,"float phase = 6.0;")
    WriteLine(fw,"float speed = 2.0;")
    WriteLine(fw,"float weight = 1.0;")
    WriteLine(fw,"float w = 0.0;")
    WriteLine(fw,"float ws = 0.0;")
    WriteLine(fw,"for(int i=0;i<ITERATIONS_RAYMARCH;i++){")
        WriteLine(fw,"vec2 p = vec2(sin(iter), cos(iter));")
        WriteLine(fw,"vec2 res = wavedx(position, p, speed, phase, Time);")
        WriteLine(fw,"position += normalize(p) * res.y * weight * DRAG_MULT;")
        WriteLine(fw,"w += res.x * weight;")
        WriteLine(fw,"iter += 12.0;")
        WriteLine(fw,"ws += weight;")
        WriteLine(fw,"weight = mix(weight, 0.0, 0.2);")
        WriteLine(fw,"phase *= 1.18;")
        WriteLine(fw,"speed *= 1.07;")
    WriteLine(fw,"}")
    WriteLine(fw,"return w / ws;")
WriteLine(fw,"}")

WriteLine(fw,"float getwaves(vec2 position, int iterations){")
    WriteLine(fw,"position *= 0.1;")
	WriteLine(fw,"float iter = 0.0;")
    WriteLine(fw,"float phase = 6.0;")
    WriteLine(fw,"float speed = 2.0;")
    WriteLine(fw,"float weight = 1.0;")
    WriteLine(fw,"float w = 0.0;")
    WriteLine(fw,"float ws = 0.0;")
    WriteLine(fw,"for(int i=0;i<ITERATIONS_NORMAL;i++){")
        WriteLine(fw,"vec2 p = vec2(sin(iter), cos(iter));")
        WriteLine(fw,"vec2 res = wavedx(position, p, speed, phase, Time);")
        WriteLine(fw,"position += normalize(p) * res.y * weight * DRAG_MULT;")
        WriteLine(fw,"w += res.x * weight;")
        
        WriteLine(fw,"iter += 12.0;")
        WriteLine(fw,"ws += weight;")
        WriteLine(fw,"weight = mix(weight, 0.0, 0.2);")
        WriteLine(fw,"phase *= 1.18;")
        WriteLine(fw,"speed *= 1.07;")
    WriteLine(fw,"}")
    WriteLine(fw,"return w / ws;")
WriteLine(fw,"}")

WriteLine(fw,"float raymarchwater(vec3 camera, vec3 start, vec3 end, float depth){")
    WriteLine(fw,"vec3 pos = start;")
    WriteLine(fw,"float h = 0.0;")
    WriteLine(fw,"float hupper = depth;")
    WriteLine(fw,"float hlower = 0.0;")
    WriteLine(fw,"vec2 zer = vec2(0.0);")
    WriteLine(fw,"vec3 dir = normalize(end - start);")
    WriteLine(fw,"for(int i=0;i<318;i++){")
        WriteLine(fw,"h = getwavesLowRes(pos.xz, ITERATIONS_RAYMARCH) * depth - depth;")
        WriteLine(fw,"if(h + 0.01 > pos.y) {")
            WriteLine(fw,"return distance(pos, camera);")
        WriteLine(fw,"}")
        WriteLine(fw,"pos += dir * (pos.y - h);")
WriteLine(fw,"    }")
    WriteLine(fw,"return -1.0;")
WriteLine(fw,"}")



WriteLine(fw,"float H = 0.0;")
WriteLine(fw,"vec3 normal(vec2 pos, float e, float depth){")
    WriteLine(fw,"vec2 ex = vec2(e, 0);")
    WriteLine(fw,"H = getwaves(pos.xy, ITERATIONS_NORMAL) * depth;")
    WriteLine(fw,"vec3 a = vec3(pos.x, H, pos.y);")
    WriteLine(fw,"return normalize(cross(normalize(a-vec3(pos.x - e, getwaves(pos.xy - ex.xy, ITERATIONS_NORMAL) * depth, pos.y)), ")
                           WriteLine(fw,"normalize(a-vec3(pos.x, getwaves(pos.xy + ex.yx, ITERATIONS_NORMAL) * depth, pos.y + e))));")
WriteLine(fw,"}")
WriteLine(fw,"mat3 rotmat(vec3 axis, float angle)")
WriteLine(fw,"{")
    WriteLine(fw,"axis = normalize(axis);")
    WriteLine(fw,"float s = sin(angle);")
    WriteLine(fw,"float c = cos(angle);")
    WriteLine(fw,"float oc = 1.0 - c;")
    WriteLine(fw,"return mat3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s, ")
    WriteLine(fw,"oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s, ")
    WriteLine(fw,"oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c);")
WriteLine(fw,"}")

WriteLine(fw,"vec3 getRay(vec2 uv){")
    WriteLine(fw,"uv = (uv * 2.0 - 1.0) * vec2(Resolution.x / Resolution.y, 1.0);")
	WriteLine(fw,"vec3 proj = normalize(vec3(uv.x, uv.y, 1.0) + vec3(uv.x, uv.y, -1.0) * pow(length(uv), 2.0) * 0.05);	")
    WriteLine(fw,"if(Resolution.x < 800.0) return proj;")
    WriteLine(fw,"vec3 ray = rotmat(vec3(0.0, -1.0, 0.0), 3.0 * (Mouse.x * 2.0 - 1.0)) * rotmat(vec3(1.0, 0.0, 0.0), 1.5 * (Mouse.y * 2.0 - 1.0)) * proj;")
    WriteLine(fw,"return ray;")
WriteLine(fw,"}")

WriteLine(fw,"float intersectPlane(vec3 origin, vec3 direction, vec3 point, vec3 normal)")
WriteLine(fw,"{ ")
    WriteLine(fw,"return clamp(dot(point - origin, normal) / dot(direction, normal), -1.0, 9991999.0); ")
WriteLine(fw,"}")

WriteLine(fw,"vec3 getatm(vec3 ray, float roughness){")
    WriteLine(fw,"vec3 sharp = mix(vec3( 0.0293, 0.0698, 0.1717) * 10.0, vec3(3.0), pow(1.0 - ray.y, 8.0));")
    WriteLine(fw,"vec3 rough = vec3(vec3( 0.0293, 0.0698, 0.1717) + vec3(1.0));")
    WriteLine(fw,"return mix(sharp, rough, roughness);")
WriteLine(fw,"}")

WriteLine(fw,"float sun(vec3 ray){")
    WriteLine(fw,"return pow(max(0.0, dot(ray, normalize(vec3(1.0, 1.0, 0.0)))), 668.0) * 110.0;")
WriteLine(fw,"}")

WriteLine(fw,"vec3 getColor(vec2 uv){")

    WriteLine(fw,"vec3 ray = getRay(uv);")
    
WriteLine(fw,"    if(ray.y >= -0.01){")
WriteLine(fw,"        vec3 C = getatm(ray, 0.0) * 1.0 + sun(ray) * 2.0;")
         WriteLine(fw,"return C; ")
    WriteLine(fw,"}")
    
    WriteLine(fw,"vec3 wfloor = vec3(0.0, -WATER_DEPTH, 0.0);")
    WriteLine(fw,"vec3 wceil = vec3(0.0, 0.0, 0.0);")
    WriteLine(fw,"vec3 orig = vec3(0.0, 2.0, 0.0);")
    WriteLine(fw,"float hihit = intersectPlane(orig, ray, wceil, vec3(0.0, 1.0, 0.0));")
    WriteLine(fw,"float lohit = intersectPlane(orig, ray, wfloor, vec3(0.0, 1.0, 0.0));")
	WriteLine(fw,"vec3 hipos = orig + ray * hihit;")
    WriteLine(fw,"vec3 lopos = orig + ray * lohit;")
    WriteLine(fw,"float dist = raymarchwater(orig, hipos, lopos, WATER_DEPTH);")
    WriteLine(fw,"vec3 pos = orig + ray * dist;")

    WriteLine(fw,"vec3 N = normal(pos.xz, 0.01, WATER_DEPTH);")
    WriteLine(fw,"vec3 R = reflect(ray, N);")
    WriteLine(fw,"float roughness = 1.0 - 1.0 / (dist * 0.01 + 1.0);")
    WriteLine(fw,"N = normalize(mix(N, vec3(0.0, 1.0, 0.0), roughness));")
    WriteLine(fw,"R = normalize(mix(R, N, roughness));")
    WriteLine(fw,"R.y = abs(R.y);")
    WriteLine(fw,"float fresnel = (0.04 + (1.0-0.04)*(pow(1.0 - max(0.0, dot(-N, ray)), 5.0)));")
    
    WriteLine(fw,"vec3 C = fresnel * (getatm(R, roughness) + sun(R));")
    
    WriteLine(fw,"return C;")
WriteLine(fw,"}")

WriteLine(fw,"vec3 gammacorrect(vec3 c){")
    WriteLine(fw,"return pow(c, vec3(1.0 / 2.4));")
WriteLine(fw,"}")
WriteLine(fw,"vec3 RRTAndODTFit(vec3 v)")
WriteLine(fw,"{")
    WriteLine(fw,"vec3 a = v * (v + 0.0245786) - 0.000090537;")
    WriteLine(fw,"vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;")
    WriteLine(fw,"return a / b;")
WriteLine(fw,"}")
 
WriteLine(fw,"mat3 transpose(mat3 m) {")
  WriteLine(fw,"return mat3(m[0][0], m[1][0], m[2][0],")
              WriteLine(fw,"m[0][1], m[1][1], m[2][1],")
              WriteLine(fw,"m[0][2], m[1][2], m[2][2]);")
WriteLine(fw,"}")
WriteLine(fw,"vec3 ACESFitted(vec3 color)")
WriteLine(fw,"{")
	WriteLine(fw,"mat3 ACESInputMat = mat3(")
	    WriteLine(fw,"0.59719, 0.35458, 0.04823,")
	    WriteLine(fw,"0.07600, 0.90834, 0.01566,")
	    WriteLine(fw,"0.02840, 0.13383, 0.83777")
	WriteLine(fw,");")
	 WriteLine(fw,"mat3 ACESOutputMat = mat3(")
	     WriteLine(fw,"1.60475, -0.53108, -0.07367,")
	    WriteLine(fw,"-0.10208,  1.10813, -0.00605,")
	    WriteLine(fw,"-0.00327, -0.07276,  1.07602")
	WriteLine(fw,");")
    WriteLine(fw,"color = transpose(ACESInputMat) * color;")
    WriteLine(fw,"color = RRTAndODTFit(color);")
    WriteLine(fw,"color = (transpose(ACESOutputMat) * color);")
    WriteLine(fw,"return gammacorrect(clamp(color, 0.0, 1.0));")
WriteLine(fw,"}")
WriteLine(fw,"vec3 render(vec2 uv){")
    WriteLine(fw,"vec3 ray = getRay(uv);")
    WriteLine(fw,"vec3 C = getColor(uv) * 1.8;")
    WriteLine(fw,"return ACESFitted(C);  ")
WriteLine(fw,"}")

WriteLine(fw,"void main( void ) {")

    WriteLine(fw,"vec2 position = ( gl_FragCoord.xy / resolution.xy );")

    WriteLine(fw,"gl_FragColor = vec4( render(position), 1.0 );")

WriteLine(fw,"}")













	CloseFile(fw)
endfunction

// Project: road
// Created: 2018-08-11

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle( "road" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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


global ang#, angx#, angy#, fDiffY#, fDiffX#,newX#,startx#, starty#, camerax#,cameray#,cameraz#,memblock, numberofcubes, inventorycubecount

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(1000,1000)
SetObjectColor(chunk,255,0,0,255)
SetObjectRotation(chunk,0,0,0)
vs=LoadShader("road.vs","road.ps")
SetObjectShader(chunk,vs)
a=1
SetObjectShaderConstantByName(chunk,"resolution",1024,768,0,0)

	
do
	SetObjectShaderConstantByName(chunk,"time",timer(),0,0,0)

	
    Print( ScreenFPS() )
    Sync()

loop


function movecamerawithmouse()
      
    fDiffX# = (GetPointerX() - startx#)/1.0
    fDiffY# = (GetPointerY() - starty#)/1.0
  
    newX# = angx# + fDiffY#
   // if ( newX# > 360 ) then newX# = 360
   // if ( newX# < -360 ) then newX# = -360
    
    // if we keep hold of the left mouse button then rotate the view otherwise the camera stays put
    // so can concentrate on adding/removing blocks at that positon
    
    
    SetCameraRotation( 1, newX#, angy# + fDiffX#, 0 )
  
endfunction


// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("road.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")


    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

	fw=OpenToWrite("road.ps")

writeline(fw,"#ifdef GL_ES")

writeline(fw,"precision mediump float;")

writeline(fw,"#endif")

writeline(fw,"uniform float time;")

writeline(fw,"uniform vec2 mouse;")

writeline(fw,"uniform vec2 resolution;")


writeline(fw,"float hash( float n ) {")

writeline(fw,"    return fract(sin(n)*43758.5453);")

writeline(fw,"}")

// port of minecraft

writeline(fw,"bool getMaterialColor( int i, vec2 coord, out vec3 color ) {")

writeline(fw,"	vec2 uv = floor( coord );")

writeline(fw,"    float n = uv.x + uv.y*347.0 + 4321.0 * float(i);")

writeline(fw,"	float h = hash(n);")
		
writeline(fw,"    float br = 1. - h * (96./255.);")
writeline(fw,"	color = vec3( 150./255., 108./255.,  74./255.); // 0x966C4A;")
	
writeline(fw,"	if (i == 4) {")

writeline(fw,"		color = vec3( 127./255., 127./255., 127./255.); // 0x7F7F7F;")

writeline(fw,"	}")
	
writeline(fw,"	float xm1 = mod((uv.x * uv.x * 3. + uv.x * 81.) / 4., 4.);")
	
writeline(fw,"	if (i == 1) {")

writeline(fw,"		if( uv.y < (xm1 + 18.)) {")

writeline(fw,"			color = vec3( 106./255., 170./255.,  64./255.); // 0x6AAA40;")

writeline(fw,"		} else if (uv.y < (xm1 + 19.)) {")

writeline(fw,"			br = br * (2. / 3.);")

writeline(fw,"		}")

writeline(fw,"	}")
	
writeline(fw,"	if (i == 7) {")

writeline(fw,"		color = vec3( 103./255., 82./255.,  49./255.); // 0x675231;")

writeline(fw,"		if (uv.x > 0. && uv.x < 15.")

writeline(fw,"			&& ((uv.y > 0. && uv.y < 15.) || (uv.y > 32. && uv.y < 47.))) {")


writeline(fw,"			color = vec3( 188./255., 152./255.,  98./255.); // 0xBC9862;")

writeline(fw,"			float xd = (uv.x - 7.);")

writeline(fw,"			float yd = (mod(uv.y, 16.) - 7.);")

writeline(fw,"			if (xd < 0.)")

writeline(fw,"				xd = 1. - xd;")

writeline(fw,"			if (yd < 0.)")
writeline(fw,"				yd = 1. - yd;")
writeline(fw,"			if (yd > xd)")
writeline(fw,"				xd = yd;")
			
writeline(fw,"			br = 1. - (h * (32./255.) + mod(xd, 4.) * (32./255.));")

writeline(fw,"		} else if ( h < 0.5 ) {")
writeline(fw,"			br = br * (1.5 - mod(uv.x, 2.));")

writeline(fw,"		}")
writeline(fw,"	}")
	
writeline(fw,"	if (i == 5) {")

writeline(fw,"		color = vec3( 181./255.,  58./255.,  21./255.); // 0xB53A15;")

writeline(fw,"		if ( mod(uv.x + (floor(uv.y / 4.) * 5.), 8.) == 0. || mod( uv.y, 4.) == 0.) {")

writeline(fw,"			color = vec3( 188./255., 175./255., 165./255.); // 0xBCAFA5;")

writeline(fw,"		}")
writeline(fw,"	}")


writeline(fw,"	if (i == 9) {")
writeline(fw,"		color = vec3(  64./255.,  64./255., 255./255.); // 0x4040ff;")
writeline(fw,"	}")
	
writeline(fw,"	float brr = br;")
writeline(fw,"	if (uv.y >= 32.)")
writeline(fw,"		brr /= 2.;")
	
writeline(fw,"	if (i == 8) {")
writeline(fw,"		color = vec3(  80./255., 217./255.,  55./255.); // 0x50D937;")

writeline(fw,"		if ( h < 0.5) {")
writeline(fw,"			return false;")
writeline(fw,"		}")
writeline(fw,"	}")
	
writeline(fw,"	color *= brr;")
	
writeline(fw,"	return true;")
writeline(fw,"}")

writeline(fw,"int getMap( vec3 pos ) {	")
writeline(fw,"	vec3 posf = floor( (pos - vec3(32.))  );")
    
writeline(fw,"	float n = posf.x + posf.y*517.0 + 1313.0*posf.z;")
writeline(fw,"    float h = hash(n);")
	
writeline(fw,"	if( h > sqrt( sqrt( dot( posf.yz, posf.yz )*0.16 ) ) - 0.8  ) {")
writeline(fw,"        return 0;")
writeline(fw,"	}")	
	
writeline(fw,"	return int( hash( n * 465.233 ) * 16. );")
writeline(fw,"}")

writeline(fw,"vec3 renderMinecraft( vec2 uv ) {")
writeline(fw,"    float xRot =  1.5;//sin( time*0.5 ) * 0.4 + (3.1415 / 2.);")
writeline(fw,"    float yRot =  0.0;//cos( time*0.5 ) * 0.4; uncomment for rotation")
writeline(fw,"    float yCos = cos(yRot);")
writeline(fw,"    float ySin = sin(yRot);")
writeline(fw,"    float xCos = cos(xRot);")
writeline(fw,"    float xSin = sin(xRot);")

writeline(fw,"	vec3 opos = vec3( 32.5 + time * 6.4, 32.5, 32.5 );")
	
writeline(fw,"	float gggxd = (uv.x - 0.5) * (resolution.x / resolution.y );")
writeline(fw,"	float ggyd = (1.-uv.y - 0.5);")
writeline(fw,"	float ggzd = 1.;")
	
writeline(fw,"	float gggzd = ggzd * yCos + ggyd * ySin;")
	
writeline(fw,"	vec3 _posd = vec3( gggxd * xCos + gggzd * xSin,")
writeline(fw,"					   ggyd * yCos - ggzd * ySin,")
writeline(fw,"					   gggzd * xCos - gggxd * xSin );")
	
writeline(fw,"	vec3 col = vec3( 0. );")
writeline(fw,"	float br = 1.;")
writeline(fw,"	vec3 bdist = vec3( 255. - 100., 255. -   0., 255. -  50.  );")
writeline(fw,"	float ddist = 0.;")
	
writeline(fw,"	float closest = 32.;")
	
writeline(fw,"	for ( int d = 0; d < 3; d++) {")
writeline(fw,"		float dimLength = _posd[d];")
		
writeline(fw,"		float ll = abs( 1. / dimLength );")
writeline(fw,"		vec3 posd = _posd * ll;;")
		
writeline(fw,"		float initial = fract( opos[d] );")
writeline(fw,"		if (dimLength > 0.) initial = 1. - initial;")
		
writeline(fw,"		float dist = ll * initial;")
		
writeline(fw,"		vec3 pos = opos + posd * initial;")
		
writeline(fw,"		if (dimLength < 0.) {")
writeline(fw,"			pos[d] -= 1.;")
writeline(fw,"		}")
		
writeline(fw,"		for (int i=0; i<30; i++) {")
writeline(fw,"			if( dist > closest )continue;")
			
writeline(fw,"			//int tex = getMap( mod( pos, 64. ) );")
writeline(fw,"			int tex = getMap( pos );")
			
writeline(fw,"			if (tex > 0) {")
writeline(fw,"				vec2 texcoord;")
writeline(fw,"				texcoord.x = mod(((pos.x + pos.z) * 16.), 16.);")
writeline(fw,"				texcoord.y = mod((pos.y * 16.), 16.) + 16.;")
writeline(fw,"				if (d == 1) {")
writeline(fw,"					texcoord.x = mod(pos.x * 16., 16.);")
writeline(fw,"					texcoord.y = mod(pos.z * 16., 16.);")
writeline(fw,"					if (posd.y < 0.)")
writeline(fw,"						texcoord.y += 32.;")
writeline(fw,"				}")
				
writeline(fw,"				if ( getMaterialColor( tex, texcoord, col ) ) {")
writeline(fw,"					ddist = 1. - (dist / 32.);")
writeline(fw,"					br = bdist[d];")
writeline(fw,"					closest = dist;")
writeline(fw,"				}")
writeline(fw,"			}")
writeline(fw,"			pos += posd;")
writeline(fw,"			dist += ll;")
writeline(fw,"		}")
writeline(fw,"	}")
	
writeline(fw,"	return col * ddist * (br/255.);")
writeline(fw,"}")

writeline(fw,"void main(void)")
writeline(fw,"{")
writeline(fw,"	vec2 uv = gl_FragCoord.xy / resolution.xy;")
	
writeline(fw,"	gl_FragColor = vec4( renderMinecraft( uv+mouse ) ,1.0);")
writeline(fw,"}")










	CloseFile(fw)
endfunction

// Created by Reinder Nijhoff 2013
//
// port of javascript minecraft: http://jsfiddle.net/uzMPU/
// original code by Markus Persson: https://twitter.com/notch/status/275331530040160256

SetErrorMode(2)

// set window properties
SetWindowTitle( "SuperNova" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createVSShaderFile()
createPSshaderFile()



chunk = CreateObjectPlane(1000,1000)
SetObjectColor(chunk,255,255,255,255)
Shader=LoadShader("supernova.vs","supernova.ps")
SetObjectShader(chunk,Shader)
SetShaderConstantByName( Shader,"iResolution",900,900,0,0 )

do
    
    SetShaderConstantByName( Shader,"time",Timer()*.5,0,0,0 )


    Print( ScreenFPS() )
    Sync()

loop



// This is the function which creates the two files VS and PS
// These just simply output lines of code to the two files

function createVSShaderFile()
	
    fw = OpenToWrite("supernova.vs")
    WriteLine(fw,"attribute highp vec3 position;")
    WriteLine(fw,"attribute mediump vec3 normal;")
    WriteLine(fw,"varying highp vec3 posVarying;")
    WriteLine(fw,"varying mediump vec3 normalVarying;")
    WriteLine(fw,"varying mediump vec3 lightVarying;")
    WriteLine(fw,"mediump vec3 GetVSLighting( mediump vec3 normal, highp vec3 pos );")
    WriteLine(fw,"uniform highp mat3 agk_WorldNormal;")
    WriteLine(fw,"uniform highp mat4 agk_World;")
    WriteLine(fw,"uniform highp mat4 agk_ViewProj;")
    WriteLine(fw,"attribute highp vec2 uv;")
    WriteLine(fw,"varying highp vec2 uvVarying;")
    WriteLine(fw,"uniform highp vec4 uvBounds0;")
     
    WriteLine(fw,"void main()")
    WriteLine(fw,"{ ")
    WriteLine(fw,"uvVarying = uv * uvBounds0.xy + uvBounds0.zw;")
    WriteLine(fw,"highp vec4 pos = agk_World * vec4(position,1.0);")
    WriteLine(fw,"mediump vec3 norm = normalize(agk_WorldNormal * normal);")
    WriteLine(fw,"gl_Position = agk_ViewProj * pos;")
    WriteLine(fw,"posVarying = pos.xyz;")
    WriteLine(fw,"normalVarying = norm;")
    WriteLine(fw,"lightVarying = GetVSLighting( norm, posVarying );")
    WriteLine(fw,"}")
    CloseFile(fw)
 
	
	
endfunction

function createPSshaderFile()

fw=OpenToWrite("supernova.ps")

WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"#endif")
WriteLine(fw,"#extension GL_OES_standard_derivatives : enable")
WriteLine(fw,"uniform float time;")
WriteLine(fw,"uniform vec2 mouse;")
WriteLine(fw,"uniform vec2 iResolution;")
WriteLine(fw,"//#define BOTH")
WriteLine(fw,"// uncomment this string to see left part")
WriteLine(fw,"#define LEFT")
WriteLine(fw,"//#define LOW_QUALITY")
WriteLine(fw,"#define DITHERING")
WriteLine(fw,"//#define TONEMAPPING")
WriteLine(fw,"//-------------------")
WriteLine(fw,"#define pi 3.14159265")
WriteLine(fw,"#define R(p, a) p=cos(a)*p+sin(a)*vec2(p.y, -p.x)")
WriteLine(fw,"vec3 hash( vec3 p )")
WriteLine(fw,"{")
WriteLine(fw,"	p = vec3( dot(p,vec3(127.1,311.7, 74.7)),")
WriteLine(fw,"			  dot(p,vec3(269.5,183.3,246.1)),")
WriteLine(fw,"			  dot(p,vec3(113.5,271.9,124.6)));")
WriteLine(fw,"	return -1.0 + 2.0*fract(sin(p)*43758.5453123);")
WriteLine(fw,"}")
WriteLine(fw,"float noise( in vec3 p )")
WriteLine(fw,"{")
WriteLine(fw,"    vec3 i = floor( p );")
WriteLine(fw,"    vec3 f = fract( p );")
WriteLine(fw,"	vec3 u = f*f*(3.0-2.0*f);")
WriteLine(fw,"    return mix( mix( mix( dot( hash( i + vec3(0.0,0.0,0.0) ), f - vec3(0.0,0.0,0.0) ), ")
WriteLine(fw,"                          dot( hash( i + vec3(1.0,0.0,0.0) ), f - vec3(1.0,0.0,0.0) ), u.x),")
WriteLine(fw,"                     mix( dot( hash( i + vec3(0.0,1.0,0.0) ), f - vec3(0.0,1.0,0.0) ), ")
WriteLine(fw,"                          dot( hash( i + vec3(1.0,1.0,0.0) ), f - vec3(1.0,1.0,0.0) ), u.x), u.y),")
WriteLine(fw,"                mix( mix( dot( hash( i + vec3(0.0,0.0,1.0) ), f - vec3(0.0,0.0,1.0) ), ")
WriteLine(fw,"                          dot( hash( i + vec3(1.0,0.0,1.0) ), f - vec3(1.0,0.0,1.0) ), u.x),")
WriteLine(fw,"                     mix( dot( hash( i + vec3(0.0,1.0,1.0) ), f - vec3(0.0,1.0,1.0) ), ")
WriteLine(fw,"                          dot( hash( i + vec3(1.0,1.0,1.0) ), f - vec3(1.0,1.0,1.0) ), u.x), u.y), u.z );")
WriteLine(fw,"}")
WriteLine(fw,"float fbm( vec3 p )")
WriteLine(fw,"{")
WriteLine(fw,"   return noise(p*.06125)*.5 + noise(p*.125)*.25 + noise(p*.25)*.125 + noise(p*.4)*.2;")
WriteLine(fw,"}")

WriteLine(fw,"float rand(vec2 co)")
WriteLine(fw,"{")
WriteLine(fw,"   return fract(sin(dot(co*0.123,vec2(12.9898,78.233))) * 43758.5453);")
WriteLine(fw,"}")

WriteLine(fw,"float Sphere( vec3 p, float r )")
WriteLine(fw,"{")
WriteLine(fw,"   return length(p)-r;")
WriteLine(fw,"}")
//==============================================================
// otaviogood's noise from https://www.shadertoy.com/view/ld2SzK
//--------------------------------------------------------------
// This spiral noise works by successively adding and rotating sin waves while increasing frequency.
// It should work the same on all computers since it's not based on a hash function like some other noises.
// It can be much faster than other noise functions if you're ok with some repetition.
WriteLine(fw,"const float nudge = 4.;	// size of perpendicular vector")
WriteLine(fw,"float normalizer = 1.0 / sqrt(1.0 + nudge*nudge);	// pythagorean theorem on that perpendicular to maintain scale")
WriteLine(fw,"float SpiralNoiseC(vec3 p)")
WriteLine(fw,"{")
WriteLine(fw,"    float n = -mod(time * 0.2,-2.); // noise amount")
WriteLine(fw,"    float iter = 2.0;")
WriteLine(fw,"    for (int i = 0; i < 8; i++)")
WriteLine(fw,"    {")
        // add sin and cos scaled inverse with the frequency
WriteLine(fw,"        n += -abs(sin(p.y*iter) + cos(p.x*iter)) / iter;	// abs for a ridged look")
WriteLine(fw,"        // rotate by adding perpendicular and scaling down")
WriteLine(fw,"        p.xy += vec2(p.y, -p.x) * nudge;")
WriteLine(fw,"        p.xy *= normalizer;")
WriteLine(fw,"        // rotate on other axis")
WriteLine(fw,"        p.xz += vec2(p.z, -p.x) * nudge;")
WriteLine(fw,"        p.xz *= normalizer;")
        // increase the frequency
WriteLine(fw,"        iter *= 1.733733;")
WriteLine(fw,"    }")
WriteLine(fw,"    return n;")
WriteLine(fw,"}")
WriteLine(fw,"float VolumetricExplosion(vec3 p)")
WriteLine(fw,"{")
WriteLine(fw,"    float final = Sphere(p,4.);")
WriteLine(fw,"    #ifdef LOW_QUALITY")
WriteLine(fw,"    final += noise(p*12.5)*.2;")
WriteLine(fw,"    #else")
WriteLine(fw,"    final += fbm(p*50.);")
WriteLine(fw,"    #endif")
WriteLine(fw,"    final += SpiralNoiseC(p.zxy*0.4132+333.)*3.0; //1.25;")
WriteLine(fw,"    return final;")
WriteLine(fw,"}")
WriteLine(fw,"float map(vec3 p) ")
WriteLine(fw,"{")
WriteLine(fw,"	R(p.xz, mouse.x*0.008*pi+time*0.1);")
WriteLine(fw,"	float VolExplosion = VolumetricExplosion(p/0.5)*0.5; // scale")
WriteLine(fw,"	return VolExplosion;")
WriteLine(fw,"}")
//--------------------------------------------------------------
// assign color to the media
WriteLine(fw,"vec3 computeColor( float density, float radius )")
WriteLine(fw,"{")
	// color based on density alone, gives impression of occlusion within
	// the media
WriteLine(fw,"	vec3 result = mix( vec3(1.0,0.9,0.8), vec3(0.4,0.15,0.1), density );")
	// color added to the media
WriteLine(fw,"	vec3 colCenter = 7.*vec3(0.8,1.0,1.0);")
WriteLine(fw,"	vec3 colEdge = 1.5*vec3(0.48,0.53,0.5);")


WriteLine(fw,"	result *= mix( colCenter, colEdge, min( (radius+.05)/.9, 1.15 ) );")
WriteLine(fw,"	return result;")
WriteLine(fw,"}")
WriteLine(fw,"bool RaySphereIntersect(vec3 org, vec3 dir, out float near, out float far)")
WriteLine(fw,"{")
WriteLine(fw,"	float b = dot(dir, org);")
WriteLine(fw,"	float c = dot(org, org) - 8.;")
WriteLine(fw,"	float delta = b*b - c;")
WriteLine(fw,"	if( delta < 0.0) ")
WriteLine(fw,"		return false;")
WriteLine(fw,"	float deltasqrt = sqrt(delta);")
WriteLine(fw,"	near = -b - deltasqrt;")
WriteLine(fw,"	far = -b + deltasqrt;")
WriteLine(fw,"	return far > 0.0;")
WriteLine(fw,"}")
// Applies the filmic curve from John Hable's presentation
// More details at : http://filmicgames.com/archives/75
WriteLine(fw,"vec3 ToneMapFilmicALU(vec3 _color)")
WriteLine(fw,"{")
WriteLine(fw,"	_color = max(vec3(0), _color - vec3(0.004));")
WriteLine(fw,"	_color = (_color * (6.2*_color + vec3(0.5))) / (_color * (6.2 * _color + vec3(1.7)) + vec3(0.06));")
WriteLine(fw,"	return _color;")
WriteLine(fw,"}")
WriteLine(fw,"void main( void )")
WriteLine(fw,"{ ") 
WriteLine(fw,"    	vec2 uv = gl_FragCoord.xy/iResolution.xy;")
	// ro: ray origin
	// rd: direction of the ray
WriteLine(fw,"	vec3 rd = normalize(vec3((gl_FragCoord.xy-0.5*iResolution.xy)/iResolution.y, 1.));")
WriteLine(fw,"	vec3 ro = vec3(0., 0., -6.);")
WriteLine(fw,"	#ifdef DITHERING")
WriteLine(fw,"	vec2 seed = uv + fract(time);")
WriteLine(fw,"	#endif ")
	// ld, td: local, total density 
	// w: weighting factor
WriteLine(fw,"	float ld=0., td=0., w=0.;")
	// t: length of the ray
	// d: distance function
WriteLine(fw,"	float d=1., t=0.;")
WriteLine(fw,"   	const float h = 0.1;")
WriteLine(fw,"	vec4 sum = vec4(0.0);")
WriteLine(fw,"    	float min_dist=0.0, max_dist=0.0;")
WriteLine(fw,"   	if(RaySphereIntersect(ro, rd, min_dist, max_dist))") 
 WriteLine(fw,"{")
WriteLine(fw,"	t = min_dist*step(t,min_dist);")
	// raymarch loop
WriteLine(fw,"   	#ifdef LOW_QUALITY")
WriteLine(fw,"	for (int i=0; i<56; i++)")
WriteLine(fw,"    	#else")
WriteLine(fw,"    	for (int i=0; i<86; i++)")
WriteLine(fw,"    	#endif")
WriteLine(fw,"	{")
WriteLine(fw,"	    vec3 pos = ro + t*rd;")
	    // Loop break conditions.
WriteLine(fw,"	    if(td>0.9 || d<0.12*t || t>10. || sum.a > 0.99 || t>max_dist) break;")
	    // evaluate distance function
WriteLine(fw,"	    float d = map(pos);")
        
WriteLine(fw,"	    #ifdef BOTH")
WriteLine(fw,"	    if (uv.x<0.5)")
WriteLine(fw,"	    {")
WriteLine(fw,"            	d = abs(d)+0.07;")
WriteLine(fw,"	    }")
WriteLine(fw,"	    #else")
WriteLine(fw,"	    #ifdef LEFT")
WriteLine(fw,"	    d = abs(d)+0.07;")
WriteLine(fw,"	    #endif")
WriteLine(fw,"	    #endif")
	    // change this string to control density 
WriteLine(fw,"	    d = max(d,0.03);")
	    // point light calculations
WriteLine(fw,"	    vec3 ldst = vec3(0.0)-pos;")
WriteLine(fw,"	    float lDist = max(length(ldst), 0.001);")
	    // the color of light 
WriteLine(fw,"	    vec3 lightColor=vec3(1.0,0.5,0.25);")
WriteLine(fw,"	    sum.rgb+=(lightColor/exp(lDist*lDist*lDist*.08)/30.); // bloom")
WriteLine(fw,"	    if (d<h)") 
WriteLine(fw,"	    {")
	    // compute local density 
WriteLine(fw,"	    ld = h - d;")
	    // compute weighting factor 
WriteLine(fw,"	    w = (1. - td) * ld;")
	    // accumulate density
WriteLine(fw,"	    td += w + 1./200.;")
WriteLine(fw,"	    vec4 col = vec4( computeColor(td,lDist), td );")
            // emission
WriteLine(fw,"            sum += sum.a * vec4(sum.rgb, 0.0) * 0.2 / lDist;	")
	    // uniform scale density
WriteLine(fw,"	    col.a *= 0.2;")
	    // colour by alpha
WriteLine(fw,"	    col.rgb *= col.a;")
	    // alpha blend in contribution
WriteLine(fw,"	    sum = sum + col*(1.0 - sum.a);  ")
WriteLine(fw,"	    }")
WriteLine(fw,"	    td += 1./70.;")
WriteLine(fw,"	    #ifdef DITHERING")
WriteLine(fw,"	    d=abs(d)*(.8+0.2*rand(seed*vec2(i)));")
WriteLine(fw,"	    #endif ")
	    // trying to optimize step size
WriteLine(fw,"	    #ifdef LOW_QUALITY")
WriteLine(fw,"	    t += max(d*0.25,0.01);")
WriteLine(fw,"	    #else")
WriteLine(fw,"	    t += max(d * 0.08 * max(min(length(ldst),d),2.0), 0.01);")
WriteLine(fw,"	    #endif")
WriteLine(fw,"	}")
	// simple scattering
WriteLine(fw,"	#ifdef LOW_QUALITY    ")
WriteLine(fw,"	sum *= 1. / exp( ld * 0.2 ) * 0.9;")
WriteLine(fw,"	#else")
WriteLine(fw,"	sum *= 1. / exp( ld * 0.2 ) * 0.8;")
WriteLine(fw,"	#endif")
WriteLine(fw,"  	sum = clamp( sum, 0.0, 1.0 );")   
WriteLine(fw,"	sum.xyz = sum.xyz*sum.xyz*(3.0-2.0*sum.xyz);")
WriteLine(fw,"	}")
   
WriteLine(fw,"	#ifdef TONEMAPPING")
WriteLine(fw,"	gl_FragColor = vec4(ToneMapFilmicALU(sum.xyz*2.2),1.0);")
WriteLine(fw,"	#else")
WriteLine(fw,"	gl_FragColor = vec4(sum.xyz,1.0);")
WriteLine(fw,"	#endif")
WriteLine(fw,"}")
CloseFile(fw)
endfunction

SetErrorMode(2)

// set window properties
SetWindowTitle( "Pixelate" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
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

createShaderFile()
imgId=createRandomBgImage()
CreateSprite(1,imgId)
LoadSpriteShader(2, "pixelate.ps")
SetSpriteShader( 1,2 )
do
    SetShaderConstantByName(2,"pixels",1024/5,768/5,0,0) //the bigger the numbers the more pixels
    sync()   
loop

function createShaderFile()

fw=OpenToWrite("pixelate.ps")
WriteLine(fw,"#ifdef GL_ES")
WriteLine(fw,"precision mediump float;")
WriteLine(fw,"precision mediump int;")
WriteLine(fw,"#endif")
WriteLine(fw,"#define PROCESSING_TEXTURE_SHADER")
WriteLine(fw,"varying mediump vec2 uvVarying;")
WriteLine(fw,"uniform sampler2D texture0;")
WriteLine(fw,"uniform vec2 pixels;")
WriteLine(fw,"void main(void)")
WriteLine(fw,"{")
WriteLine(fw,"  vec2 p = uvVarying;")
WriteLine(fw,"	p.x -= mod(p.x, 1.0 / pixels.x);")
WriteLine(fw,"	p.y -= mod(p.y, 1.0 / pixels.y);")
WriteLine(fw,"	vec3 col = texture2D(texture0, p).rgb;")
WriteLine(fw,"	gl_FragColor = vec4(col, 1.0);")
WriteLine(fw,"}")
CloseFile(fw)
endfunction

function createRandomBgImage()
    SetClearColor(0,0,0)
    ClearScreen()
    Render()
    For num = 1 to 500
		DrawEllipse(Random(1,1023),Random(1,787),random(10,30),random(10,30),makecolor(random(1,255),random(1,255),random(1,255)),makecolor(random(1,255),random(1,255),random(1,255)),1)
    next num
    swap()
    img = getimage(0,0,1024,768)
    //SetImageTransparentColor(img,0,0,0)
endfunction img