Sorry your browser is not supported!

// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=16  // Size of the chunk in X and Z direction

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy

// meshmemblock types
Type Vertex
      
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
endtype
global collisiondata as _CollisionData[size,size,size]
CD as _CollisionData

// meshmemblock types

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)

//addCubeToMesh(0,0,0,1,1,1)
//cube = CreateObjectFromMeshWithUVTexturing(meshid,1,img)

// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		//create a floor
		collisiondata[x+size/2,y,z+size/2].id = 0
		collisiondata[x+size/2,y,z+size/2].air=1
		addCubeToMesh(x+size/2,y,z+size/2,1,1,1)
			
		
		
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next

chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)




startx#=screenwidth/2
starty#=screenheight/2
camerax#=0
cameray#=10
cameraz#=0
SetRawMousePosition(startx#,starty#)

SetCameraRange(1,.01,1000)	

do

	
	checkcollisions()

	if GetRawKeyState(32) or GetRawMouseLeftPressed() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)
	//	for xx=getobjectx(cubehit)-1 to getobjectx(cubehit)+1
	//		for zz=getobjectz(cubehit)-1 to getobjectz(cubehit)+1
				
	//			if collisiondata[colx+xx,coly-1,colz+zz].air = 0
	//				collisiondata[colx+xx,coly-1,colz+zz].id = InstanceObject(cube)
//					collisiondata[colx+xx,coly-1,colz+zz].air = 1
	//				SetObjectPosition(collisiondata[colx+xx,coly-1,colz+zz].id,xx,getobjecty(cubehit)-1,zz)
		//		endif
	//		next
		//next
		DeleteObject(chunk)
		collisiondata[collisioncoordx,size/2+1,collisioncoordz].air = 0
		addCubeToMesh(collisioncoordx,size/2+1,collisioncoordz,1,1,1)
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		
	endif
	if GetRawKeyPressed(17) or GetRawMouseRightPressed() // CTRL or right mouse button
		//add cube
//		collisiondata[colx,coly+1,colz].id = InstanceObject(cube)
//		collisiondata[colx,coly+1,colz].air = 1
//		SetObjectPosition(collisiondata[colx,coly+1,colz].id,getobjectx(cubehit),getobjecty(cubehit)+1,getobjectz(cubehit))
		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
    Print( ScreenFPS() )
    Sync()
loop

function checkcollisions()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2)
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2)
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2)
	
endfunction 

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#)
	c=MakeColor(255,255,255)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction

function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, color as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
        SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
        SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
        SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
        SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
        SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
        SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
        SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
    
    DeleteObject(cube)
    cube = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(cube,texture,0)
endfunction cube

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=16  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=15 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes

// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
endtype
global collisiondata as _CollisionData[size,size,size]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types
global img,camerax#,cameray#,cameraz#,centrespr

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


buildworld()

initialisecamera()




do
	SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawKeyState(32) or GetRawMouseLeftPressed() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

	//	for xx=getobjectx(cubehit)-1 to getobjectx(cubehit)+1
	//		for zz=getobjectz(cubehit)-1 to getobjectz(cubehit)+1
				
	//			if collisiondata[colx+xx,coly-1,colz+zz].air = 0
	//				collisiondata[colx+xx,coly-1,colz+zz].id = InstanceObject(cube)
//					collisiondata[colx+xx,coly-1,colz+zz].air = 1
	//				SetObjectPosition(collisiondata[colx+xx,coly-1,colz+zz].id,xx,getobjecty(cubehit)-1,zz)
		//		endif
	//		next
		//next


		DeleteObject(chunk)
		collisiondata[collisioncoordx,size/2+1,collisioncoordz].air = 1
		addCubeToMesh(collisioncoordx,size/2+1,collisioncoordz,1,1,1,1)
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		
	endif
	if GetRawKeyPressed(17) or GetRawMouseRightPressed() // CTRL or right mouse button
		//add cube



		DeleteObject(chunk)
		collisiondata[collisioncoordx,size/2+1,collisioncoordz].air = 1
		addCubeToMesh(collisioncoordx,size/2+1,collisioncoordz,1,1,1,1)
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)


//		collisiondata[colx,coly+1,colz].id = InstanceObject(cube)
//		collisiondata[colx,coly+1,colz].air = 1
//		SetObjectPosition(collisiondata[colx,coly+1,colz].id,getobjectx(cubehit),getobjecty(cubehit)+1,getobjectz(cubehit))
		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
	Print("Number of chunks - " + str(numofchunks))
	print("Number of Cubes - " + str(numofcubes))
    Print( ScreenFPS() )
    Sync()
loop

function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=0
	cameray#=10
	cameraz#=0

	SetCameraRange(1,.01,1000)	

// crate centre object
	centrespr = CreateSprite(0)
	SetRawMousePosition(startx#,starty#)

endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for farx=-renderdistance to renderdistance
		for farz=-renderdistance to renderdistance
			chunks.insert(buildchunk(img))
			inc numofchunks
			SetObjectPosition(chunks[chunkid],farx * size, 0, farz * size)
			inc chunkid
			
		next
	next
	DeleteText(building)
endfunction

function buildchunk(img)
	

// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		//create a floor
		collisiondata[x+size/2,y,z+size/2].id = 0
		collisiondata[x+size/2,y,z+size/2].air=1
		addCubeToMesh(x+size/2,y,z+size/2,1,1,1,1)
			
		inc numofcubes
		
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next
//DeleteObject(chunk)
chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
emptymesh()
endfunction	chunk
	

function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=screenwidth/2
	my#=screenheight/2
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2)
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2)
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2)
	
endfunction 

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction

function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
    
//    DeleteObject(cube)
    cube = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(cube,texture,0)
endfunction cube

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=64  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes

// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
	height
endtype
//global collisiondata as _CollisionData[size,size,size]
global collisiondata as _CollisionData[size,size]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types
global img,camerax#,cameray#,cameraz#,centrespr

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


buildworld()

initialisecamera()




do
	//SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawKeyState(32) or GetRawMouseRightPressed() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

		for xx=-1 to 1
			for zz=-1 to 1
				
				if collisiondata[collisioncoordx+xx,collisioncoordz+zz].air = 0
					collisiondata[collisioncoordx+xx,collisioncoordz+zz].id = 0
					collisiondata[collisioncoordx+xx,collisioncoordz+zz].air = 1
					addCubeToMesh(collisioncoordx+xx,getheightofcube(collisioncoordx,collisioncoordz)-1,collisioncoordz+zz,1,1,1,1)
		
				endif
			next

		next


		DeleteObject(chunk)
		collisiondata[collisioncoordx,collisioncoordz].air = 0
		
	//	addCubeToMesh(collisioncoordx,size/2,collisioncoordz,1,1,1,0)
	//	for a=0 to 23
	//		meshid.VertexList.remove(collisiondata[collisioncoordx,collisioncoordz].vertexindex+a)
	//	next
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		
	endif

// ADD CUBE
	if GetRawKeyPressed(17) or GetRawMouseLeftPressed() // CTRL or right mouse button
		//add cube
		DeleteObject(chunk)
		collisiondata[collisioncoordx,collisioncoordz].air = 1 
		inc collisiondata[collisioncoordx,collisioncoordz].height
		addCubeToMesh(collisioncoordx,getheightofcube(collisioncoordx,collisioncoordz),collisioncoordz,1,1,1,1)
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)


		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
	Print("Number of chunks - " + str(numofchunks))
	print("Number of Cubes - " + str(numofcubes))
    Print( ScreenFPS() )
    Sync()
loop

function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=size/2
	cameray#=size/2+10
	cameraz#=size/2

	SetCameraRange(1,.01,1000)	

// crate centre object
	centrespr = CreateObjectPlane(.8,.8)
	SetObjectRotation(centrespr,90,0,0)
	SetObjectColor(centrespr,100,100,100,20)
	SetRawMousePosition(startx#,starty#)
	

endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for farx=-renderdistance to renderdistance
		for farz=-renderdistance to renderdistance
			chunks.insert(buildchunk(img))
			inc numofchunks
			SetObjectPosition(chunks[chunkid],farx * size, 0, farz * size)
			inc chunkid
			
		next
	next
	DeleteText(building)
endfunction

function buildchunk(img)
	
v=0
// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		h=random(size/2,size/2+1)
		h=size/2
		collisiondata[x+size/2,z+size/2].id = v
		collisiondata[x+size/2,z+size/2].air=1
		collisiondata[x+size/2,z+size/2].height=h
		addCubeToMesh(x+size/2,h,z+size/2,1,1,1,1)
			
		inc numofcubes
		inc v
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next
//DeleteObject(chunk)
chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
emptymesh()
endfunction	chunk
	

function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2
	print("X - " + str(collisioncoordx))
	print("Z - " + str(collisioncoordz))
	print("Y - " + str(getheightofcube(collisioncoordx,collisioncoordz)))
	print("CUBE No " + str(collisiondata[collisioncoordx,collisioncoordz].id))
	SetObjectPosition(centrespr,collisioncoordx,getheightofcube(collisioncoordx,collisioncoordz)+.6,collisioncoordz)
	
endfunction 

function getheightofcube(cx,cz)
	
	cy=collisiondata[cx,cz].height
	
	
endfunction cy

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction

function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
    
//    DeleteObject(cube)
    cube = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(cube,texture,0)
endfunction cube

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes

// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
	height
	vertexindex
endtype
//global collisiondata as _CollisionData[size,size,size]
global collisiondata as _CollisionData[size,size]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types
global img,camerax#,cameray#,cameraz#,centrespr

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


buildworld()

initialisecamera()




do
	//SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawKeyState(32) or GetRawMouseRightState() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

		for xx=-1 to 1
			for zz=-1 to 1
				
//				if collisiondata[collisioncoordx+xx,collisioncoordz+zz].air = 0
					collisiondata[collisioncoordx+xx,collisioncoordz+zz].id = 0
					collisiondata[collisioncoordx+xx,collisioncoordz+zz].air = 1
					addCubeToMesh(collisioncoordx+xx,getheightofcube(collisioncoordx,collisioncoordz)-1,collisioncoordz+zz,1,1,1,1)
		
	//			endif
			next

		next

		DeleteObject(chunk)

	// if the cube already been hit then dont need to remove it again
			vindex = collisiondata[collisioncoordx,collisioncoordz].vertexindex
	// chop out a chunk data for the cube
			for a=vindex to vindex + 35
				meshid.VertexList[a].air=0
			next
			chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)

	// set the chunk to air
			collisiondata[collisioncoordx,collisioncoordz].air = 0
		
	endif

// ADD CUBE
	if GetRawKeyPressed(17) or GetRawMouseLeftState() // CTRL or left mouse button to add
		//add cube
		DeleteObject(chunk)
		collisiondata[collisioncoordx,collisioncoordz].air = 1 
		inc collisiondata[collisioncoordx,collisioncoordz].height
		addCubeToMesh(collisioncoordx,getheightofcube(collisioncoordx,collisioncoordz),collisioncoordz,1,1,1,1)
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)


		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
	Print("Number of chunks -* " + str(numofchunks))
	print("Number of Cubes - " + str(numofcubes))
	Print("Vertex Length " + str(meshid.VertexList.length))
    Print( ScreenFPS() )
    Sync()
loop

function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=size/2
	cameray#=size/2+10
	cameraz#=size/2

	SetCameraRange(1,.01,1000)	

// crate centre object
	centrespr = CreateObjectPlane(.8,.8)
	SetObjectRotation(centrespr,90,0,0)
	SetObjectColor(centrespr,100,100,100,20)
	SetRawMousePosition(startx#,starty#)
	

endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for farx=-renderdistance to renderdistance
		for farz=-renderdistance to renderdistance
			chunks.insert(buildchunk(img))
			inc numofchunks
			SetObjectPosition(chunks[chunkid],farx * size, 0, farz * size)
			inc chunkid
			
		next
	next
	DeleteText(building)
endfunction

function buildchunk(img)
	
v=0
// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		h=random(size/2,size/2+1)
		h=size/2
		collisiondata[x+size/2,z+size/2].id = v
		collisiondata[x+size/2,z+size/2].air=1
		collisiondata[x+size/2,z+size/2].height=h
		collisiondata[x+size/2,z+size/2].vertexindex=v
		
		addCubeToMesh(x+size/2,h,z+size/2,1,1,1,1)
			
		inc numofcubes
		inc v,36
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next
//DeleteObject(chunk)
chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
//emptymesh()
endfunction	chunk
	

function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2
	print("X - " + str(collisioncoordx))
	print("Z - " + str(collisioncoordz))
	print("Y - " + str(getheightofcube(collisioncoordx,collisioncoordz)))
	print("CUBE No " + str(collisiondata[collisioncoordx,collisioncoordz].id))
	print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,collisioncoordz].vertexindex))
	SetObjectPosition(centrespr,collisioncoordx,getheightofcube(collisioncoordx,collisioncoordz)+.6,collisioncoordz)
	
endfunction 

function getheightofcube(cx,cz)
	
	cy=collisiondata[cx,cz].height
	
	
endfunction cy

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction

function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
endfunction 1

function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2
	print("X - " + str(collisioncoordx))
	print("Y - " + str(collisioncoordy))
	print("Z - " + str(collisioncoordz))
	
//	print("Y - " + str(getheightofcube(collisioncoordx,collisioncoordz)))
	print("CUBE No " + str(collisiondata[collisioncoordx,collisioncoordz].id))
	print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,collisioncoordz].vertexindex))
	SetObjectPosition(centrespr,collisioncoordx,getheightofcube(collisioncoordx,collisioncoordz)+.6,collisioncoordz)
	
endfunction 

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes

// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
	height
	vertexindex
endtype
//global collisiondata as _CollisionData[size,size,size]
global collisiondata as _CollisionData[size,size, size]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types
global img,camerax#,cameray#,cameraz#,centrespr

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


buildworld()

initialisecamera()




do
	//SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawKeyState(32) or GetRawMouseRightPressed() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

		for xx=-1 to 1
			for zz=-1 to 1
				// if there is no cube at the position that add and dont check itself
			//	if xx<>0 and zz<>0
			//		if collisiondata[collisioncoordx+xx,collisioncoordz+zz].air = 0
						collisiondata[collisioncoordx+xx,size/2,collisioncoordz+zz].id = 0
						collisiondata[collisioncoordx+xx,size/2,collisioncoordz+zz].air = 1
						addCubeToMesh(collisioncoordx+xx,size/2-1,collisioncoordz+zz,1,1,1,1)
						inc numofcubes
				//	else
					// why bother adding a cube that already exists
					// do nothing
			///		endif
			//	endif
			next

		next

		DeleteObject(chunk)

	// if the cube already been hit then dont need to remove it again
			vindex = collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex
	// chop out a chunk data for the cube
			for a=vindex to vindex + 35
				meshid.VertexList[a].air=0
			next
					
			chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)

	// set the chunk to air
			collisiondata[collisioncoordx,size/2,collisioncoordz].air = 0
			dec collisiondata[collisioncoordx,size/2,collisioncoordz].height
			dec numofcubes
		
	endif

// ADD CUBE
	if GetRawKeyPressed(17) or GetRawMouseLeftState() // CTRL or left mouse button to add
		//add cube
		DeleteObject(chunk)
		collisiondata[collisioncoordx,size/2+1,collisioncoordz].air = 1 
		inc collisiondata[collisioncoordx,size/2+1,collisioncoordz].height
		addCubeToMesh(collisioncoordx,size/2+1,collisioncoordz,1,1,1,1)
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		inc numofcubes
		

		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
	Print("Number of chunks -* " + str(numofchunks))
	print("Number of Cubes - " + str(numofcubes))
	Print("Vertex Length " + str(meshid.VertexList.length))
    Print( ScreenFPS() )
    Sync()
loop

function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=size/2
	cameray#=size/2+10
	cameraz#=size/2

	SetCameraRange(1,.01,1000)	

// crate centre object
	centrespr = CreateObjectPlane(.8,.8)
	SetObjectRotation(centrespr,90,0,0)
	SetObjectColor(centrespr,100,100,100,20)
	SetRawMousePosition(startx#,starty#)
	

endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for farx=-renderdistance to renderdistance
		for farz=-renderdistance to renderdistance
			chunks.insert(buildchunk(img))
			inc numofchunks
			SetObjectPosition(chunks[chunkid],farx * size, 0, farz * size)
			inc chunkid
			
		next
	next
	DeleteText(building)
endfunction

function buildchunk(img)
	
v=0
// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		h=random(size/2,size/2+1)
		h=size/2
		collisiondata[x+size/2,y,z+size/2].id = v
		collisiondata[x+size/2,y,z+size/2].air=1
		collisiondata[x+size/2,y,z+size/2].height=h
		collisiondata[x+size/2,y,z+size/2].vertexindex=v
		
		addCubeToMesh(x+size/2,h,z+size/2,1,1,1,1)
			
		inc numofcubes
		inc v,36
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next
//DeleteObject(chunk)
chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
//emptymesh()
endfunction	chunk
	

function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2
	print("X - " + str(collisioncoordx))
	print("Y - " + str(collisioncoordy))
	print("Z - " + str(collisioncoordz))
	
//	print("Y - " + str(getheightofcube(collisioncoordx,collisioncoordz)))
	print("CUBE No " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].id))
	print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex))
	SetObjectPosition(centrespr,collisioncoordx,size/2+.6,collisioncoordz)
	
endfunction 

function getheightofcube(cx,cy,cz)
	
	cy=collisiondata[cx,cy,cz].height
	
	
endfunction cy

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction

function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
endfunction 1

function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2

	sx#=Get3DVectorXFromScreen(mx#,my#) *size/2
	sz#=Get3DVectorZFromScreen(mx#,my#) * size/2
	print("X - " + str(collisioncoordx))
	print("Z - " + str(collisioncoordz))

	print("Y - " + str(getheightofcube(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex)))

	print("CUBE No " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].id))
	print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex))
	SetObjectPosition(centrespr,collisioncoordx,size/2+.6,collisioncoordz)
	
endfunction 

function getheightofcube(vindex)
	
//	cy=collisiondata[cx,cy,cz].height
	
	// get the height from the vertexindex of the cube itself in teh vertex array
	
	cy = MeshID.VertexList[vindex].y
	
	
endfunction cy

function get_cube_height(objID,cx,cz,direction)
     
    // direction=0 or going down
    // direction=1 for going up
     
// we know the X and Z, so need to go through all the Ys until the centresprite object has hit it and then stop returning that Y
    if direction=0
        // going down ** Removing blocks
        for cy=getobjecty(centrespr) to 0 step -1
            if collisiondata[cx,cy,cz].air = 1 // there is a block so stop and set the height of it
                height=cy
                cy=0
            endif
        next
    else
        // Going up ** Adding blocks
        for cy=getobjecty(centrespr) to size
            if collisiondata[cx,cy,cz].air = 0 // there is an empty space then great block so stop and set the height of it
                height=cy
                cy=size
            endif
        next
    endif
    print("Height: " + str(height))
     
endfunction height
 

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes,chunk
global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz
global vertexcounter=0


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
	vertexindex
endtype
//global collisiondata as _CollisionData[size,size,size]
global collisiondata as _CollisionData[size,size, size]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


buildworld()

initialisecamera()




do
	//SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawKeyState(32) or GetRawMouseRightState() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

		cy = get_cube_height(centrespr,collisioncoordx,collisioncoordz,0)
		
		for xx=-1 to 1
			for zz=-1 to 1
				// if there is no cube at the position that add and dont check itself
				if cy<=size/2 // only add extra blocks to help the underground
					if collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].air = 0 // add a cube if there is an empty space
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].vertexindex = vertexcounter
						inc vertexcounter,36
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].id = numofcubes
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].air = 1
						addCubeToMesh(collisioncoordx+xx,cy-1,collisioncoordz+zz,1,1,1,1)
						inc numofcubes
					endif
				else
					// ignore creating extras if above ground
				endif
			next
		next

		DeleteObject(chunk)

	// if the cube already been hit then dont need to remove it again
			vindex = collisiondata[collisioncoordx,cy,collisioncoordz].vertexindex
	// chop out a chunk data for the cube
			for a=vindex to vindex + 35
				meshid.VertexList[a].air=0
			next
	// set the chunk to air
			collisiondata[collisioncoordx,cy,collisioncoordz].air = 0
			chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)

			dec numofcubes
		
	endif

// ADD CUBE
	if GetRawKeyPressed(17) or GetRawMouseLeftState() // CTRL or left mouse button to add
		//add cube
		DeleteObject(chunk)
		cy = get_cube_height(centrespr,collisioncoordx,collisioncoordz,1)
		
		collisiondata[collisioncoordx,cy,collisioncoordz].air = 1 
		
		collisiondata[collisioncoordx,cy,collisioncoordz].vertexindex = vertexcounter
		inc vertexcounter,36
						
		addCubeToMesh(collisioncoordx,cy,collisioncoordz,1,1,1,1)
		
		
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		inc numofcubes
		

		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
	Print("Number of chunks -* " + str(numofchunks))
	print("Number of Cubes - " + str(numofcubes))
	Print("Vertex Length " + str(meshid.VertexList.length))
    Print( ScreenFPS() )
    Sync()
loop

function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=size/2
	cameray#=size/2+10
	cameraz#=size/2

	SetCameraRange(1,.01,1000)	

// crate centre object
	centrespr = CreateObjectBox(1,1,1)
	SetObjectPosition(centrespr,0,size/2+.6,0)
	SetObjectRotation(centrespr,90,0,0)
	SetObjectColor(centrespr,100,100,100,20)
	SetRawMousePosition(startx#,starty#)

	
endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for farx=-renderdistance to renderdistance
		for farz=-renderdistance to renderdistance
			chunks.insert(buildchunk(img))
			inc numofchunks
			SetObjectPosition(chunks[chunkid],farx * size, 0, farz * size)
			inc chunkid
			
		next
	next
	DeleteText(building)
endfunction

function buildchunk(img)
	
// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		h=random(size/2,size/2+1)
		h=size/2
		collisiondata[x+size/2,y,z+size/2].id = numofcubes
		collisiondata[x+size/2,y,z+size/2].air=1
		collisiondata[x+size/2,y,z+size/2].vertexindex=vertexcounter
		
		addCubeToMesh(x+size/2,h,z+size/2,1,1,1,1)
			
		inc numofcubes
		inc vertexcounter,36
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next
//DeleteObject(chunk)
chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
//emptymesh()
endfunction	chunk
	
function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2

	print("X - " + str(collisioncoordx))
	print("Y - " + str(collisioncoordy))
	print("Z - " + str(collisioncoordz))
//	print("Y - " + str(getheightofcube(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex)))
	print("CUBE No " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].id))
	print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex))
	SetObjectPosition(centrespr,collisioncoordx,get_cube_height(centrespr,collisioncoordx,collisioncoordz,0)+.6,collisioncoordz)
	
	
endfunction 

function get_cube_height(objID,cx,cz,direction)
	
	// direction=0 or going down
	// direction=1 for going up
	
// we know the X and Z, so need to go through all the Ys until the centresprite object has hit it and then stop returning that Y
	if direction=0
		// going down ** Removing blocks
		for cy=getobjecty(centrespr) to 0 step -1
			if collisiondata[cx,cy,cz].air = 1 // there is a block so stop and set the height of it
				height=cy
				cy=0
			endif
		next
	else
		// Going up ** Adding blocks
		for cy=getobjecty(centrespr) to size
			if collisiondata[cx,cy,cz].air = 0 // there is an empty space then great block so stop and set the height of it
				height=cy
				cy=size
			endif
		next
	endif
	print("Height: " + str(height))
	
endfunction height


function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
	SetObjectColor(1,255,255,255,10)
endfunction 1

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes,chunk
global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz
global vertexcounter=0


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
	vertexindex
	beenremoved
endtype
//global collisiondata as _CollisionData[size,size,size]
global collisiondata as _CollisionData[size,size, size]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types

img=LoadImage("\media\texture.png")


//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


buildworld()

initialisecamera()




do
	//SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawKeyState(32) or GetRawMouseRightPressed() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

		cy = get_cube_height(centrespr,collisioncoordx,collisioncoordz,0)
		for xx=-1 to 1
			for zz=-1 to 1
				// if there is no cube at the position that add and dont check itself
				if cy<=size/2 // only add extra blocks to help the underground
					
					if collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].beenremoved = 0 // add a cube if there is an empty space
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].vertexindex = vertexcounter
						inc vertexcounter,36
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].id = numofcubes
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].air = 1
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].beenremoved = 1
						addCubeToMesh(collisioncoordx+xx,cy-1,collisioncoordz+zz,1,1,1,1)
						inc numofcubes
					endif
				else
					// ignore creating extras if above ground
				endif
			next
		next

		DeleteObject(chunk)

	// if the cube already been hit then dont need to remove it again
			vindex = collisiondata[collisioncoordx,cy,collisioncoordz].vertexindex
	// chop out a chunk data for the cube
			for a=vindex to vindex + 35
				meshid.VertexList[a].air=0
			next
	// set the chunk to air
			collisiondata[collisioncoordx,cy,collisioncoordz].air = 0
			collisiondata[collisioncoordx,cy,collisioncoordz].beenremoved = 1
			
			chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)

			dec numofcubes
		
	endif

// ADD CUBE
	if GetRawKeyPressed(17) or GetRawMouseLeftState() // CTRL or left mouse button to add
		//add cube
		DeleteObject(chunk)
		cy = get_cube_height(centrespr,collisioncoordx,collisioncoordz,1)
		
		collisiondata[collisioncoordx,cy,collisioncoordz].air = 1 
		
		collisiondata[collisioncoordx,cy,collisioncoordz].vertexindex = vertexcounter
		inc vertexcounter,36
						
		addCubeToMesh(collisioncoordx,cy,collisioncoordz,1,1,1,1)
		
		
		chunk=CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		inc numofcubes
		

		
	endif


	movecamera()
	
	
	if GetRawKeyState(37) then inc camerax#,.05
	if GetRawKeyState(39) then dec camerax#,.05
	if GetRawKeyState(38) then inc cameraz#,.05
	if GetRawKeyState(40) then dec cameraz#,.05
	if GetRawKeyState(83) then dec cameray#,.05
	if GetRawKeyState(87) then inc cameray#,.05
	
	
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
	
	Print("Number of chunks -* " + str(numofchunks))
	print("Number of Cubes - " + str(numofcubes))
	Print("Vertex Length " + str(meshid.VertexList.length))
    Print( ScreenFPS() )
    Sync()
loop

function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=size/2
	cameray#=size/2+10
	cameraz#=size/2

	SetCameraRange(1,.01,1000)	

// crate centre object
	centrespr = CreateObjectBox(1,1,1)
	SetObjectPosition(centrespr,0,size/2+.6,0)
	SetObjectRotation(centrespr,90,0,0)
	SetObjectColor(centrespr,100,100,100,20)
	SetRawMousePosition(startx#,starty#)

	
endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for farx=-renderdistance to renderdistance
		for farz=-renderdistance to renderdistance
			chunks.insert(buildchunk(img))
			inc numofchunks
			SetObjectPosition(chunks[chunkid],farx * size, 0, farz * size)
			inc chunkid
			
		next
	next
	DeleteText(building)
endfunction

function buildchunk(img)
	
// build chunk mesh
for x=-size/2 to size/2
	y=size/2 
	for z=-size/2 to size/2	
		h=random(size/2,size/2+1)
		h=size/2
		collisiondata[x+size/2,y,z+size/2].id = numofcubes
		collisiondata[x+size/2,y,z+size/2].air=1
		collisiondata[x+size/2,y,z+size/2].vertexindex=vertexcounter
		
		addCubeToMesh(x+size/2,h,z+size/2,1,1,1,1)
			
		inc numofcubes
		inc vertexcounter,36
		//SetObjectPosition(collisiondata[x+size/2,y,z+size/2].id,x,0,z)
	next
next
//DeleteObject(chunk)
chunk = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
//emptymesh()
endfunction	chunk
	
function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * size/2) + size/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * size/2) + size/2

	print("X - " + str(collisioncoordx))
	print("Y - " + str(collisioncoordy))
	print("Z - " + str(collisioncoordz))
//	print("Y - " + str(getheightofcube(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex)))
	print("CUBE No " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].id))
	print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex))
	SetObjectPosition(centrespr,collisioncoordx,get_cube_height(centrespr,collisioncoordx,collisioncoordz,0)+.6,collisioncoordz)
	
	
endfunction 

function get_cube_height(objID,cx,cz,direction)
	
	// direction=0 or going down
	// direction=1 for going up
	
// we know the X and Z, so need to go through all the Ys until the centresprite object has hit it and then stop returning that Y
	if direction=0
		// going down ** Removing blocks
		for cy=getobjecty(centrespr) to 0 step -1
			if collisiondata[cx,cy,cz].air = 1 // there is a block so stop and set the height of it
				height=cy
				cy=0
			endif
		next
	else
		// Going up ** Adding blocks
		for cy=getobjecty(centrespr) to size
			if collisiondata[cx,cy,cz].air = 0 // there is an empty space then great block so stop and set the height of it
				height=cy
				cy=size
			endif
		next
	endif
	print("Height: " + str(height))
	
endfunction height


function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)


	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)



	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)



	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)



	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)







	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
	SetObjectColor(1,255,255,255,10)
endfunction 1

//// show all errors
SetErrorMode(2)
 
#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant KEY_LEFT         37
#constant KEY_UP           38
#constant KEY_RIGHT        39
#constant KEY_DOWN         40
#constant KEY_A            65
#constant KEY_D            68
#constant KEY_E            69 
#constant KEY_Z            90
#constant KEY_M            77
#constant KEY_S            83
#constant KEY_L            76
#constant KEY_C            67
#constant KEY_HOME         36
#constant KEY_PLUS         107
#constant KEY_SUBTRACT     109
#constant KEY_SHIFT        16
#constant Depth#=48
// set window properties
SetWindowTitle( "Height map Extrude Tool V1" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window
 
// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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


type _boxes
    id
    memID
    x#
    y#
    z#
endtype

final_object as integer	
global objnumber,width
global boxes as _boxes[]
//global size=0
camerax#=32
cameray#=20
cameraz#=-85
centreObjId=0
image=0
extrude=220:direction=1
final_object=0

global centrespr
centrespr = CreateObjectBox(1,1,1)
//SetObjectRotation(centrespr,90,0,0)
SetObjectColor(centrespr,100,100,100,20)
box as _boxes
do
	print(depth#)
	moveblockwithmouse()
	if GetRawKeyState(KEY_LEFT) then dec camerax#,.25
	if GetRawKeyState(KEY_RIGHT) then inc camerax#,.25
	if GetRawKeyState(KEY_UP) then dec cameray#,.25
	if GetRawKeyState(KEY_DOWN) then inc cameray#,.25
	if GetRawKeyState(KEY_A) then inc cameraz#,.25
	if GetRawKeyState(KEY_Z) then dec cameraz#,.25
	
	if GetRawKeyPressed(KEY_L) 
		ret$=ChooseRawFile("*.jpg;*.png",1)
		if ret$<>""
             image=loadImage("raw:"+ret$)
             imgmemblock = CreateMemblockFromImage(image)
			 width = GetMemblockInt(imgmemblock,0)
			 depth = GetMemblockInt(imgmemblock,4)
			 if mod(width,2)<>0 or mod(depth,2)<>0
				 Message("The image wasnt suitable. It needs to be an even number width and height")
				 ret$="":DeleteImage(image):DeleteMemblock(imgmemblock)
			 endif	 
        endif
	endif	
	
	if GetRawKeyPressed(KEY_E)
		if ret$<>""
			centreObjId=normalHeightFunction(256-extrude,direction,"raw:"+ret$) 
			deletedObjects=dohousekeeping()				
			/*
			AGM_SaveObject("raw:"+left(ret$,len(ret$)-4)+".obj","raw:"+left(ret$,len(ret$)-4)+".mtl")
			final_object=LoadObject("raw:"+left(ret$,len(ret$)-4)+".obj")
			SetObjectColor(final_object,200,0,0,255)
			SetObjectPosition(final_object,0,0,0)
			RotateObjectLocaly(final_object,-180)*/
			camerax#=-63
			cameray#=25
			cameraz#=-50
		endif	
	endif
	
	if GetRawMouseLeftPressed()
		object_Hit=checkCollision(centrespr)
		if object_Hit>0 and object_Hit<>centrespr
			box=getObjectToChange(object_Hit)
			raiseObject(box,100)
		endif
	endif		
	
	if GetRawKeyPressed(KEY_C)
		for num = boxes.length to 0 step -1
			DeleteObject(boxes[num].id)
			boxes.remove(num)
		next num
		DeleteAllObjects()
		final_object=0
	endif

	
	if GetRawKeyPressed(KEY_HOME)
		if getObjectExists(centreObjID)
			xx#=GetObjectX(centreObjID)
			yy#=GetObjectY(centreObjID)
			zz#=GetObjectZ(centreObjID)
			for num = boxes.length to 0 step -1
				if GetObjectExists(boxes[num].id)
					SetObjectPosition(boxes[num].id,getObjectX(boxes[num].id)-xx#,0,getObjectZ(boxes[num].id)-zz#)
				endif
			next num
		else
			If GetObjectExists(final_object)
				SetObjectPosition(final_object,0,0,0)
			endif
		endif	
		camerax#=0
		cameray#=25
		cameraz#=-50
	endif
	
	print("Height map Extrude Tool V1")
	if ret$="" 
		print("No image Loaded please load an image to extrude")
	else	
		print(left(ret$,len(ret$)-4))
	endif
	if boxes.length<0 
		print("No blocks in memory please use one of the extrude functions")
	else
		print("Number of blocks in memory "+str(boxes.length))
	endif	
	print("Press Home to center")
	print("Press C to clear")
    print("Press L to load image")
	print("Press E to Extrude")
	print("Camera X "+str(getCameraX(1)))
	print("Camera Y "+str(getCameraY(1)))
	print("Camera Z "+str(getCameraZ(1)))
    Print("FPS "+str( ScreenFPS()) )
    SetCameraPosition(1,camerax#,cameray#,cameraz#)
    Sync()
loop

function normalHeightFunction(extrudeDivisor as integer,direction as integer, filename$)
//top left front 0,9,18
//top right front 2,4,11
//top left back 8,14,16
//top right back 6,10,12
vertexLF as integer[2] = [0,9,18]
vertexRF as integer[2] = [2,4,11]
vertexLB as integer[2] = [8,14,16]
vertexRB as integer[2] = [6,10,12]

vertexBLF as integer[2] = [1,19,20]
vertexBRF as integer[2] = [3,5,22]
vertexBLB as integer[2] = [15,17,21]
vertexBRB as integer[2] = [7,13,23]

//bottom left front 1,19,20
//bottom right front 3,5,22
//bottom left back 15,17,21,24,25,26,27
//bottom right back 7,13,23,
box as _boxes
img = LoadImage(filename$)
imgmemblock = CreateMemblockFromImage(img)
//local size as integer     
width = GetMemblockInt(imgmemblock,0)
depth = GetMemblockInt(imgmemblock,4)
objnumber=0
for z=depth-1 to 0 step -1
	for x=width-1 to 0 step -1
		
		Offset = (12+((z * width) + x) * 4) - 4
		r=GetMemblockByte(imgmemblock,Offset)
		g=GetMemblockByte(imgmemblock,Offset+1)
		b=GetMemblockByte(imgmemblock,Offset+2)
		a=GetMemblockByte(imgmemblock,Offset+3)
		color#=(r+g+b) 
		Height#=(color#/extrudeDivisor)
		
		box.id=CreateObjectBox(1,1,1)
		boxes.insert(box)
		SetObjectPosition(boxes[objnumber].id,-x, 0 ,-z)
		SetObjectColor(boxes[objnumber].id,r,g,b,a)
		boxes[objnumber].memID=CreateMemblockFromObjectMesh(boxes[objnumber].id,1)
			
		for i = 0 to 2
			SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexRF[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexRF[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexRF[i])+Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexRF[i]))
			SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexRB[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexRB[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexRB[i])+Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexRB[i]))	
			SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexLF[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexLF[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexLF[i])+Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexLF[i]))
			SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexLB[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexLB[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexLB[i])+Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexLB[i]))	
		next i
		if direction=2
			for i = 0 to 2
				SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexBRF[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexBRF[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexBRF[i])-Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexBRF[i]))
				SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexBRB[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexBRB[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexBRB[i])-Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexBRB[i]))	
				SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexBLF[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexBLF[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexBLF[i])-Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexBLF[i]))
				SetMeshMemblockVertexPosition(boxes[objnumber].memID,vertexBLB[i],GetMeshMemblockVertexX(boxes[objnumber].memID,vertexBLB[i]),GetMeshMemblockVertexY(boxes[objnumber].memID,vertexBLB[i])-Height#,GetMeshMemblockVertexZ(boxes[objnumber].memID,vertexBLB[i]))	
			next i
		endif	
		SetObjectMeshFromMemblock(boxes[objnumber].id,1,boxes[objnumber].memID)
		//DeleteMemblock(memID)
		
		if (width-1)/2=x and (depth-1)/2=z then centreObjId=boxes[objnumber].id
		if (width-1)/2=x and (depth-1)=z then SetCameraPosition(1,getObjectX(boxes[objnumber].id),getObjectY(boxes[objnumber].id)+20,getObjectz(boxes[objnumber].id)-20)
		DeleteMemblock(boxes[objnumber].memID) 
		inc objnumber:rem if objnumber =width*depth then exitfunction centreObjID
	next x
next z

endfunction	centreObjId

function raiseObject(box ref as _boxes,Height# as float)
//top left front 0,9,18
//top right front 2,4,11
//top left back 8,14,16
//top right back 6,10,12
vertexLF as integer[2] = [0,9,18]
vertexRF as integer[2] = [2,4,11]
vertexLB as integer[2] = [8,14,16]
vertexRB as integer[2] = [6,10,12]

vertexBLF as integer[2] = [1,19,20]
vertexBRF as integer[2] = [3,5,22]
vertexBLB as integer[2] = [15,17,21]
vertexBRB as integer[2] = [7,13,23]

//bottom left front 1,19,20
//bottom right front 3,5,22
//bottom left back 15,17,21,24,25,26,27
//bottom right back 7,13,23,
		
		//box.id=CreateObjectBox(1,1,1)
		//boxes.insert(box)
		//SetObjectPosition(box.id,-x, 0 ,-z)
		//SetObjectColor(box.id,r,g,b,a)
		box.memID=CreateMemblockFromObjectMesh(box.id,1)
			
		for i = 0 to 2
			SetMeshMemblockVertexPosition(box.memID,vertexRF[i],GetMeshMemblockVertexX(box.memID,vertexRF[i]),GetMeshMemblockVertexY(box.memID,vertexRF[i])+Height#,GetMeshMemblockVertexZ(box.memID,vertexRF[i]))
			SetMeshMemblockVertexPosition(box.memID,vertexRB[i],GetMeshMemblockVertexX(box.memID,vertexRB[i]),GetMeshMemblockVertexY(box.memID,vertexRB[i])+Height#,GetMeshMemblockVertexZ(box.memID,vertexRB[i]))	
			SetMeshMemblockVertexPosition(box.memID,vertexLF[i],GetMeshMemblockVertexX(box.memID,vertexLF[i]),GetMeshMemblockVertexY(box.memID,vertexLF[i])+Height#,GetMeshMemblockVertexZ(box.memID,vertexLF[i]))
			SetMeshMemblockVertexPosition(box.memID,vertexLB[i],GetMeshMemblockVertexX(box.memID,vertexLB[i]),GetMeshMemblockVertexY(box.memID,vertexLB[i])+Height#,GetMeshMemblockVertexZ(box.memID,vertexLB[i]))	
		next i
		//if direction=2
		//	for i = 0 to 2
		//		SetMeshMemblockVertexPosition(box[objnumber].memID,vertexBRF[i],GetMeshMemblockVertexX(box[objnumber].memID,vertexBRF[i]),GetMeshMemblockVertexY(box.memID,vertexBRF[i])-Height#,GetMeshMemblockVertexZ(box.memID,vertexBRF[i]))
		//		SetMeshMemblockVertexPosition(box[objnumber].memID,vertexBRB[i],GetMeshMemblockVertexX(box[objnumber].memID,vertexBRB[i]),GetMeshMemblockVertexY(box.memID,vertexBRB[i])-Height#,GetMeshMemblockVertexZ(box.memID,vertexBRB[i]))	
		//		SetMeshMemblockVertexPosition(box[objnumber].memID,vertexBLF[i],GetMeshMemblockVertexX(box[objnumber].memID,vertexBLF[i]),GetMeshMemblockVertexY(box.memID,vertexBLF[i])-Height#,GetMeshMemblockVertexZ(box.memID,vertexBLF[i]))
		//		SetMeshMemblockVertexPosition(box[objnumber].memID,vertexBLB[i],GetMeshMemblockVertexX(box[objnumber].memID,vertexBLB[i]),GetMeshMemblockVertexY(box.memID,vertexBLB[i])-Height#,GetMeshMemblockVertexZ(box.memID,vertexBLB[i]))	
		//	next i
		//endif	
		SetObjectMeshFromMemblock(box.id,1,box.memID)
		//DeleteMemblock(memID)
		
		//if (width-1)/2=x and (depth-1)/2=z then centreObjId=boxes[objnumber].id
		//if (width-1)/2=x and (depth-1)=z then SetCameraPosition(1,getObjectX(boxes[objnumber].id),getObjectY(boxes[objnumber].id)+20,getObjectz(boxes[objnumber].id)-20)
		DeleteMemblock(box.memID) 
		
endfunction	  //centreObjId


function dohousekeeping()
	DeletedObjects=0
	for num = boxes.length to 0 step -1
		if GetObjectExists(boxes[num].id)
			r=GetObjectColorRed(boxes[num].id)
			b=GetObjectColorBLue(boxes[num].id)
			g=GetObjectColorGreen(boxes[num].id)
			if r+b+g<1 
				DeleteObject(boxes[num].id)
				boxes.remove(num)
				inc DeletedObjects
			endif
		endif
	next num

endfunction DeletedObjects	

Function AGM_SaveObject(filename$ as string,material$ as string)
fw = OpenToWrite(filename$) 
  
WriteLine(fw,"#AGM Object - " + filename$)
WriteLine(fw,"#Exported with AppGameKit")
WriteLine(fw,"")
WriteLine(fw,"mtllib " + trimPath(material$))
incrementalcounter=0
   
`number of material
m=0
for t= boxes.length to 0 step-1
    if GetObjectExists(boxes[t].id) 
        mesh = CreateMemblockFromObjectMesh(boxes[t].id,1)
`       get object vertex quantity 
        verts= GetMemblockInt( mesh, 0 )
        writeline(fw,"g ") //GROUP
   
        `VERTEX
        for i= 0 to verts -1
            x#=GetMeshMemblockVertexX(mesh,i)
            y#=GetMeshMemblockVertexy(mesh,i)
            z#=GetMeshMemblockVertexz(mesh,i)
            ox#=(width-1)-GetObjectWorldX(boxes[t].id)
            oy#=GetObjectWorldY(boxes[t].id)
            oz#=GetObjectWorldZ(boxes[t].id)
  
            Writeline ( fw, " v " + str(x#+ox#)+ " "+str(y#+oy#)+ " "+str(z#+oz#))
        next i
   
    `TEXTURE VEERTICES
    for i= 1 to verts
        uu#=GetMeshMemblockVertexU( mesh, i )
        vv#=GetMeshMemblockVertexV( mesh, i )
        writeline(fw, " vt "+str(uu#)+" "+str(vv#))
    next
    
  `     NORMALS
    for i= 0 to verts -1
        x#=GetMeshMemblockVertexnormalX(mesh,i)
        y#=GetMeshMemblockVertexnormaly(mesh,i)
        z#=GetMeshMemblockVertexnormalz(mesh,i)
  
        Writeline ( fw, " vn " + str(x#)+ " "+str(y#)+ " "+str(z#))
    next i
     
    
    `FACES
   
    inc m,1
    //Writeline ( fw,"usemtl Material.00"+str(m))
    Writeline ( fw,"usemtl Material.00")
    
    s=0 `reseting variable s
  
   for i= 1 to verts-4
         
    inc s,1
      if s=3
        n=n+1
        nor=nor+4
        writeline (fw, " f "+ str(n+1)+"/"+str(n+1)+"/"+str(nor)    +" "+str(n) +"/"+str(n+2)+"/"+str(nor)     +" "+str(n+2)+"/"+str(n)+"/"+str(nor)      +" "+str(n+3)+"/"+str(n+3)+"/"+str(nor))
        s=0
        n=n+3
      endif
   next
   DeleteMemblock(mesh)
endif
next t
CloseFile ( fw )  
 /*
fw=OpenToWrite(material$)
for t= boxes.length to 0 step-1
    if GetObjectExists(boxes[t].id) 
        //Writeline ( fw,"newmtl Material.00"+str(t))
        Writeline ( fw,"newmtl Material.00")
        
        WriteLine(fw,"Kd " + str(GetObjectColorRed(boxes[t].id)/255.0) + " " + str(GetObjectColorGreen(boxes[t].id)/255.0) + " " + str(GetObjectColorBlue(boxes[t].id)/255.0))
        DeleteObject(boxes[t].id)
        DeleteMemblock(boxes[t].memID)
        boxes.remove(t)
    endif
next t
CloseFile(fw)
*/
for num = boxes.length to 0 step -1
    DeleteObject(boxes[num].id)
    DeleteMemblock(boxes[num].memID)
    boxes.remove(num)
next num    
DeleteAllObjects()
endfunction

function trimPath(str$ as string)
num=len(str$)
if num<1 then exitfunction ""
repeat 
	dec num
until mid(str$,num,1)="\"
for num2=(num+1) to len(Str$)	
	trimStr$=trimStr$+mid(str$,num2,1) 
next
endfunction trimStr$

function moveblockwithmouse()
 
	VectorX# = Get3DVectorXFromScreen( GetPointerX(), GetPointerY() )
	VectorY# = Get3DVectorYFromScreen( GetPointerX(), GetPointerY() )
	VectorZ# = Get3DVectorZFromScreen( GetPointerX(), GetPointerY()*2 )
  
// get a vector that points in the direction the camera is looking
	VectorX2# = Get3DVectorXFromScreen( GetVirtualWidth()/2.0, GetVirtualHeight()/2.0 )
	VectorY2# = Get3DVectorYFromScreen( GetVirtualWidth()/2.0, GetVirtualHeight()/2.0 )
	VectorZ2# = Get3DVectorZFromScreen( GetVirtualWidth()/2.0, GetVirtualHeight()/2.0 )
  
// normalise Vector in the direction of Vector2
	Dot# = VectorX#*VectorX2# + VectorY#*VectorY2# + VectorZ#*VectorZ2#
	if ( Dot# > 0 )
		VectorX# = VectorX# / Dot#
		VectorY# = VectorY# / Dot#
		VectorZ# = VectorZ# / Dot#
	endif
  
	WorldX# = VectorX# * Depth# + GetCameraX(1)
	WorldY# = VectorY# * Depth# + GetCameraY(1)
	WorldZ# = VectorZ# * Depth# + GetCameraZ(1)
	object_Hit=checkCollision(centrespr)
	if object_Hit>0 and object_Hit<>centrespr
		height#=(GetObjectMeshSizeMaxY(object_Hit,1)-GetObjectMeshSizeMinY(object_Hit,1))/2 
		SetObjectPosition(centrespr,getObjectX(centrespr),GetObjectMeshSizeMaxY(object_Hit,1)+1.5,getObjectZ(centrespr))
	else
		SetObjectPosition(centrespr,WorldX#,worldY# ,WorldZ#)
	endif

endfunction

function checkCollision(objId as integer)
	local width# as float
	local height# as float
	local depth2# as float
	local x# as float
	local y# as float
	local z# as float
	local start_x# as float
	local start_y# as float
	local start_z# as float
	local end_x# as float
	local end_y# as float
	local end_z# as float 
	local object_Hit as integer	

	//this checks for colliion between an object with any other object and returns its id
	width#=(GetObjectMeshSizeMaxX(objID,1)-GetObjectMeshSizeMinX(objID,1))/2 
	height#=(GetObjectMeshSizeMaxX(objID,1)-GetObjectMeshSizeMinX(objID,1))/2 
	depth2#=(GetObjectMeshSizeMaxX(objID,1)-GetObjectMeshSizeMinX(objID,1))/2 
 
	x#=getObjectWorldX(objID)
	y#=GetObjectWorldY(objID)
	z#=getObjectWorldZ(objID)


	// calculate the start of the ray cast
	start_x# = x#-width#
	start_y# = y#+height#
	start_z# = z#-depth# 

	// calculate the end of the ray cast
	end_x# = x#+width#   
	end_y# = y#-height#
	end_z# = z#+depth#
 
	// determine which object has been hit
	object_Hit = ObjectRayCast(0,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)
endfunction	object_Hit

function getObjectToChange(objID)
	for num=0 to boxes.length
		if boxes[num].id=objID then exitfunction boxes[num]
	next num	
endfunction	boxes[num]

/// Project: Craft-A-Lite 
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
//#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant CHUNK_HEIGHT=1
#constant CHUNK_WIDTH=128
#constant CHUNK_COLUMN_HEIGHT=0
#constant vel#=0.5 // velocity of the camera/player

// just the the sake of colliion destection works on blocks that are on your eye level - then 
// then made it so there is a 60% chance of a block on eye level - so can do collisiotn detectioning
#constant HEIGHTRANDOMNESS = 95 // this can be changed but utilmately removed altogether when collision works perfectly - high is less, low is more



#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Craft-A-Lite" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy, worldcoordx, worldcoordy,worldcoordz

// character controller variables
global onground#, velx#, vely#,velz#, speed#


// chunk variable
global numofchunks, numofcubes,chunk,chunkid



global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz, actualverts
global vertexcounter=0


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

type _CollisionData
	id
	air // 1- block // 0- air
	vertexindex
	vertices as Vertex[]
	beenremoved
endtype
//global collisiondata as _CollisionData[size,size,size]
global collisiondata as _CollisionData[CHUNK_WIDTH,CHUNK_HEIGHT, CHUNK_WIDTH]
CD as _CollisionData

global chunks as integer[]

// meshmemblock types

img=LoadImage("\media\texture.png")

CreateObjectSphere(80000,4000,50,50)
SetObjectCullMode(80000,0)
SetObjectColor(80000,135,206,250,255)
//SetObjectColorEmissive(80000,0,0,255)
 

//SetImageWrapU(img,1)
//SetImageWrapV(img,1)
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)

	actualverts=0
	worldcoordx=0
	worldcoordy=0
	worldcoordz=0
	
	SetPrintSize(16)
//SetPrintColor(0,0,0)

buildworld()

initialisecamera()


debug=1
do
	//SetSpritePosition(centrespr,screenwidth/2,screenheight/2)
	
	//
	Get_world_coordinates()

	if GetRawMouseRightPressed() // SPACE or left mouse button
	// delete the object
		// but require to add more (underneath)

		cy = get_cube_height_onmouselocation(centrespr,collisioncoordx,collisioncoordz,0)
		for xx=-1 to 1
			for zz=-1 to 1
				// if there is no cube at the position that add and dont check itself
				if cy<=CHUNK_HEIGHT/2 // only add extra blocks to help the underground
					
					if collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].beenremoved = 0 // add a cube if there is an empty space
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].vertexindex = vertexcounter
						inc vertexcounter,36
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].id = numofcubes
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].air = 1
						collisiondata[collisioncoordx+xx,cy-1,collisioncoordz+zz].beenremoved = 1
						addCubeToMesh(collisioncoordx+xx,cy-1,collisioncoordz+zz,1,1,1,1)
						inc numofcubes
					endif
				else
					// ignore creating extras if above ground
				endif
			next
		next

		DeleteObject(chunk)

	// if the cube already been hit then dont need to remove it again
			vindex = collisiondata[collisioncoordx,cy,collisioncoordz].vertexindex
	// chop out a chunk data for the cube
			for a=vindex to vindex + 35
				meshid.VertexList[a].air=0
			next
	// set the chunk to air
			collisiondata[collisioncoordx,cy,collisioncoordz].air = 0
			collisiondata[collisioncoordx,cy,collisioncoordz].beenremoved = 1
			
			CreateObjectFromMeshWithUVTexturing(chunkid,meshid,1,img)

			dec numofcubes
		
	endif

// ADD CUBE
	if GetRawKeyPressed(17) or GetRawMouseLeftState() // CTRL or left mouse button to add
		//add cube
		DeleteObject(chunk)
		cy = get_cube_height_onmouselocation(centrespr,collisioncoordx,collisioncoordz,1)
		
		collisiondata[collisioncoordx,cy,collisioncoordz].air = 1 
		
		collisiondata[collisioncoordx,cy,collisioncoordz].vertexindex = vertexcounter
		inc vertexcounter,36
						
		addCubeToMesh(collisioncoordx,cy,collisioncoordz,1,1,1,1)
		
		
		CreateObjectFromMeshWithUVTexturing(chunkid,meshid,1,img)
		inc numofcubes
		

		
	endif


	movecamera()
	
	
	charactercontroller()
	
	

	
	if debug=1
		print("Chunk ID = " )
		print("Mouse Position on Chunk X - " + str(collisioncoordx) + " - PlayeronChunkX - " + str(floor(camerax#+velx#)) + " World X "+ str(floor(worldcoordx)))
		print("Mouse Position on Chunk Y - " + str(collisioncoordy) + " - PlayeronChunkY - " + str(floor(cameray#+vely#)) + " World X "+ str(floor(worldcoordy)))
		print("Mouse Position on Chunk Z - " + str(collisioncoordz) + " - PlayeronChunkZ - " + str(floor(cameraz#+velz#)) + " World X "+ str(floor(worldcoordz)))
		//print("Y - " + str(getheightofcube(collisiondata[collisioncoordx,size/2,collisioncoordz].vertexindex)))
		print("CUBE No " + str(collisiondata[collisioncoordx,CHUNK_HEIGHT/2,collisioncoordz].id))
		print("CUBE Vertex Index " + str(collisiondata[collisioncoordx,CHUNK_HEIGHT/2,collisioncoordz].vertexindex))
		Print("Number of chunks -* " + str(numofchunks))
		print("Number of Cubes - " + str(numofcubes))
		Print("Vertex Length " + str(meshid.VertexList.length))
		print("True Vertices " + str(actualverts))
    endif
    
    Print( ScreenFPS() )
    Sync()
loop

function charactercontroller()
	
	// save old camera position values in case surrounding collision check is HIT
	oldx#=camerax#
	oldy#=cameray#
	oldz#=cameraz#
	
	px=floor(camerax#+velx#+.5)
	py=floor(cameray#+vely#)
	pz=floor(cameraz#+velz#+.5)
	print(px-1)
	print(px+1)
	print(pz+1)
	print(pz-1)
	
	if collisiondata[px-1,py,pz].air=0 and GetRawKeyState(37) then dec velx#,speed#
	if collisiondata[px+1,py,pz].air=0 and GetRawKeyState(39) then inc velx#,speed#
	if collisiondata[px,py,pz-1].air=0 and GetRawKeyState(40) then dec velz#,speed#
	if collisiondata[px,py,pz+1].air=0 and GetRawKeyState(38) then inc velz#,speed#



	
		if GetRawKeyState(32) then inc vely#,speed# *8


		if GetRawKeyState(83) then dec cameray#,speed#
		if GetRawKeyState(87) then inc cameray#,speed# 
	
		if vely#>speed#*8 then dec vely#,speed#*8
	
		checkandsetboundaries()
		
		if vely#<=0 	
			// find the height of the currrent location on the chunk and set it
//			cameray#=get_camera_height(floor(camerax#+velx#),cameray#,floor(cameraz#+velz#))
		
		endif
		if velz#<=-CHUNK_WIDTH/2 then velz#=-CHUNK_WIDTH/2

	
	
	SetCameraPosition(1,camerax#+velx#,cameray#+vely#,cameraz#+velz#)

endfunction

function checkandsetboundaries()
	if velx#<=-CHUNK_WIDTH/2 then velx#=-CHUNK_WIDTH/2
	if velx#>=CHUNK_WIDTH/2 then velx#=CHUNK_WIDTH/2
	if velz#<=-CHUNK_WIDTH/2 then velz#=-CHUNK_WIDTH/2
	if velz#>=CHUNK_WIDTH/2 then velz#=CHUNK_WIDTH/2
	
endfunction


function initialisecamera()
	startx#=screenwidth/2
	starty#=screenheight/2
	camerax#=CHUNK_WIDTH/2
	cameraz#=CHUNK_WIDTH/2
	cameray#=10
	cameray#=get_camera_height(camerax#,cameray#,cameray#)

	onground#=cameray#
	SetCameraRange(1,.01,4100)	

// crate centre object
	centrespr = CreateObjectBox(1,1,1)
	SetObjectPosition(centrespr,0,CHUNK_HEIGHT/2+.6,0)
	SetObjectRotation(centrespr,90,0,0)
	SetObjectColor(centrespr,100,100,100,20)
	SetRawMousePosition(startx#,starty#)

// speed of the character/camera
	speed#=0.005
	
endfunction

function buildworld()
	building = CreateText("Building World - Please Wait")
	SetTextSize(building,30)
	SetTextPosition(building,screenwidth/2-GetTextTotalWidth(building)/2,screenheight/2)
	sync()
	chunkid=0
	numofchunks=0
	numofcubes=0
	for fary=0 to CHUNK_COLUMN_HEIGHT
		for farx=-renderdistance to renderdistance
			for farz=-renderdistance to renderdistance
				chunks.insert(buildchunk(img))
				inc numofchunks
				SetObjectPosition(chunks[chunkid],farx * CHUNK_WIDTH, fary * CHUNK_HEIGHT, farz * CHUNK_WIDTH)
				inc chunkid
			
			next
		next
	next
	inc worldcoordx,CHUNK_WIDTH * (renderdistance+1)
	inc worldcoordy,CHUNK_HEIGHT * (CHUNK_HEIGHT+1)
	inc worldcoordz,CHUNK_WIDTH * (renderdistance+1)

	DeleteText(building)
endfunction

function buildchunk(img)

for y=0 to CHUNK_HEIGHT
		
	for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
			for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2	
	
				collisiondata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].id = numofcubes
				if y=0
						collisiondata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air=1
					
				else
					
					if random(0,100)>HEIGHTRANDOMNESS
						collisiondata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air=1
					else
						collisiondata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air=0
					endif	
				endif
				
				collisiondata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].vertexindex=vertexcounter
		
				addCubeToMesh(x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2,1,1,1,collisiondata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air)
				inc numofcubes
				inc vertexcounter,36

			next
		next
	next
	
	CreateObjectFromMeshWithUVTexturing(chunkid,meshid,1,img)
//emptymesh()
endfunction	chunkid
	
function get_world_coordinates()
 
	cx#=GetCameraX(1)
	cy#=GetCameray(1)
	cz#=GetCameraz(1)

	mx#=getpointerx()
	my#=getpointery()
	
	collisioncoordx=floor(Get3DVectorXFromScreen(mx#,my#) * CHUNK_WIDTH/2) + CHUNK_WIDTH/2
	collisioncoordy=floor(Get3DVectorYFromScreen(mx#,my#) * CHUNK_HEIGHT/2) + CHUNK_HEIGHT/2
	collisioncoordz=floor(Get3DVectorZFromScreen(mx#,my#) * CHUNK_WIDTH/2) + CHUNK_WIDTH/2


	
	//SetObjectPosition(centrespr,collisioncoordx,get_cube_height_onmouselocation(centrespr,collisioncoordx,collisioncoordz,0)+.6,collisioncoordz)
	
	
endfunction 


function get_camera_height(cx,cy,cz)
	height=cy
	for cy=getcameray(1) to 0 step -1
		if cy<=CHUNK_HEIGHT
			if collisiondata[cx,cy,cz].air = 1 // there is a block so stop and set the height of it
				height=cy+1
				cy=0
			endif
		endif	
		
	next
	
endfunction height

function get_cube_height_onmouselocation(objID,cx,cz,direction)
	
	// direction=0 or going down
	// direction=1 for going up
	
// we know the X and Z, so need to go through all the Ys until the centresprite object has hit it and then stop returning that Y
	if direction=0
		// going down ** Removing blocks
		for cy=getobjecty(objID) to 0 step -1
			if collisiondata[cx,cy,cz].air = 1 // there is a block so stop and set the height of it
				height=cy
				cy=0
			endif
		next
	else
		// Going up ** Adding blocks
		for cy=getobjecty(objID) to CHUNK_HEIGHT
			if collisiondata[cx,cy,cz].air = 0 // there is an empty space then great block so stop and set the height of it
				height=cy
				cy=CHUNK_HEIGHT
			endif
		next
	endif
	print("Height: " + str(height))
	
endfunction height


function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	
	//if collisiondata[cx,cy+1,cz].air = 0 // is the cube above is AIR then create a face otherwise dont
	// TOP face - top left corner texture
	//                                                                                       Normals, U Vs      , Color
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)
	inc actualverts,6
	//endif

//	if collisiondata[cx,cy-1,cz].air = 0 // is the cube above is AIR then create a face otherwise dont
	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)
	inc actualverts,6
	//endif

//	if cx-1>1
	//if collisiondata[cx-1,cy,cz].air = 0 // is the cube above is AIR then create a face otherwise dont
	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	inc actualverts,6
//	endif
	//endif

//	if cx+1<size-1
	//if collisiondata[cx+1,cy,cz].air = 0 // is the cube above is AIR then create a face otherwise dont
		
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)
	inc actualverts,6
//	endif
		
	//endif
	

//	if cz+1<size
	//if collisiondata[cx,cy,cz+1].air = 0 // is the cube above is AIR then create a face otherwise dont
		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	inc actualverts,6
	//endif 
	//endif

//	if cz-1>0
	//if collisiondata[cx,cy,cz-1].air = 0 // is the cube above is AIR then create a face otherwise dont
		

	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)
	inc actualverts,6

//	endif
	//endif





	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(chunkid,m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next

    CreateObjectFromMeshMemblock(chunkid,chunkmesh)
    SetObjectImage(chunkid,texture,0)
	SetObjectColor(chunkid,255,255,255,10)
endfunction chunkid

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes,chunk, hitobject
global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz, actualverts
global vertexcounter=0


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


hitobject=CreateObjectBox(1,1,1)
SetObjectColor(hitobject,255,0,0,255)

camerax#=0
cameray#=5
cameraz#=-10

startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)

gap=5
for x=-20 to 20
	for y=-20 to 20
		for z=-20 to 20
	
			if mod(abs(x),gap)=1 and mod(abs(y),gap)=1 and mod(abs(z),gap)=1
				addCubeToMesh(x,y,z,1,1,1,1)
			endif
		next
	next
next

obj=CreateObjectFromMeshWithUVTexturing(meshid,1,0)


do
	getworldcoords()
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop


function getworldcoords()
	
	// get the position of the pointer (mouse)
        pointer_x = GetPointerX()
        pointer_y = GetPointerY()

        // get the x, y and z unit vectors based on the pointer position
        unit_x# = Get3DVectorXFromScreen(pointer_x,pointer_y)
        unit_y# = Get3DVectorYFromScreen(pointer_x,pointer_y)
        unit_z# = Get3DVectorZFromScreen(pointer_x,pointer_y)

		
        // calculate the start of the ray cast, which is the unit vector + the camera position
        start_x# = unit_x#
        start_y# = unit_y# + cameray#
        start_z# = unit_z# + cameraz#

        // calculate the end of the vector, which is the unit vector multiplied by the length of the ray cast and then add the camera position to it
        end_x# = 800*unit_x#
        end_y# = 800*unit_y# + cameray#
        end_z# = 800*unit_z# + cameraz#

        // if the mouse in one the ground then position the sphere on the mouse
        if ObjectRayCast(1,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#) <> 0
			print("hit")
            SetObjectPosition(hitobject,GetObjectRayCastX(0),GetObjectRayCastY(0),GetObjectRayCastZ(0))
			SetObjectVisible(hitobject,1)
			print("X - " + str(floor(getobjectx(hitobject))))
			print("Y - " + str(floor(getobjecty(hitobject))))
			print("Z - " + str(floor(getobjectz(hitobject))))
		else
			SetObjectVisible(hitobject,0)
			
        endif

	
endfunction

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)

	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
		
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)

		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)

	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)


	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
	SetObjectColor(1,255,255,255,10)
endfunction 1

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes,chunk, hitobject
global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz, actualverts,cross
global vertexcounter=0


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

createcrosshair()


camerax#=0
cameray#=5
cameraz#=-10

startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)

gap=1
for x=-20 to 20
	for y=-2 to 0
//	for y=-20 to 20
		for z=-20 to 20
			if y=0 
				addCubeToMesh(x,random(0,2),z,1,1,1,1)
			else
				addCubeToMesh(x,y,z,1,1,1,1)
			endif
		next
	next
next

obj=CreateObjectFromMeshWithUVTexturing(meshid,1,LoadImage("\media\texture.png"))


do
	SetSpritePosition(cross,screenwidth/2,screenheight/2)
	
	getworldcoords()
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop

function createcrosshair()

hitobject=CreateObjectBox(1,1,1)
SetObjectColor(hitobject,255,0,0,255)
	
		swap()
	for x=-3 to 3
		for y=-3 to 3
			c=MakeColor(255,255,255)
			
			if x=-2 or x=2 then c=MakeColor(0,0,0)
			if y=-2 or y=2 then c=MakeColor(0,0,0)
			if x=0 or y=0 then c=MakeColor(255,255,255)
//			if y=-2 or y=2 then c=MakeColor(0,0,0)
			
			
			DrawLine(25+x,0,25+x,50,c,c)
			DrawLine(0,25+y,50,25+y,c,c)
		next
	next
	render()
	cross=CreateSprite(GetImage(0,0,50,50))
	SetRawMouseVisible(0)

endfunction


function getworldcoords()
	
	// get the position of the pointer (mouse)
        pointer_x = screenwidth/2
        pointer_y = screenheight/2

        // get the x, y and z unit vectors based on the pointer position
        unit_x# = Get3DVectorXFromScreen(pointer_x,pointer_y)
        unit_y# = Get3DVectorYFromScreen(pointer_x,pointer_y)
        unit_z# = Get3DVectorZFromScreen(pointer_x,pointer_y)

		
        // calculate the start of the ray cast, which is the unit vector + the camera position
        start_x# = unit_x#
        start_y# = unit_y# + cameray#
        start_z# = unit_z# + cameraz#

        // calculate the end of the vector, which is the unit vector multiplied by the length of the ray cast and then add the camera position to it
        end_x# = 800*unit_x#
        end_y# = 800*unit_y# + cameray#
        end_z# = 800*unit_z# + cameraz#

        // if the mouse in one the ground then position the sphere on the mouse
        if ObjectRayCast(1,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#) <> 0
			print("hit")
            SetObjectPosition(hitobject,GetObjectRayCastX(0),GetObjectRayCastY(0),GetObjectRayCastZ(0))
			SetObjectVisible(hitobject,1)
			print("X - " + str(floor(getobjectx(hitobject))))
			print("Y - " + str(floor(getobjecty(hitobject))))
			print("Z - " + str(floor(getobjectz(hitobject))))
		else
			SetObjectVisible(hitobject,0)
			
        endif

	
endfunction

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)

	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
		
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)

		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)

	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)


	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
	SetObjectColor(1,255,255,255,10)
endfunction 1

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes,chunk, hitobject
global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz, actualverts,cross
global vertexcounter=0

global hitobjectx,hitobjecty,hitobjectz

// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh

createcrosshair()


camerax#=0
cameray#=5
cameraz#=-10

startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)

gap=1
for x=-20 to 20
	for y=-2 to 0
//	for y=-20 to 20
		for z=-20 to 20
			if y=0 
				addCubeToMesh(x,random(0,2),z,1,1,1,1)
			else
				addCubeToMesh(x,y,z,1,1,1,1)
			endif
		next
	next
next

obj=CreateObjectFromMeshWithUVTexturing(meshid,1,LoadImage("\media\texture.png"))


do
	SetSpritePosition(cross,screenwidth/2,screenheight/2)
	
	checkkeypresses()
	getworldcoords()
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop

function checkkeypresses()
	
	if GetRawKeyState(37) then dec camerax#,.005
	if GetRawKeyState(38) then inc cameraz#,.005
	if GetRawKeyState(39) then inc camerax#,.005
	if GetRawKeyState(40) then dec cameraz#,.005
	
	if GetRawMouseLeftPressed()
// add a cube at the hitobject location Y + 1
		addCubeToMesh(hitobjectx,hitobjecty+1,hitobjectz,1,1,1,1)
		DeleteObject(obj)
		obj=CreateObjectFromMeshWithUVTexturing(meshid,1,LoadImage("\media\texture.png"))
		
	endif
	
endfunction


function createcrosshair()

hitobject=CreateObjectBox(.1,.1,.1)
SetObjectColor(hitobject,255,0,0,255)
	
		swap()
	for x=-3 to 3
		for y=-3 to 3
			c=MakeColor(255,255,255)
			
			if x=-2 or x=2 then c=MakeColor(0,0,0)
			if y=-2 or y=2 then c=MakeColor(0,0,0)
			if x=0 or y=0 then c=MakeColor(255,255,255)
//			if y=-2 or y=2 then c=MakeColor(0,0,0)
			
			
			DrawLine(25+x,0,25+x,50,c,c)
			DrawLine(0,25+y,50,25+y,c,c)
		next
	next
	render()
	cross=CreateSprite(GetImage(0,0,50,50))
	SetRawMouseVisible(0)

endfunction


function getworldcoords()
	
	// get the position of the pointer (mouse)
        pointer_x = screenwidth/2
        pointer_y = screenheight/2

        // get the x, y and z unit vectors based on the pointer position
        unit_x# = Get3DVectorXFromScreen(pointer_x,pointer_y)
        unit_y# = Get3DVectorYFromScreen(pointer_x,pointer_y)
        unit_z# = Get3DVectorZFromScreen(pointer_x,pointer_y)

		
        // calculate the start of the ray cast, which is the unit vector + the camera position
        start_x# = unit_x#
        start_y# = unit_y# + cameray#
        start_z# = unit_z# + cameraz#

        // calculate the end of the vector, which is the unit vector multiplied by the length of the ray cast and then add the camera position to it
        end_x# = 800*unit_x#
        end_y# = 800*unit_y# + cameray#
        end_z# = 800*unit_z# + cameraz#

        // if the mouse in one the ground then position the sphere on the mouse
        if ObjectRayCast(1,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#) <> 0
			print("hit")
            SetObjectPosition(hitobject,GetObjectRayCastX(0),GetObjectRayCastY(0),GetObjectRayCastZ(0))
			SetObjectVisible(hitobject,1)
			hitobjectx = (floor(getobjectx(hitobject)))
			hitobjecty = (floor(getobjecty(hitobject)))
			hitobjectz = (floor(getobjectz(hitobject)))
				
			print("X - " + str(floor(getobjectx(hitobject))))
			print("Y - " + str(floor(getobjecty(hitobject))))
			print("Z - " + str(floor(getobjectz(hitobject))))
		else
			SetObjectVisible(hitobject,0)
			
        endif

	
endfunction

function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	SetCameraPosition(1,camerax#,cameray#,cameraz#)
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)

	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
		
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)

		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)

	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)


	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
	SetObjectColor(1,255,255,255,10)
endfunction 1

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant size=32  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#,cube,collisioncoordx,collisioncoordz,collisioncoordy
global numofchunks, numofcubes,chunk
global img,camerax#,cameray#,cameraz#,centrespr, minx,miny,minz,maxx,maxy,maxz, actualverts
global vertexcounter=0


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


// create player collisions units all way raround the player
for a=6 to 12
	CreateObjectBox(a,.1,.1,.1)
	SetObjectVisible(a,0)
next




startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)

for x=-20 to 20
	for y=0 to 1
		for z=-20 to 20
			if y=1
				if random(0,100)>70 then addCubeToMesh(x,random(y,y+1),z,1,1,1,1)
			else
				addCubeToMesh(x,y,z,1,1,1,1)
			endif	
		next
	next
next



obj=CreateObjectFromMeshWithUVTexturing(meshid,1,LoadImage("\media\texture.png"))

camerax#=0
cameray#=5
cameraz#=-10
speed#=.01


SetCameraRange(1,.01,1000)
do
	
	        // get player input
		if checkCollisionv2(obj,6,11)<>1 and GetRawKeyState(37) then dec camerax#,speed#


		if checkCollisionv2(obj,6,12)<>1 and GetRawKeyState(39) then inc camerax#,speed#

		if checkCollisionv2(obj,6,10)<>1 and GetRawKeyState(40) then dec cameraz#,speed#


		if checkCollisionv2(obj,6,9)<>1 and GetRawKeyState(38) then inc cameraz#,speed#
		


//		if checkCollisionv2(obj,6,7)<>1 and GetRawKeyState(83) then dec cameray#,speed#


		if checkCollisionv2(obj,6,8)<>1 and GetRawKeyState(87) 
			inc cameray#,speed#
			jumping=1
		endif

// check if hits the ground by checking the collisioner underneath camera
		if jumping=0 and checkCollisionv2(obj,6,7)<>1
			 dec cameray#,speed#
		else
			jumping=0
		endif

		SetCameraPosition(1,camerax#,cameray#,cameraz#)
		
		//collision object centre 
		SetObjectPosition(6,camerax#,cameray#,cameraz#)
		//collision object bottom
		SetObjectPosition(7,camerax#,cameray#-.5,cameraz#)
		//collision object above
		SetObjectPosition(8,camerax#,cameray#+.5,cameraz#)
		//collision object front
		SetObjectPosition(9,camerax#,cameray#,cameraz#+.5)
		//collision object behin
		SetObjectPosition(10,camerax#,cameray#,cameraz#-.5)
		//collision object left
		SetObjectPosition(11,camerax#-.5,cameray#,cameraz#)
		//collision object right
		SetObjectPosition(12,camerax#+.5,cameray#,cameraz#)
		
	
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop


function movecamera()
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)

	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
		
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)

		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)

	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)


	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
   
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	DeleteObject(1)

    CreateObjectFromMeshMemblock(1,chunkmesh)
    SetObjectImage(1,texture,0)
	SetObjectColor(1,255,255,255,10)
endfunction 1

function checkCollisionv2(objwith,objID as integer,objID2 as integer)
	start_x#=getobjectx(objID)
	start_y#=getobjecty(objID)
	start_z#=getobjectz(objID)

	end_x#=getobjectx(objID2)
	end_y#=getobjecty(objID2)
	end_z#=getobjectz(objID2)


// determine which object has been hit
	object_Hit = ObjectRayCast(objwith,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)

endfunction object_Hit

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable

// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#
global camerax#,cameray#,cameraz#
global size=7  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
global level as integer[20]
global vortexcollisioner as integer[20]


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


// create player collisions units all way raround the player
for a=6 to 12
	CreateObjectBox(a,10,10,10)
	SetObjectVisible(a,0)
next


img = createtexturesnowy()
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


img2 = createtexturegreeny()
SetImageMagFilter(img2,0)
SetImageMinFilter(img2,0)


startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)




tree=0
createtreestructure()

tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
SetObjectPosition(tree,-5,0,0)
		emptymesh()

createtreestructure()

tree2 = CreateObjectFromMeshWithUVTexturing(meshid,1,img2)
SetObjectPosition(tree2,5,0,0)

		emptymesh()







camerax#=0
cameray#=15
cameraz#=-15
speed#=.01


SetCameraRange(1,.01,1000)

do
		RotateObjectLocalY(tree,.1)
		RotateObjectLocalY(tree2,-.1)
	
	    if ( GetPointerPressed() )
        startx# = GetPointerX()
        starty# = GetPointerY()
        angx# = GetCameraAngleX(1)
        angy# = GetCameraAngleY(1)
        pressed = 1
     endif
	
	        // get player input
	//if ( checkCollisionv2(obj,6,9)<>1 and GetRawKeyState( 38 ) ) then MoveCameraLocalZ( 1, speed# )  // cursor up
     //if ( checkCollisionv2(obj,6,10)<>1 and GetRawKeyState( 40 ) ) then MoveCameraLocalZ( 1, -speed# ) // cursor down
     //if ( checkCollisionv2(obj,6,11)<>1 and GetRawKeyState( 37 ) ) then MoveCameraLocalX( 1, -speed# ) // cursor iz
     //if ( checkCollisionv2(obj,6,12)<>1 and GetRawKeyState( 39 ) ) then MoveCameraLocalX( 1, speed# )  // cursor derecha 
/*  		if checkCollisionv2(obj,6,11)<>1 and GetRawKeyState(37) then dec camerax#,speed#
		if checkCollisionv2(obj,6,12)<>1 and GetRawKeyState(39) then inc camerax#,speed#
		if checkCollisionv2(obj,6,10)<>1 and GetRawKeyState(40) then dec cameraz#,speed#
		if checkCollisionv2(obj,6,9)<>1 and GetRawKeyState(38) then inc cameraz#,speed#
		if checkCollisionv2(obj,6,8)<>1 and GetRawKeyState(87) 
			MoveCameraLocalY(1,speed#)
			inc cameray#,speed#
			jumping=1
		endif
		
// check if hits the ground by checking the collisioner underneath camera
		if jumping=0 and checkCollisionv2(obj,6,7)<>1
			 MoveCameraLocalY(1,-speed#)
	//		 dec cameray#,speed#
		else
			jumping=0
		endif

		setcameradata()
	*/
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop

function setcameradata()
		SetCameraPosition(1,camerax#,cameray#,cameraz#)
		camerax#=getcamerax(1)
		cameray#=getcameray(1)
		cameraz#=getcameraz(1)
		
		//collision object centre 
		SetObjectPosition(6,camerax#,cameray#,cameraz#)
		//collision object bottom
		SetObjectPosition(7,camerax#,cameray#-.5,cameraz#)
		//collision object above
		SetObjectPosition(8,camerax#,cameray#+.5,cameraz#)
		//collision object front
		SetObjectPosition(9,camerax#,cameray#,cameraz#+.5)
		//collision object behin
		SetObjectPosition(10,camerax#,cameray#,cameraz#-.5)
		//collision object left
		SetObjectPosition(11,camerax#-.5,cameray#,cameraz#)
		//collision object right
		SetObjectPosition(12,camerax#+.5,cameray#,cameraz#)
endfunction

function movecamera()
	if GetPointerState()=1
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	endif
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)

	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)


	// Left Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
		
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)

		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)

	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)


	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
	objID=1
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	objID = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(objID,texture,0)
	SetObjectColor(objID,255,255,255,10)
endfunction objID 

function checkCollisionv2(objwith,objID as integer,objID2 as integer)
	start_x#=getobjectx(objID)
	start_y#=getobjecty(objID)
	start_z#=getobjectz(objID)

	end_x#=getobjectx(objID2)
	end_y#=getobjecty(objID2)
	end_z#=getobjectz(objID2)


// determine which object has been hit
	object_Hit = ObjectRayCast(objwith,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)

endfunction object_Hit

function createtexturesnowy()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
		//	if random(1,0)=1
				c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
			//else
			//	c=MakeColor(random(200,255),random(200,255),random(200,255)) // white
			//endif	
			
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
			c=MakeColor(random(100,140),random(30,130),0)
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
			if y<20
				if random(0,10)>1
					c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
				else
					c=MakeColor(random(100,140),random(30,130),0)
				endif
						
			else
				c=MakeColor(random(100,140),random(30,130),0)
			endif
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img

function createtexturegreeny()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
				c=MakeColor(0,random(40,155),0) // green
						
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img




function createtreestructure()
	//           111
	//            111
	//          1111111
	//          1 1 111
	//         11111111 
	//          1 1 111
	//          1111111
	//            111
	//           111
	//
	height=8
	
	addCubeToMesh(0,8,0,1,1,1,1)
	
	addCubeToMesh(-1,7,0,1,1,1,1)
	addCubeToMesh(1,7,0,1,1,1,1)
	addCubeToMesh(0,7,-1,1,1,1,1)
	addCubeToMesh(0,7,1,1,1,1,1)

	addCubeToMesh(-1,6,1,1,1,1,1)
	addCubeToMesh(-1,6,0,1,1,1,1)
	addCubeToMesh(-1,6,-1,1,1,1,1)
	addCubeToMesh(0,6,-1,1,1,1,1)
	addCubeToMesh(0,6,0,1,1,1,1)
	addCubeToMesh(0,6,1,1,1,1,1)
	addCubeToMesh(1,6,-1,1,1,1,1)
	addCubeToMesh(1,6,0,1,1,1,1)
	addCubeToMesh(1,6,1,1,1,1,1)


	addCubeToMesh(-1,5,1,1,1,1,1)
	addCubeToMesh(-1,5,0,1,1,1,1)
	addCubeToMesh(-1,5,-1,1,1,1,1)
	addCubeToMesh(0,5,-1,1,1,1,1)
	addCubeToMesh(0,5,0,1,1,1,1)
	addCubeToMesh(0,5,1,1,1,1,1)
	addCubeToMesh(1,5,-1,1,1,1,1)
	addCubeToMesh(1,5,0,1,1,1,1)
	addCubeToMesh(1,5,1,1,1,1,1)
	
	addCubeToMesh(-2,5,0,1,1,1,1)
	addCubeToMesh(2,5,0,1,1,1,1)
	addCubeToMesh(0,5,-2,1,1,1,1)
	addCubeToMesh(0,5,2,1,1,1,1)

	addCubeToMesh(-1,4,1,1,1,1,1)
	addCubeToMesh(-1,4,0,1,1,1,1)
	addCubeToMesh(-1,4,-1,1,1,1,1)
	addCubeToMesh(0,4,-1,1,1,1,1)
	addCubeToMesh(0,4,0,1,1,1,1)
	addCubeToMesh(0,4,1,1,1,1,1)
	addCubeToMesh(1,4,-1,1,1,1,1)
	addCubeToMesh(1,4,0,1,1,1,1)
	addCubeToMesh(1,4,1,1,1,1,1)

	addCubeToMesh(-2,4,0,1,1,1,1)
	addCubeToMesh(2,4,0,1,1,1,1)
	addCubeToMesh(0,4,-2,1,1,1,1)
	addCubeToMesh(0,4,2,1,1,1,1)

	addCubeToMesh(-2,4,-1,1,1,1,1)
	addCubeToMesh(2,4,-1,1,1,1,1)
	addCubeToMesh(-2,4,1,1,1,1,1)
	addCubeToMesh(2,4,1,1,1,1,1)


	addCubeToMesh(-1,4,-2,1,1,1,1)
	addCubeToMesh(1,4,-2,1,1,1,1)
	addCubeToMesh(-1,4,2,1,1,1,1)
	addCubeToMesh(1,4,2,1,1,1,1)


	addCubeToMesh(-1,3,-1,1,1,1,1)
	addCubeToMesh(-1,3,0,1,1,1,1)
	addCubeToMesh(-1,3,1,1,1,1,1)

	addCubeToMesh(1,3,-1,1,1,1,1)
	addCubeToMesh(1,3,0,1,1,1,1)
	addCubeToMesh(1,3,1,1,1,1,1)
	addCubeToMesh(0,3,-1,1,1,1,1)
	addCubeToMesh(0,3,1,1,1,1,1)


	addCubeToMesh(0,2,0,1,1,1,1)
	addCubeToMesh(0,1,0,1,1,1,1)
	addCubeToMesh(0,0,0,1,1,1,1)
endfunction

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable
#constant CHUNK_WIDTH=16
#constant CHUNK_HEIGHT=16


// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#
global camerax#,cameray#,cameraz#
global size=7  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
global level as integer[20]
global vortexcollisioner as integer[20]


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


type _chunkdata
	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	air as integer // 0 - air, 1-block
endtype
global chunkdata as _chunkdata[CHUNK_WIDTH,CHUNK_HEIGHT,CHUNK_WIDTH]




// create player collisions units all way raround the player
for a=6 to 12
	CreateObjectBox(a,10,10,10)
	SetObjectVisible(a,0)
next


img = createtexturesnowy()
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)


// setup chunk - define where blocks are first
for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
		for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
			chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].air=random(0,1)
		next
	next
next

// cull them
cull_chunk_data()

// build the mesh with the Faces data from the cull
for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
		for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
			addCubeToMesh(x,y,z,1,1,1,1  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[0]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[1]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[2]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[3]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[4]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[5])
		next
	next
next


tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
SetObjectPosition(tree,0,0,0)
		emptymesh()









camerax#=0
cameray#=15
cameraz#=-15
speed#=.01


SetCameraRange(1,.01,1000)

do
		RotateObjectLocalY(tree,.1)

	    if ( GetPointerPressed() )
        startx# = GetPointerX()
        starty# = GetPointerY()
        angx# = GetCameraAngleX(1)
        angy# = GetCameraAngleY(1)
        pressed = 1
     endif
	
	        // get player input
	//if ( checkCollisionv2(obj,6,9)<>1 and GetRawKeyState( 38 ) ) then MoveCameraLocalZ( 1, speed# )  // cursor up
     //if ( checkCollisionv2(obj,6,10)<>1 and GetRawKeyState( 40 ) ) then MoveCameraLocalZ( 1, -speed# ) // cursor down
     //if ( checkCollisionv2(obj,6,11)<>1 and GetRawKeyState( 37 ) ) then MoveCameraLocalX( 1, -speed# ) // cursor iz
     //if ( checkCollisionv2(obj,6,12)<>1 and GetRawKeyState( 39 ) ) then MoveCameraLocalX( 1, speed# )  // cursor derecha 
/*  		if checkCollisionv2(obj,6,11)<>1 and GetRawKeyState(37) then dec camerax#,speed#
		if checkCollisionv2(obj,6,12)<>1 and GetRawKeyState(39) then inc camerax#,speed#
		if checkCollisionv2(obj,6,10)<>1 and GetRawKeyState(40) then dec cameraz#,speed#
		if checkCollisionv2(obj,6,9)<>1 and GetRawKeyState(38) then inc cameraz#,speed#
		if checkCollisionv2(obj,6,8)<>1 and GetRawKeyState(87) 
			MoveCameraLocalY(1,speed#)
			inc cameray#,speed#
			jumping=1
		endif
		
// check if hits the ground by checking the collisioner underneath camera
		if jumping=0 and checkCollisionv2(obj,6,7)<>1
			 MoveCameraLocalY(1,-speed#)
	//		 dec cameray#,speed#
		else
			jumping=0
		endif

		setcameradata()
	*/
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop

function cull_chunk_data()
	
//	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	
	for x=0 to CHUNK_WIDTH
		for y=0 to 0
			for z=0 to CHUNK_WIDTH
				
				for f=1 to 5
					chunkdata[x,y,z].faces[f]=1
				next
				
				if x-1>0 // check left and this one right
					if chunkdata[x-1,y,z].air = 1
						chunkdata[x-1,y,z].faces[3]=0	
						chunkdata[x,y,z].faces[2]=0
					 else
						chunkdata[x-1,y,z].faces[3]=1	
						chunkdata[x,y,z].faces[2]=1
						 
					endif
				endif

				if z-1>0 // check front and this ones back
					if chunkdata[x,y,z-1].air = 1
						chunkdata[x,y,z-1].faces[4]=0	
						chunkdata[x,y,z].faces[5]=0
					 else
						chunkdata[x,y,z-1].faces[4]=1	
						chunkdata[x,y,z].faces[5]=1
						 
					endif
				endif


			next
		next
	next

	
	
endfunction

function setcameradata()
		SetCameraPosition(1,camerax#,cameray#,cameraz#)
		camerax#=getcamerax(1)
		cameray#=getcameray(1)
		cameraz#=getcameraz(1)
		
		//collision object centre 
		SetObjectPosition(6,camerax#,cameray#,cameraz#)
		//collision object bottom
		SetObjectPosition(7,camerax#,cameray#-.5,cameraz#)
		//collision object above
		SetObjectPosition(8,camerax#,cameray#+.5,cameraz#)
		//collision object front
		SetObjectPosition(9,camerax#,cameray#,cameraz#+.5)
		//collision object behin
		SetObjectPosition(10,camerax#,cameray#,cameraz#-.5)
		//collision object left
		SetObjectPosition(11,camerax#-.5,cameray#,cameraz#)
		//collision object right
		SetObjectPosition(12,camerax#+.5,cameray#,cameraz#)
endfunction

function movecamera()
	if GetPointerState()=1
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	endif
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c,top,bottom,lft,rght,front,back)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	if top=1
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)
	endif
	
	if bottom=1
	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)
	endif


	if back=1
	// front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	endif
		
		
	if front=1
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)
	endif
	
	
	if lft=1
		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	endif

	if rght=1
	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)
	endif

	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
	objID=1
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	objID = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(objID,texture,0)
	SetObjectColor(objID,255,255,255,10)
endfunction objID 

function checkCollisionv2(objwith,objID as integer,objID2 as integer)
	start_x#=getobjectx(objID)
	start_y#=getobjecty(objID)
	start_z#=getobjectz(objID)

	end_x#=getobjectx(objID2)
	end_y#=getobjecty(objID2)
	end_z#=getobjectz(objID2)


// determine which object has been hit
	object_Hit = ObjectRayCast(objwith,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)

endfunction object_Hit

function createtexturesnowy()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
		//	if random(1,0)=1
				c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
			//else
			//	c=MakeColor(random(200,255),random(200,255),random(200,255)) // white
			//endif	
			
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
			c=MakeColor(random(100,140),random(30,130),0)
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
			if y<20
				if random(0,10)>1
					c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
				else
					c=MakeColor(random(100,140),random(30,130),0)
				endif
						
			else
				c=MakeColor(random(100,140),random(30,130),0)
			endif
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img

function createtexturegreeny()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
				c=MakeColor(0,random(40,155),0) // green
						
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img




function createtreestructure(x#,y#,z#)
	//           111
	//            111
	//          1111111
	//          1 1 111
	//         11111111 
	//          1 1 111
	//          1111111
	//            111
	//           111
	//
	height=8
	
	/*
	addCubeToMesh(x#+0,y#+8,z#,1,1,1,1)
	
	addCubeToMesh(x#-1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#+1,1,1,1,1)

	addCubeToMesh(x#-1,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#+1,1,1,1,1)
	
	addCubeToMesh(x#-2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)

	addCubeToMesh(x#-1,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+1,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+2,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#-2,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#+2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+2,1,1,1,1)


	addCubeToMesh(x#-1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#+1,1,1,1,1)

	addCubeToMesh(x#+1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#+1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#+1,1,1,1,1)


	addCubeToMesh(x#,y#+2,z#,1,1,1,1)
	addCubeToMesh(x#,y#+1,z#,1,1,1,1)
	addCubeToMesh(x#,y#+0,z#,1,1,1,1)
*/











	
	
	
	
endfunction

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable
#constant CHUNK_WIDTH=16
#constant CHUNK_HEIGHT=16


// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#
global camerax#,cameray#,cameraz#
global size=7  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
global level as integer[20]
global vortexcollisioner as integer[20]


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


type _chunkdata
	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	air as integer // 0 - air, 1-block
endtype
global chunkdata as _chunkdata[CHUNK_WIDTH,CHUNK_HEIGHT,CHUNK_WIDTH]




// create player collisions units all way raround the player
for a=6 to 12
	CreateObjectBox(a,10,10,10)
	SetObjectVisible(a,0)
next


img = createtexturesnowy()
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)


// setup chunk - define where blocks are first
for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
//	for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
	y=0
		for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2

			chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air=random(0,5)
//		next
	next
next

// cull them
cull_chunk_data()

// build the mesh with the Faces data from the cull
for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	//for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
		y=0
		for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
			addCubeToMesh(x,y,z,1,1,1,1  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[0]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[1]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[2]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[3]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[4]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[5])
	// draw a smaller cube inside where it should go - thiswill be removed later
			addCubeToMesh(x,y+1,z,.3,.3,.3,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air  ,1,1,1,1,1,1)
		next
//	next
next


tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
SetObjectPosition(tree,0,0,0)
		emptymesh()









camerax#=0
cameray#=15
cameraz#=-15
speed#=.01


SetCameraRange(1,.01,1000)

do
		RotateObjectLocalY(tree,.05)

	    if ( GetPointerPressed() )
        startx# = GetPointerX()
        starty# = GetPointerY()
        angx# = GetCameraAngleX(1)
        angy# = GetCameraAngleY(1)
        pressed = 1
     endif
	
	        // get player input
	//if ( checkCollisionv2(obj,6,9)<>1 and GetRawKeyState( 38 ) ) then MoveCameraLocalZ( 1, speed# )  // cursor up
     //if ( checkCollisionv2(obj,6,10)<>1 and GetRawKeyState( 40 ) ) then MoveCameraLocalZ( 1, -speed# ) // cursor down
     //if ( checkCollisionv2(obj,6,11)<>1 and GetRawKeyState( 37 ) ) then MoveCameraLocalX( 1, -speed# ) // cursor iz
     //if ( checkCollisionv2(obj,6,12)<>1 and GetRawKeyState( 39 ) ) then MoveCameraLocalX( 1, speed# )  // cursor derecha 
/*  		if checkCollisionv2(obj,6,11)<>1 and GetRawKeyState(37) then dec camerax#,speed#
		if checkCollisionv2(obj,6,12)<>1 and GetRawKeyState(39) then inc camerax#,speed#
		if checkCollisionv2(obj,6,10)<>1 and GetRawKeyState(40) then dec cameraz#,speed#
		if checkCollisionv2(obj,6,9)<>1 and GetRawKeyState(38) then inc cameraz#,speed#
		if checkCollisionv2(obj,6,8)<>1 and GetRawKeyState(87) 
			MoveCameraLocalY(1,speed#)
			inc cameray#,speed#
			jumping=1
		endif
		
// check if hits the ground by checking the collisioner underneath camera
		if jumping=0 and checkCollisionv2(obj,6,7)<>1
			 MoveCameraLocalY(1,-speed#)
	//		 dec cameray#,speed#
		else
			jumping=0
		endif

		setcameradata()
	*/
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop

function cull_chunk_data()
	
//	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	
	for x=-0 to CHUNK_WIDTH
		for y=0 to 0
			for z=0 to CHUNK_WIDTH
				
				
					
					
				if x-1>0 // check left and this one right
					if chunkdata[x-1,y,z].air = 1
						chunkdata[x-1,y,z].faces[2]=0
						chunkdata[x,y,z].faces[3]=0
						//chunkdata[x,y,z].faces[0]=0	
					 else
						chunkdata[x-1,y,z].faces[2]=1	
						
						chunkdata[x,y,z].faces[3]=1
						//chunkdata[x,y,z].faces[0]=0	
						 
					endif
				endif

				if x+1<=CHUNK_WIDTH // check left and this one right
					if chunkdata[x+1,y,z].air = 1
						chunkdata[x+1,y,z].faces[2]=0
						chunkdata[x,y,z].faces[3]=0
						//chunkdata[x,y,z].faces[0]=0	
					 else
						chunkdata[x+1,y,z].faces[2]=1	
						
						chunkdata[x,y,z].faces[3]=1
						//chunkdata[x,y,z].faces[0]=0	
						 
					endif
				endif


				if z-1>0 // check front and this ones back
					if chunkdata[x,y,z-1].air = 1
						chunkdata[x,y,z-1].faces[4]=0	
						chunkdata[x,y,z].faces[5]=0
						chunkdata[x,y,z].faces[0]=0	
					 else
						chunkdata[x,y,z-1].faces[4]=1
							
						chunkdata[x,y,z].faces[5]=1
//						chunkdata[x,y,z].faces[0]=1	
						 
					endif
				endif


			next
		next
	next

	
	
endfunction

function setcameradata()
		SetCameraPosition(1,camerax#,cameray#,cameraz#)
		camerax#=getcamerax(1)
		cameray#=getcameray(1)
		cameraz#=getcameraz(1)
		
		//collision object centre 
		SetObjectPosition(6,camerax#,cameray#,cameraz#)
		//collision object bottom
		SetObjectPosition(7,camerax#,cameray#-.5,cameraz#)
		//collision object above
		SetObjectPosition(8,camerax#,cameray#+.5,cameraz#)
		//collision object front
		SetObjectPosition(9,camerax#,cameray#,cameraz#+.5)
		//collision object behin
		SetObjectPosition(10,camerax#,cameray#,cameraz#-.5)
		//collision object left
		SetObjectPosition(11,camerax#-.5,cameray#,cameraz#)
		//collision object right
		SetObjectPosition(12,camerax#+.5,cameray#,cameraz#)
endfunction

function movecamera()
	if GetPointerState()=1
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	endif
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c,top,bottom,lft,rght,front,back)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	if top=1
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)
	endif
	
	if bottom=1
	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)
	endif


	if back=1
	// front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	endif
		
		
	if front=1
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)
	endif
	
	
	if lft=1
		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	endif

	if rght=1
	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)
	endif

	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
	objID=1
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	objID = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(objID,texture,0)
	SetObjectColor(objID,255,255,255,10)
endfunction objID 

function checkCollisionv2(objwith,objID as integer,objID2 as integer)
	start_x#=getobjectx(objID)
	start_y#=getobjecty(objID)
	start_z#=getobjectz(objID)

	end_x#=getobjectx(objID2)
	end_y#=getobjecty(objID2)
	end_z#=getobjectz(objID2)


// determine which object has been hit
	object_Hit = ObjectRayCast(objwith,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)

endfunction object_Hit

function createtexturesnowy()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
		//	if random(1,0)=1
				c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
			//else
			//	c=MakeColor(random(200,255),random(200,255),random(200,255)) // white
			//endif	
			
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
			c=MakeColor(random(100,140),random(30,130),0)
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
			if y<20
				if random(0,10)>1
					c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
				else
					c=MakeColor(random(100,140),random(30,130),0)
				endif
						
			else
				c=MakeColor(random(100,140),random(30,130),0)
			endif
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img

function createtexturegreeny()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
				c=MakeColor(0,random(40,155),0) // green
						
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img




function createtreestructure(x#,y#,z#)
	//           111
	//            111
	//          1111111
	//          1 1 111
	//         11111111 
	//          1 1 111
	//          1111111
	//            111
	//           111
	//
	height=8
	
	/*
	addCubeToMesh(x#+0,y#+8,z#,1,1,1,1)
	
	addCubeToMesh(x#-1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#+1,1,1,1,1)

	addCubeToMesh(x#-1,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#+1,1,1,1,1)
	
	addCubeToMesh(x#-2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)

	addCubeToMesh(x#-1,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+1,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+2,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#-2,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#+2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+2,1,1,1,1)


	addCubeToMesh(x#-1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#+1,1,1,1,1)

	addCubeToMesh(x#+1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#+1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#+1,1,1,1,1)


	addCubeToMesh(x#,y#+2,z#,1,1,1,1)
	addCubeToMesh(x#,y#+1,z#,1,1,1,1)
	addCubeToMesh(x#,y#+0,z#,1,1,1,1)
*/











	
	
	
	
endfunction

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable
#constant CHUNK_WIDTH=16
#constant CHUNK_HEIGHT=16


// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#
global camerax#,cameray#,cameraz#
global size=7  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
global level as integer[20]
global vortexcollisioner as integer[20]


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


type _chunkdata
	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	air as integer // 0 - air, 1-block
endtype
global chunkdata as _chunkdata[CHUNK_WIDTH,CHUNK_HEIGHT,CHUNK_WIDTH]




// create player collisions units all way raround the player
for a=6 to 12
	CreateObjectBox(a,10,10,10)
	SetObjectVisible(a,0)
next


img = createtexturesnowy()
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)


// setup chunk - define where blocks are first
for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
//	for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
	y=0
		for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2

			chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air=random(0,5)
//		next
	next
next

// cull them
cull_chunk_data()

// build the mesh with the Faces data from the cull
for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	//for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
		y=0
		for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
			addCubeToMesh(x,y,z,1,1,1,1  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[0]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[1]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[2]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[3]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[4]  ,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].faces[5])
	// draw a smaller cube inside where it should go - thiswill be removed later
			addCubeToMesh(x,y+1,z,.3,.3,.3,chunkdata[x+CHUNK_WIDTH/2,y,z+CHUNK_WIDTH/2].air  ,1,1,1,1,1,1)
		next
//	next
next


tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
SetObjectPosition(tree,0,0,0)
		emptymesh()









camerax#=0
cameray#=15
cameraz#=-15
speed#=.01


SetCameraRange(1,.01,1000)

do
		RotateObjectLocalY(tree,.05)

	    if ( GetPointerPressed() )
        startx# = GetPointerX()
        starty# = GetPointerY()
        angx# = GetCameraAngleX(1)
        angy# = GetCameraAngleY(1)
        pressed = 1
     endif
	
	        // get player input
	//if ( checkCollisionv2(obj,6,9)<>1 and GetRawKeyState( 38 ) ) then MoveCameraLocalZ( 1, speed# )  // cursor up
     //if ( checkCollisionv2(obj,6,10)<>1 and GetRawKeyState( 40 ) ) then MoveCameraLocalZ( 1, -speed# ) // cursor down
     //if ( checkCollisionv2(obj,6,11)<>1 and GetRawKeyState( 37 ) ) then MoveCameraLocalX( 1, -speed# ) // cursor iz
     //if ( checkCollisionv2(obj,6,12)<>1 and GetRawKeyState( 39 ) ) then MoveCameraLocalX( 1, speed# )  // cursor derecha 
/*  		if checkCollisionv2(obj,6,11)<>1 and GetRawKeyState(37) then dec camerax#,speed#
		if checkCollisionv2(obj,6,12)<>1 and GetRawKeyState(39) then inc camerax#,speed#
		if checkCollisionv2(obj,6,10)<>1 and GetRawKeyState(40) then dec cameraz#,speed#
		if checkCollisionv2(obj,6,9)<>1 and GetRawKeyState(38) then inc cameraz#,speed#
		if checkCollisionv2(obj,6,8)<>1 and GetRawKeyState(87) 
			MoveCameraLocalY(1,speed#)
			inc cameray#,speed#
			jumping=1
		endif
		
// check if hits the ground by checking the collisioner underneath camera
		if jumping=0 and checkCollisionv2(obj,6,7)<>1
			 MoveCameraLocalY(1,-speed#)
	//		 dec cameray#,speed#
		else
			jumping=0
		endif

		setcameradata()
	*/
	movecamera()
    Print( ScreenFPS() )
    Sync()
loop

function cull_chunk_data()
	
//	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	
	for x=-0 to CHUNK_WIDTH
		for y=0 to 0
			for z=0 to CHUNK_WIDTH
//turn off all the faces
				for f=1 to 5
					chunkdata[x,y,z].faces[f]=0
				next
				
					
// turn oo the faces we need
				if x-1>0 // check left and this one right
					if chunkdata[x-1,y,z].air = 1
						chunkdata[x-1,y,z].faces[3]=1
						chunkdata[x,y,z].faces[2]=1
					endif
				endif

				if z-1>0 // check front and this ones back
					if chunkdata[x,y,z-1].air = 1
						chunkdata[x,y,z-1].faces[5]=1
						chunkdata[x,y,z].faces[4]=1
					endif
				endif



			next
		next
	next

	
	
endfunction

function setcameradata()
		SetCameraPosition(1,camerax#,cameray#,cameraz#)
		camerax#=getcamerax(1)
		cameray#=getcameray(1)
		cameraz#=getcameraz(1)
		
		//collision object centre 
		SetObjectPosition(6,camerax#,cameray#,cameraz#)
		//collision object bottom
		SetObjectPosition(7,camerax#,cameray#-.5,cameraz#)
		//collision object above
		SetObjectPosition(8,camerax#,cameray#+.5,cameraz#)
		//collision object front
		SetObjectPosition(9,camerax#,cameray#,cameraz#+.5)
		//collision object behin
		SetObjectPosition(10,camerax#,cameray#,cameraz#-.5)
		//collision object left
		SetObjectPosition(11,camerax#-.5,cameray#,cameraz#)
		//collision object right
		SetObjectPosition(12,camerax#+.5,cameray#,cameraz#)
endfunction

function movecamera()
	if GetPointerState()=1
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	endif
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c,top,bottom,lft,rght,front,back)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	if top=1
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)
	endif
	
	if bottom=1
	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)
	endif


	if back=1
	// front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	endif
		
		
	if front=1
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)
	endif
	
	
	if lft=1
		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	endif

	if rght=1
	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)
	endif

	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
	objID=1
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	objID = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(objID,texture,0)
	SetObjectColor(objID,255,255,255,10)
endfunction objID 

function checkCollisionv2(objwith,objID as integer,objID2 as integer)
	start_x#=getobjectx(objID)
	start_y#=getobjecty(objID)
	start_z#=getobjectz(objID)

	end_x#=getobjectx(objID2)
	end_y#=getobjecty(objID2)
	end_z#=getobjectz(objID2)


// determine which object has been hit
	object_Hit = ObjectRayCast(objwith,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)

endfunction object_Hit

function createtexturesnowy()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
		//	if random(1,0)=1
				c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
			//else
			//	c=MakeColor(random(200,255),random(200,255),random(200,255)) // white
			//endif	
			
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
			c=MakeColor(random(100,140),random(30,130),0)
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
			if y<20
				if random(0,10)>1
					c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
				else
					c=MakeColor(random(100,140),random(30,130),0)
				endif
						
			else
				c=MakeColor(random(100,140),random(30,130),0)
			endif
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img

function createtexturegreeny()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
				c=MakeColor(0,random(40,155),0) // green
						
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img




function createtreestructure(x#,y#,z#)
	//           111
	//            111
	//          1111111
	//          1 1 111
	//         11111111 
	//          1 1 111
	//          1111111
	//            111
	//           111
	//
	height=8
	
	/*
	addCubeToMesh(x#+0,y#+8,z#,1,1,1,1)
	
	addCubeToMesh(x#-1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#+1,1,1,1,1)

	addCubeToMesh(x#-1,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#+1,1,1,1,1)
	
	addCubeToMesh(x#-2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)

	addCubeToMesh(x#-1,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+1,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+2,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#-2,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#+2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+2,1,1,1,1)


	addCubeToMesh(x#-1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#+1,1,1,1,1)

	addCubeToMesh(x#+1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#+1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#+1,1,1,1,1)


	addCubeToMesh(x#,y#+2,z#,1,1,1,1)
	addCubeToMesh(x#,y#+1,z#,1,1,1,1)
	addCubeToMesh(x#,y#+0,z#,1,1,1,1)
*/











	
	
	
	
endfunction

            for (y = 0; y < 7; y++ )
                for (z = 0; z < 7; z++ )
                    for (x = 0; x < 7; x++)

                    
                        if (x = block) // block at this current position

                            if (y - 1 == air ) // is there a NO block at the previous Y positin
                                y - 1 topface = 0 
                                y     bottomface = 1 // change this to have a bottom face
                            endif
                            if (y - 1 == block ) // there is a block at the previous but also at this location, so
                                y - 1 topface = 0 (otherwise will have visible faces inside two connected cubes
                                y     bottom  = 0 (otherwise will have visible faces inside two connected cubes
                            endif


                            endif
                            if (z - 1 == air) // is the NO block on the previous Z 
                                z - 1 frontface = 0 then change that blocks front face to invisible
                                z     backface  = 1 change this blocks backface to visible
                            endif
                            if (z - 1 = block)  // if there is a block at previous Z 
                                z - 1 frontface = 0 // change that blocks front face to also invisible  (otherwise will have visible faces inside two connected cubes
                                z     backface = 0 // change this block back face to also invisible  (otherwise will have visible faces inside two connected cubes
                            endif
                        
                            if (x - 1 == air)  // there is NO block at the previous X position
                                x - 1 rightface = 0 // remove the right face of the previous block
                                x     leftface  = 1 // add a left face to the current position cube
                            endif
                        
                            if ( x - 1 == block ) // is there a block there - if so then remove the inner faces
                                x - 1 rightface = 0 (otherwise will have visible faces inside two connected cubes
                                x leftface = 0 (otherwise will have visible faces inside two connected cubes
                            endif

                        endif

                        if (x == air) // empty space at this current position

                            if (y - 1 == air ) // is there a NO block at the previous Y positin
                                y - 1 topface = 0 (otherwise will have visible faces outside two connected cubes
                                y     bottomface = 0 (otherwise will have visible faces outside two connected cubes
                            endif
                            if (y - 1 == block ) // there is a block at the previous but also at this location, so
                                y - 1 topface = 1 
                                y     bottom  = 0 
                            endif


                            if (z - 1) == air // is there no block previus Z
                                z - 1 frontface = 0 // change its front to no face  (otherwise will have visible faces outside two connected cubes
                                z     backface = 0  // change current backface to no face.(otherwise will have visible faces outside two connected cubes
                            endif

                            if (z - 1) == block  // is there a block prebious Z
                                z - 1 frontface 1 // change its front have have a face
                                z         backface 0  // change this block backface to not have a face
                            endif

                            if ( x - 1  == air ) // there is no block at the previous X positin either
                                x - 1 rightface = 0;(otherwise will have visible faces outside two connected cubes
                                x leftface = 0;(otherwise will have visible faces outside two connected cubes
                            endif
                        
                            if (x - 1 == block ) // there is a block at the previous position, so enable its rightface
                                x - 1 rightface = 1;
                                x leftface = 0;
                            endif
    
                        endif
                  next
               next
            next

/// Project: Mesh Template
// Created: 2019-01-12

// show all errors
SetErrorMode(2)

#constant screenwidth=1024
#constant screenheight=768
#constant fullscreen=0
#constant screenrate=0
#constant renderdistance=0 // how many chunks surrounding each other - call it render distance variable
#constant CHUNK_WIDTH=16
#constant CHUNK_HEIGHT=16


// set window properties
SetWindowTitle( "Mesh Template" )
SetWindowSize( screenwidth, screenheight, fullscreen )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( screenwidth, screenheight ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( screenrate, 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 angx#,angy#,startx#,starty#
global camerax#,cameray#,cameraz#
global size=7  // Size of the chunk in X and Z direction - make this small so the chunk can be quickly rebuilt in processing
global level as integer[20]
global vortexcollisioner as integer[20]


// meshmemblock types
Type Vertex
    air as integer  
    x as float
    y as float
    z as float
    nx as float
    ny as float
    nz as float
    u as float
    v as float
endtype
  
Type Triangle
    v1 as integer
    v2 as integer
    v3 as integer
endtype
  
Type Mesh
    VertexList as Vertex[]
endtype
  
global MeshID as Mesh


type _chunkdata
	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	air as integer // 0 - air, 1-block
endtype
global chunkdata as _chunkdata[CHUNK_WIDTH,CHUNK_HEIGHT,CHUNK_WIDTH]




// create player collisions units all way raround the player
for a=6 to 12
	CreateObjectBox(a,10,10,10)
	SetObjectVisible(a,0)
next


img = createtexturesnowy()
SetImageMagFilter(img,0)
SetImageMinFilter(img,0)


startx#=screenwidth/2
starty#=screenheight/2
SetRawMousePosition(startx#,starty#)


setupchunk()


// cull them
cull_chunk_data()

buildchunk()

tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
SetObjectPosition(tree,0,0,0)
		emptymesh()









camerax#=0
cameray#=20
cameraz#=-30
speed#=.01


SetCameraRange(1,.01,1000)

global cull=1
global tops=1
global minis=1

do
	
	if GetRawKeyState(37) then dec camerax#,.01
	if GetRawKeyState(39) then inc camerax#,.01
	if GetRawKeyState(38) then dec cameraz#,.01
	if GetRawKeyState(40) then inc cameraz#,.01
	
	
	if GetRawKeyState(32)
		RotateObjectLocalY(tree,.05)
	endif
	
	 if ( GetPointerPressed() )
        startx# = GetPointerX()
        starty# = GetPointerY()
        angx# = GetCameraAngleX(1)
        angy# = GetCameraAngleY(1)
        pressed = 1
     endif

	
	if GetRawKeyPressed(84)
		tops=-tops
// resetup the chunk with the cull setting
		DeleteObject(tree)
		emptychunk() // clears the chunkdata
		setupchunk()
		if cull=1 then cull_chunk_data()
		buildchunk()

		tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		SetObjectPosition(tree,0,0,0)
		emptymesh()
		

	endif
	
	if GetRawKeyPressed(82)
		minis=-minis
// resetup the chunk with the cull setting
		DeleteObject(tree)
		emptychunk() // clears the chunkdata
		setupchunk() 
		if cull=1 then cull_chunk_data()
		buildchunk()

		tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		SetObjectPosition(tree,0,0,0)
		emptymesh()
		

	endif
		
	if GetRawKeyPressed(67) 
		cull=-cull
// resetup the chunk with the cull setting
		DeleteObject(tree)
		emptychunk() // clears the chunkdata
		setupchunk()
		if cull=1 
			cull_chunk_data()
		else
			standardise_chunk_data()
		endif	
		buildchunk()

		tree = CreateObjectFromMeshWithUVTexturing(meshid,1,img)
		SetObjectPosition(tree,0,0,0)
		emptymesh()
		

	endif

	if (minis=1)
		print("Mini Cubes : On")
	else
		print("Mini Cubes : Off")
	endif
	
    if (cull=1)
		print("Cube Culling : On")
	else 
		print("Cube Culling : Off")
	endif

    if (tops=1)
		print("Top and outside Faces : On")
	else 
		print("Top and outside Faces : Off")
	endif
	print ("Press Space to spin")
	print ("Press C to cull on or off")
	print ("Press R to minis on or off")
	print ("Press T to make TOP and outside faces on or off - so can see results better")
	print(GetRawLastKey())
	        // get player input
	//if ( checkCollisionv2(obj,6,9)<>1 and GetRawKeyState( 38 ) ) then MoveCameraLocalZ( 1, speed# )  // cursor up
     //if ( checkCollisionv2(obj,6,10)<>1 and GetRawKeyState( 40 ) ) then MoveCameraLocalZ( 1, -speed# ) // cursor down
     //if ( checkCollisionv2(obj,6,11)<>1 and GetRawKeyState( 37 ) ) then MoveCameraLocalX( 1, -speed# ) // cursor iz
     //if ( checkCollisionv2(obj,6,12)<>1 and GetRawKeyState( 39 ) ) then MoveCameraLocalX( 1, speed# )  // cursor derecha 
/*  		if checkCollisionv2(obj,6,11)<>1 and GetRawKeyState(37) then dec camerax#,speed#
		if checkCollisionv2(obj,6,12)<>1 and GetRawKeyState(39) then inc camerax#,speed#
		if checkCollisionv2(obj,6,10)<>1 and GetRawKeyState(40) then dec cameraz#,speed#
		if checkCollisionv2(obj,6,9)<>1 and GetRawKeyState(38) then inc cameraz#,speed#
		if checkCollisionv2(obj,6,8)<>1 and GetRawKeyState(87) 
			MoveCameraLocalY(1,speed#)
			inc cameray#,speed#
			jumping=1
		endif
		
// check if hits the ground by checking the collisioner underneath camera
		if jumping=0 and checkCollisionv2(obj,6,7)<>1
			 MoveCameraLocalY(1,-speed#)
	//		 dec cameray#,speed#
		else
			jumping=0
		endif

		setcameradata()
	*/
	movecamera()
	setcameradata()
    Print( ScreenFPS() )
    Sync()
loop

function emptychunk()
	
	for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
		for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
			for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	
				chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].air=0
				for f=0 to 5
					chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[f] = 0	
				next
			next
		next
	next
endfunction
function buildchunk()
	// build the mesh with the Faces data from the cull
for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
		for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
			addCubeToMesh(x,y,z,1,1,1,1  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[0]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[1]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[2]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[3]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[4]  ,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].faces[5])
	// draw a smaller cube inside where it should go - thiswill be removed later
			if minis = 1 then addCubeToMesh(x,y+1,z,.3,.3,.3,chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].air  ,1,1,1,1,1,1)
		next
	next
next


endfunction
function setupchunk()
	// setup chunk - define where blocks are first
	for x=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
		for y=-CHUNK_HEIGHT/2 to CHUNK_HEIGHT/2
			for z=-CHUNK_WIDTH/2 to CHUNK_WIDTH/2
	
				chunkdata[x+CHUNK_WIDTH/2,y+CHUNK_HEIGHT/2,z+CHUNK_WIDTH/2].air=random(0,1)
			next
		next
	next
endfunction

function standardise_chunk_data()
	
//	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	
 for y=0 to CHUNK_HEIGHT
	for z=0 to CHUNK_WIDTH
		for x=0 to CHUNK_WIDTH
			for f=0 to 5
				chunkdata[x,y,z].faces[f]=1
			next
		
		next
	next
next

endfunction


function cull_chunk_data()
	
//	faces as integer[5] // 0 -top, 1-bottom, 2-left, 3-right, 4 front, 5 back
	
 for y=0 to CHUNK_HEIGHT
	for z=0 to CHUNK_WIDTH
		for x=0 to CHUNK_WIDTH
 
         
            if (chunkdata[x,y,z].air = 1) // block at this current position
				
				if tops=1 
					if y=CHUNK_HEIGHT then chunkdata[x,y,z].faces[0] = 1 // put a final top on the Y edge to catch the last block
				endif
					if x=CHUNK_WIDTH then chunkdata[x,y,z].faces[3] = 1 // put a final edge on the X edge to catch the last block
					if z=CHUNK_WIDTH then chunkdata[x,y,z].faces[5] = 1 // put a final edge on the Z edge to catch the last block
				
					if y=0 then chunkdata[x,y,z].faces[1] = 1 // put a final top on the Y edge to catch the last block
					if x=0 then chunkdata[x,y,z].faces[2] = 1 // put a final edge on the X edge to catch the last block
					if z=0 then chunkdata[x,y,z].faces[4] = 1 // put a final edge on the Z edge to catch the last block
				
				
				if y-1>=0
					if (chunkdata[x,y - 1,z].air = 0 ) // is there a NO block at the previous Y positin
						chunkdata[x,y - 1,z].faces[0] = 0 // topface = 0 
if tops=1	then 					chunkdata[x,y 	 ,z].faces[1] = 1 //    bottomface = 1 // change this to have a bottom face
					endif
					if (chunkdata[x,y - 1,z].air = 1 ) // there is a block at the previous but also at this location, so
						chunkdata[x,y - 1,z].faces[0] = 0 // topface = 0 (otherwise will have visible faces inside two connected cubes
						chunkdata[x,y 	 ,z].faces[1]= 0 //    bottom  = 0 (otherwise will have visible faces inside two connected cubes
					endif
				endif
				if z-1>=0
                if (chunkdata[x,y,z - 1].air = 0) // is the NO block on the previous Z 
                    chunkdata[x,y,z - 1].faces[5] = 0 // frontface = 0 then change that blocks front face to invisible
                    chunkdata[x,y,z	   ].faces[4] = 1 //     backface  = 1 change this blocks backface to visible
                endif
                if (chunkdata[x,y,z - 1].air = 1)  // if there is a block at previous Z 
                    chunkdata[x,y,z - 1].faces[5] = 0 // frontface = 0 // change that blocks front face to also invisible  (otherwise will have visible faces inside two connected cubes
                    chunkdata[x,y,z		].faces[4] = 0 //     backface = 0 // change this block back face to also invisible  (otherwise will have visible faces inside two connected cubes
                endif
				endif
				
				if x-1>=0
                if (chunkdata[x - 1	,y,z].air = 0)  // there is NO block at the previous X position
                    chunkdata[x - 1	,y,z].faces[3] = 0   //rightface = 0 // remove the right face of the previous block
                    chunkdata[x 	,y,z].faces[2] = 1	//    leftface  = 1 // add a left face to the current position cube
                endif
             
                if ( chunkdata[x - 1,y,z].air =1 ) // is there a block there - if so then remove the inner faces
                    chunkdata[x - 1,y,z].faces[3] = 0 // rightface = 0 (otherwise will have visible faces inside two connected cubes
                    chunkdata[x, 	y,z].faces[2] = 0 // leftface = 0 (otherwise will have visible faces inside two connected cubes
                endif
				endif
            endif
 
            if (chunkdata[x,y,z].air = 0) // empty space at this current position
				if y-1>=0
					if (chunkdata[x,y - 1	,z].air = 0 ) // is there a NO block at the previous Y positin
						chunkdata[x,y - 1	,z].faces[0] = 0 // topface = 0 (otherwise will have visible faces outside two connected cubes
						chunkdata[x,y 		,z].faces[1]=0 //    bottomface = 0 (otherwise will have visible faces outside two connected cubes
					endif
					if (chunkdata[x,y - 1	,z].air = 1 ) // there is a block at the previous but also at this location, so
						if tops=1 then 	chunkdata[x,y - 1	,z].faces[0] = 1 // topface = 1 
						chunkdata[x,y 		,z].faces[1] = 0 //    bottom  = 0 
					endif
				endif
				if z-1>=0
                if (chunkdata[x,y,z - 1].air = 0) // is there no block previus Z
                    chunkdata[x,y,z - 1].faces[5] = 0 // frontface = 0 // change its front to no face  (otherwise will have visible faces outside two connected cubes
                    chunkdata[x,y,z    ].faces[4] = 0 // backface = 0  // change current backface to no face.(otherwise will have visible faces outside two connected cubes
                endif
 
                if (chunkdata[x,y,z - 1].air = 1)  // is there a block prebious Z
                    chunkdata[x,y,z - 1].faces[5] = 1 // frontface 1 // change its front have have a face
                    chunkdata[x,y,z    ].faces[4] = 0 //     backface 0  // change this block backface to not have a face
                endif
				endif
				
				if x-1>=0
                if ( chunkdata[x - 1,y,z].air  = 0 ) // there is no block at the previous X positin either
                    chunkdata[x - 1,y,z].faces[3]=0 // rightface = 0;(otherwise will have visible faces outside two connected cubes
                    chunkdata[x	,y,z].faces[2]=0 //x leftface = 0;(otherwise will have visible faces outside two connected cubes
                endif
             
                if (chunkdata[x - 1,y,z].air = 1 ) // there is a block at the previous position, so enable its rightface
                    chunkdata[x - 1,y,z].faces[3]=1 // rightface = 1;
                    chunkdata[x		,y,z].faces[2] = 0 // leftface = 0;
                endif
				endif
 
            endif
      next
   next
	next
	

	
	
endfunction

function setcameradata()
		SetCameraPosition(1,camerax#,cameray#,cameraz#)
		camerax#=getcamerax(1)
		cameray#=getcameray(1)
		cameraz#=getcameraz(1)
		
		//collision object centre 
		SetObjectPosition(6,camerax#,cameray#,cameraz#)
		//collision object bottom
		SetObjectPosition(7,camerax#,cameray#-.5,cameraz#)
		//collision object above
		SetObjectPosition(8,camerax#,cameray#+.5,cameraz#)
		//collision object front
		SetObjectPosition(9,camerax#,cameray#,cameraz#+.5)
		//collision object behin
		SetObjectPosition(10,camerax#,cameray#,cameraz#-.5)
		//collision object left
		SetObjectPosition(11,camerax#-.5,cameray#,cameraz#)
		//collision object right
		SetObjectPosition(12,camerax#+.5,cameray#,cameraz#)
endfunction

function movecamera()
	if GetPointerState()=1
	fDiffX# = (GetPointerX() - startx#)/4.0
    fDiffY# = (GetPointerY() - starty#)/4.0
    newX# = angx# + fDiffY#
    if ( newX# > 89 ) then newX# = 89
    if ( newX# < -89 ) then newX# = -89
    SetCameraRotation(1, newX#, angy# + fDiffX#, 0 )
	endif
endfunction
function addCubeToMesh(x#,y#,z#,sizex#,sizey#,sizez#,c,top,bottom,lft,rght,front,back)
	
	
	// do adjacent culling check
	cx = floor(x#)
	cy = floor(y#)
	cz = floor(z#)
	
	if top=1
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0	,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5  ,0		, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, .5 ,0		, c)
	AddVertex(meshid, x#-(sizex#/2)  		,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0	,.5	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, .5 ,.5	, c)
	endif
	
	if bottom=1
	// BOTTOM face - top right corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0.5,0  	, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5	, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 1,0		, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 1,0.5		, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,0.5		, c)
	endif


	if back=1
	// front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0, 0.5,1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)			, 0,1,0, 0,1, c)
	endif
		
		
	if front=1
	// Right Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0, 0,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)

	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez# 	, 0,1,0, 0.5,0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0,1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0, 0.5,1, c)
	endif
	
	
	if lft=1
		
	// Front Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2) 			, 0,1,0   , 0    , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0    , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5 , 1  , c)

	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5  , 1, c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#  	, 0,1,0  , .5  , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)			,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	endif

	if rght=1
	// Back Side - bottom left corner texture
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)			, 0,1,0   , 0   , 0.5, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez#	, 0,1,0   , .5   , 1  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2) 			, 0,1,0   , 0   , 1  , c)


	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)-sizey#	,z#+(sizez#/2)-sizez# 	, 0,1,0  , .5   , 1, c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)		   	, 0,1,0  , 0    , .5  , c)
	AddVertex(meshid, x#-(sizex#/2)+sizex#	,y#+(sizey#/2)			,z#+(sizez#/2)-sizez#	, 0,1,0  , .5  , .5 , c)
	endif

	
endfunction


function emptymesh()
	meshid.VertexList.length=-1
endfunction

Function AddVertex(m ref as Mesh, x as float, y as float, z as float, nx as float, ny as float, nz as float, u as float, v as float, air as integer)
    vert as vertex
    vert.x = x
    vert.y = y
    vert.z = z
    vert.nx = nx
    vert.ny = ny
    vert.nz = nz
    vert.u = u
    vert.v = v
    vert.air = air
    m.VertexList.Insert(vert)
  
endfunction
Function CreateObjectFromMeshWithUVTexturing(m ref as mesh, MeshIndex,texture)
	objID=1
    DeleteMemblock(chunkmesh)
    VertexCount = m.VertexList.Length + 1
    IndexCount = 0
    IndexOffset = 60 + VertexCount*36
    chunkmesh = CreateMemblock(IndexOffset+IndexCount*4)
    SetMemblockInt(chunkmesh,0,VertexCount)
    SetMemblockInt(chunkmesh,4,IndexCount)
    SetMemblockInt(chunkmesh,8,3)
    SetMemblockInt(chunkmesh,12,32) // no color - 36 if color
    SetmemblockInt(chunkmesh,16,60)
    SetMemblockInt(chunkmesh,20,IndexOffset)
    SetMemblockInt(chunkmesh,24,0x0c000300)
    SetMemblockString(chunkmesh,28,"position")
    SetMemblockInt(chunkmesh,40,0x08000300)
    SetMemblockString(chunkmesh,44,"normal")
    SetMemblockInt(chunkmesh,52,0x04000200)
    SetMemblockString(chunkmesh,56,"uv")
    //SetMemblockInt(memblock,60,0x08010401) // maybe one day or year in 2019 lol
    //SetMemblockString(memblock,64,"color") // maybe one day or year in 2019 lol
        for i = 0 to m.VertexList.Length
			
		if m.VertexList[i].air = 1 // has a block there
			SetMemblockFloat(chunkmesh,60+i*32,m.VertexList[i].x)
			SetMemblockFloat(chunkmesh,64+i*32,m.VertexList[i].y)
			SetMemblockFloat(chunkmesh,68+i*32,m.VertexList[i].z)
			SetMemblockFloat(chunkmesh,72+i*32,m.VertexList[i].nx)
			SetMemblockFloat(chunkmesh,76+i*32,m.VertexList[i].ny)
			SetMemblockFloat(chunkmesh,80+i*32,m.VertexList[i].nz)
			SetMemblockFloat(chunkmesh,84+i*32,m.VertexList[i].u)
			SetMemblockFloat(chunkmesh,88+i*32,m.VertexList[i].v)
		endif
        //SetMemblockInt(memblock,104+i*36,m.VertexList[i].color) //maybe one day or year in 2019 lol
    next
//    DeleteAllObjects()
	objID = CreateObjectFromMeshMemblock(chunkmesh)
    SetObjectImage(objID,texture,0)
	SetObjectColor(objID,255,255,255,10)
endfunction objID 

function checkCollisionv2(objwith,objID as integer,objID2 as integer)
	start_x#=getobjectx(objID)
	start_y#=getobjecty(objID)
	start_z#=getobjectz(objID)

	end_x#=getobjectx(objID2)
	end_y#=getobjecty(objID2)
	end_z#=getobjectz(objID2)


// determine which object has been hit
	object_Hit = ObjectRayCast(objwith,start_x#,start_y#,start_z#,end_x#,end_y#,end_z#)

endfunction object_Hit

function createtexturesnowy()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
		//	if random(1,0)=1
				c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
			//else
			//	c=MakeColor(random(200,255),random(200,255),random(200,255)) // white
			//endif	
			
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
			c=MakeColor(random(100,140),random(30,130),0)
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
			if y<20
				if random(0,10)>1
					c=MakeColor(random(240,255),random(240,255),random(240,255)) // green
				else
					c=MakeColor(random(100,140),random(30,130),0)
				endif
						
			else
				c=MakeColor(random(100,140),random(30,130),0)
			endif
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img

function createtexturegreeny()

countx=2
	
	
	stp = 1
	//top - snowy
	for x=0 to 16 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next
	
	//bottom - dirt
	for x=16 to 32 step stp
		for y=0 to 16 step stp
				c=MakeColor(0,random(40,155),0) // green
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next


// 3 sides - a bit of green at top and orange at bottom
	for x=0 to 16 step stp
		for y=16 to 32 step stp
				c=MakeColor(0,random(40,155),0) // green
						
			DrawBox(x,y,x+4,y+4,c,c,c,c,1)
		next
	next



	
	img = GetImage(0,0,32,32)
	SaveImage(img,"test.png")
endfunction img




function createtreestructure(x#,y#,z#)
	//           111
	//            111
	//          1111111
	//          1 1 111
	//         11111111 
	//          1 1 111
	//          1111111
	//            111
	//           111
	//
	height=8
	
	/*
	addCubeToMesh(x#+0,y#+8,z#,1,1,1,1)
	
	addCubeToMesh(x#-1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+7,z#,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+7,z#+1,1,1,1,1)

	addCubeToMesh(x#-1,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#,y#+6,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+6,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+5,z#+1,1,1,1,1)
	
	addCubeToMesh(x#-2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+5,z#,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+5,z#,1,1,1,1)

	addCubeToMesh(x#-1,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+1,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#,y#+4,z#+2,1,1,1,1)

	addCubeToMesh(x#-2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#-1,1,1,1,1)
	addCubeToMesh(x#-2,y#+4,z#+1,1,1,1,1)
	addCubeToMesh(x#+2,y#+4,z#+1,1,1,1,1)


	addCubeToMesh(x#-1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#-2,1,1,1,1)
	addCubeToMesh(x#-1,y#+4,z#+2,1,1,1,1)
	addCubeToMesh(x#+1,y#+4,z#+2,1,1,1,1)


	addCubeToMesh(x#-1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#-1,y#+3,z#+1,1,1,1,1)

	addCubeToMesh(x#+1,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#,1,1,1,1)
	addCubeToMesh(x#+1,y#+3,z#+1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#-1,1,1,1,1)
	addCubeToMesh(x#,y#+3,z#+1,1,1,1,1)


	addCubeToMesh(x#,y#+2,z#,1,1,1,1)
	addCubeToMesh(x#,y#+1,z#,1,1,1,1)
	addCubeToMesh(x#,y#+0,z#,1,1,1,1)
*/











	
	
	
	
endfunction


/*
for (y = 0; y < 7; y++ )
    for (z = 0; z < 7; z++ )
        for (x = 0; x < 7; x++)
 
         
            if (x = block) // block at this current position
 
                if (y - 1 == air ) // is there a NO block at the previous Y positin
                    y - 1 topface = 0 
                    y     bottomface = 1 // change this to have a bottom face
                endif
                if (y - 1 == block ) // there is a block at the previous but also at this location, so
                    y - 1 topface = 0 (otherwise will have visible faces inside two connected cubes
                    y     bottom  = 0 (otherwise will have visible faces inside two connected cubes
                endif
 
 
                endif
                if (z - 1 == air) // is the NO block on the previous Z 
                    z - 1 frontface = 0 then change that blocks front face to invisible
                    z     backface  = 1 change this blocks backface to visible
                endif
                if (z - 1 = block)  // if there is a block at previous Z 
                    z - 1 frontface = 0 // change that blocks front face to also invisible  (otherwise will have visible faces inside two connected cubes
                    z     backface = 0 // change this block back face to also invisible  (otherwise will have visible faces inside two connected cubes
                endif
             
                if (x - 1 == air)  // there is NO block at the previous X position
                    x - 1 rightface = 0 // remove the right face of the previous block
                    x     leftface  = 1 // add a left face to the current position cube
                endif
             
                if ( x - 1 == block ) // is there a block there - if so then remove the inner faces
                    x - 1 rightface = 0 (otherwise will have visible faces inside two connected cubes
                    x leftface = 0 (otherwise will have visible faces inside two connected cubes
                endif
 
            endif
 
            if (x == air) // empty space at this current position
 
                if (y - 1 == air ) // is there a NO block at the previous Y positin
                    y - 1 topface = 0 (otherwise will have visible faces outside two connected cubes
                    y     bottomface = 0 (otherwise will have visible faces outside two connected cubes
                endif
                if (y - 1 == block ) // there is a block at the previous but also at this location, so
                    y - 1 topface = 1 
                    y     bottom  = 0 
                endif
 
 
                if (z - 1) == air // is there no block previus Z
                    z - 1 frontface = 0 // change its front to no face  (otherwise will have visible faces outside two connected cubes
                    z     backface = 0  // change current backface to no face.(otherwise will have visible faces outside two connected cubes
                endif
 
                if (z - 1) == block  // is there a block prebious Z
                    z - 1 frontface 1 // change its front have have a face
                    z         backface 0  // change this block backface to not have a face
                endif
 
                if ( x - 1  == air ) // there is no block at the previous X positin either
                    x - 1 rightface = 0;(otherwise will have visible faces outside two connected cubes
                    x leftface = 0;(otherwise will have visible faces outside two connected cubes
                endif
             
                if (x - 1 == block ) // there is a block at the previous position, so enable its rightface
                    x - 1 rightface = 1;
                    x leftface = 0;
                endif
 
            endif
      next
   next
next

*/