Sorry your browser is not supported!

            // create new object / mesh
            AgkImage img = new AgkImage("media/checked.png");
            AgkObject3D o = new AgkObject3D();
            AgkMesh m = new AgkMesh(o);
            m.SetImage(img);

            // set mesh properties
            float width = 25;
            float height = 25;
            int segH = 63;
            int segV = 63;

            // calc num vertices and indices
            uint numV = (uint)((segH + 1) * (segV + 1));
            uint numI = (uint)(segH * segV * 6);
            m.SetVertices(numV, numI);

            // create attributes
            m.CreateVertexAttributes(3);
            position = m.CreateVertexAttribute(0, "position", 0, 3, false);
            normal = m.CreateVertexAttribute(1, "normal", 0, 3, true);
            AgkVertexAttrib uv = m.CreateVertexAttribute(2, "uv", 0, 2, true);

            // create vertices (position)
            float cx = width / 2.0f;
            float cz = height / 2.0f;
            float sx = width / segH;
            float sz = height / segV;
            uint index = 0;
            for (int z = 0; z <= segV; z++)
            {
                for (int x = 0; x <= segH; x++)
                {
                    float px = x * sx - cx;
                    float pz = z * sz - cz;
                    //float py = -(float)Math.Sin(Math.Min(Math.Sqrt(px * px + pz * pz) * 2.0, cx) / cx) * (width / 5.0f);
                    float py =  (float)Math.Sin(Math.Sqrt(px * px + pz * pz)) / cx * (width / 3.0f);

                    AGKVector3 p = new AGKVector3(px, py, pz);
                    position.SetData(index, p);

                    AGKVector2 t = new AGKVector2(x * 1.0f / segH, z * 1.0f / segV);
                    uv.SetData(index, t);

                    normal.SetData(index, AGKVector3.Vector3Zero);
                    index++;
                }
            }

            // build indices
            m.GetIndices(out indices);
            index = 0;
            for (int y = 0; y < segV; y++)
            {
                int v = y * (segV + 1);
                for (int x = 0; x < segH; x++)
                {
                    indices[index] = v;
                    indices[index + 1] = v + 1;
                    indices[index + 2] = v + 1 + (segH + 1);

                    indices[index + 3] = v;
                    indices[index + 4] = v + 1 + (segH + 1);
                    indices[index + 5] = v + (segH + 1);

                    index += 6;
                    v++;
                }
            }

            // calc normals
            RecalcNormals(m);
            m.SetIndices(ref indices);
            m.ProcessVertexData();

            o.AddMesh(m);

            while (Core.LoopAGK())
            {
                Agk.Print(Agk.ScreenFPS());
                Agk.Print(string.Format("Vertices: {0}", m.NumVertices));
                Agk.Print(string.Format("Faces: {0}", m.NumIndices/3));
                MeshMod(m, Agk.Timer()*3.0f);
                o.Draw();
                //o.RotateLocalY(90.0f*Agk.GetFrameTime());

                Agk.Sync();
            }

        static void MeshMod(AgkMesh mesh, float amp)
        {
            //AgkVertexAttrib position = mesh.GetVertexAttribute("position");
            for (uint i = 0; i <= mesh.NumVertices; i++)
            {
                AGKVector3 p = position.GetDataVec3(i);
                float length = (float)Math.Sqrt(p.X * p.X + p.Z * p.Z) + amp;
                p.Y = (float)Math.Sin(length) / 12.5f * (25.0f / 3.0f);

                position.SetData(i, p);
            }
            RecalcNormals(mesh);

            mesh.ProcessVertexData();
        }

        static void RecalcNormals(AgkMesh mesh)
        {
            // calc normals
            for (int i = 0; i < indices.Length; i += 3)
            {
                AGKVector3 v0 = position.GetDataVec3((uint)indices[i]);
                AGKVector3 v1 = position.GetDataVec3((uint)indices[i + 1]);
                AGKVector3 v2 = position.GetDataVec3((uint)indices[i + 2]);

                AGKVector3 nc = -((v1 - v0).Cross(v2 - v0)).Normalize();

                AGKVector3 n = (normal.GetDataVec3((uint)indices[i]) + nc);
                normal.SetData((uint)indices[i], n.Normal);

                n = (normal.GetDataVec3((uint)indices[i + 1]) + nc);
                normal.SetData((uint)indices[i + 1], n.Normal);

                n = (normal.GetDataVec3((uint)indices[i + 2]) + nc);
                normal.SetData((uint)indices[i + 2], n.Normal);
            }
        }

// Project: Parabola
// Created: 2018-04-06

// show all errors
SetErrorMode(2)
#constant screenWidth=1024
#constant screenHeight=768
#constant mapX=1024
#constant mapY=50
#constant mapZ=512

  
SetWindowSize(screenWidth,screenHeight,0)
Setvirtualresolution(screenWidth,screenHeight)
SetScissor(0,0,0,0)
SetCameraRange( 1, 0.1, 900000 )
SetGlobal3DDepth(10000)


type _heights
	meshposition
	height
    PointX
    PointZ
endtype

rem for sine cosine calculations
#constant centreX=5
#constant yPosition=1
#constant amplitude=150
//#constant speedX#=.1251
#constant WaveWidth=10
#constant frequency#=15



global TerrainImageID
global TerrainObjectID

TerrainImageID=createtexture(32,32, makecolor(0,200,0),155)
Image1=createtexture(512,512, makecolor(200,200,200),5)
//Image1=createtexture(512,512, makecolor(200,200,200),255) //creates like a grass over terrain

saveImage(image1,"height.png")
DeleteImage(image1):rem DeleteObject(mem)
 
// create the terrain object from a height map
TerrainObjectID=CreateObjectFromHeightMap( "height.png", mapX,mapY, mapZ, 0, 0 )
//TerrainObjectID=CreateObjectBox(mapX,1,mapZ)

SetObjectCollisionMode( TerrainObjectID, 1 ) //On needed for object raycasting
SetObjectImage( TerrainObjectID, TerrainImageID, 0 )
SetObjectTransparency(TerrainObjectID,0)
TerrainMemblock= CreateMemblockFromObjectMesh(TerrainObjectID,1)

rem num=mapX*126
maxIndices=GetMemblockInt(terrainMemblock,0)
maxX=(SQRT(maxIndices))
Dim heights[maxIndices] as _heights
meshposition=0:num=0:pointX=0:pointZ=0
for num = 0 to maxIndices //max vertices
        pointX=pointX+1
        if pointX>maxX 
			pointX=1
			pointZ=PointZ+1
		endif
        // add to array
        heights[num].height=1
        heights[num].meshposition=meshposition
		heights[num].PointX=pointX   
        heights[num].PointZ=pointZ    
        
        inc meshposition
next num



//setupArray()  
//SetCameraRange(1,1,2000 ) 
SetCameraPosition(1, 805, 378, -41)
  
steps = -1  
do
    checkCameraMovement()
      
    pointerState=GetRawMouseLeftState() 
	if GetRawMouseRightPressed()
		for i = 0 to maxIndices-1 //max vertices -1
			xWave#=Cos(heights[i].PointX)*(wavewidth/2)+centreX:xWave2#=Cos(heights[i].PointZ)*(wavewidth/2)+centreX
			yWave#=Sin(xWave#*frequency#)*(amplitude)+yposition:yWave2#=Sin(xWave2#*frequency#)*(amplitude)+yposition			
			SetMeshMemblockVertexPosition(TerrainMemblock,heights[i].meshposition,GetMeshMemblockVertexX(TerrainMemblock,i),GetMeshMemblockVertexY(TerrainMemblock,i)+(yWave#+ywave2#),GetMeshMemblockVertexZ(TerrainMemblock,i))
			rem used for the animation
			heights[i].pointX=heights[i].pointX+1
			if heights[i].pointX>maxX 
				heights[i].pointX=1
			endif
		next
		SetObjectMeshFromMemblock(TerrainObjectID,1,TerrainMemblock)         
	endif
    //endif
    // show some information
    Print( "FPS: " + str(ScreenFPS(),1) )
    Print( "Polygons: " + str(GetPolygonsDrawn()))
    print("vertices="+str(GetMemblockInt(terrainMemblock,0)))
    print("Arrows move camera")
    print("Click right mouse to apply sine curve")
    sync()
      
loop


function checkCameraMovement()
  
if GetRawKeyState(37) then MoveCameraLocalX(1,-5) //Left
if GetRawKeyState(39) then MoveCameraLocalX(1,5) //Right
if GetRawKeyState(38) then MoveCameraLocalZ(1,5) //Forward
if GetRawKeyState(40) then MoveCameraLocalZ(1,-5) //Backward
if GetRawKeyState(87) then MoveCameraLocalY(1,-5) //87 W
if GetRawKeyState(83) then MoveCameraLocalY(1,5) //87 S
if GetRawKeyState(65) then RotateCameraLocalY(1,1)
if GetRawKeyState(68) then RotateCameraLocalY(1,-1)
  
// if cameray#<(blocksizey*10) then cameray#=(blocksizey*10)
if GetRawKeyPressed(27) then end

endfunction
  
  

  
function resetTerrain (msblk as integer) 
  
    count = GetMemblockInt( msblk ,0 )
    for i = 0 to count  
        SetMeshMemblockVertexPosition(msblk,i,GetMeshMemblockVertexX(msblk,i),0,GetMeshMemblockVertexZ(msblk,i)) //make it flat
    next
    SetObjectMeshFromMemblock(TerrainObjectID,1,msblk)
Endfunction

// 102, 51, 0
// Function to create a texture
//
// Inputs - Sizex - size of the texture to create - width
//          Sizey - size of the texture to create - height
//          Color - is the main color of the image
//          Denisity - is a the depth of the texture - the lower the value, the more detail. higher value = no detail
// 
// Returns the image for the resulting texture
//
// EG. CreateTexture ( 100, 100,  makecolor(0,0,255), 100)
//          This could create a DEEP water effect texture?
    
function createtexture(sizex# as float, sizey# as float, color, density as integer)
    swap()
    drawbox(0,0,sizex#, sizey#, color, color,color,color, 1)
    render()
    img = getimage(0,0,sizex#, sizey#)
        
    memblockid = CreateMemblockFromImage (img)
    imgwidth = GetMemblockInt(memblockid, 0)
    imgheight = GetMemblockInt(memblockid, 4)
        
    size=GetMemblockSize(memblockid)
    for offset=12 to size-4 step 4
          
        r=GetMemblockByte(memblockid, offset)
        g=GetMemblockByte(memblockid, offset+1)
        b=GetMemblockByte(memblockid, offset+2)
        a=GetMemblockByte(memblockid, offset+3)
                
            
        strength=random(1,density)
    
        SetMemblockByte (memblockid, offset, r-strength)
        SetMemblockByte (memblockid, offset+1, g-strength)
        SetMemblockByte (memblockid, offset+2, b-strength )
        SetMemblockByte (memblockid, offset+3, a-strength)
    next
    deleteimage (img)
    img = CreateImageFromMemblock(memblockid)
    DeleteMemblock(memblockid)
endfunction img

        // function to set the height of a plain from an image
        private static void SetHeightmap(uint oid, uint iid, float posX, float posY, float mul)
        {
            AgkObject3D obj = new AgkObject3D(Agk.GetObjectPtr(oid));
            AgkMesh mesh = obj.GetMesh(0);

            AgkVertexAttrib uv = mesh.GetVertexAttribute("uv");
            AgkVertexAttrib pos = mesh.GetVertexAttribute("position");

            for (uint i = 0; i < mesh.NumVertices; i++)
            {
                AGKVector2 tex = uv.GetDataVec2(i);
                AGKVector3 coord = pos.GetDataVec3(i);
                double y = perlin.GetValue(tex.U + posX, tex.V + posY, 0.5) * mul;


                coord.Y = (float)y;
                pos.SetData(i, coord);
            }
            RecalcNormals(mesh);
            mesh.ProcessVertexData();

            float width = Agk.GetImageWidth(100);
            float height = Agk.GetImageHeight(100);
            float mu = (posX % width);
            float mv = (posY % height);
            mesh.SetUVOffset(0, mu, mv);

        }

        // create object plain specify the width, height and number of segments
        private static void CreatePlain(uint obj, uint width, uint height, int segH, int segV)
        {
            if (!Agk.IsObjectExists(obj))
                Agk.CreateObjectPlane(obj, 1, 1);

            AgkObject3D o = new AgkObject3D(Agk.GetObjectPtr(obj));
            o.DeleteMeshes();

            AgkMesh m = new AgkMesh(o);

            // calc num vertices and indices
            uint numV = (uint)((segH + 1) * (segV + 1));
            uint numI = (uint)(segH * segV * 6);
            m.SetVertices(numV, numI);

            // create attributes
            m.CreateVertexAttributes(3);
            AgkVertexAttrib position = m.CreateVertexAttribute(0, "position", 0, 3, false);
            AgkVertexAttrib normal = m.CreateVertexAttribute(1, "normal", 0, 3, true);
            AgkVertexAttrib uv = m.CreateVertexAttribute(2, "uv", 0, 2, true);

            // create vertices (position)
            float cx = (float)width / 2.0f;
            float cz = (float)height / 2.0f;
            float sx = (float)width / (float)segH;
            float sz = (float)height / (float)segV;
            uint index = 0;
            for (int z = 0; z <= segV; z++)
            {
                for (int x = 0; x <= segH; x++)
                {
                    float px = x * sx - cx;
                    float pz = z * sz - cz;
                    //float py = (float)Math.Sin(Math.Sqrt(px * px + pz * pz)) / cx * (width / 3.0f);
                    float py = 0.0f;

                    AGKVector3 p = new AGKVector3(px, py, pz);
                    position.SetData(index, p);

                    AGKVector2 t = new AGKVector2(x * 1.0f / segH, z * 1.0f / segV);
                    uv.SetData(index, t);

                    normal.SetData(index, AGKVector3.Vector3Zero);
                    index++;
                }
            }

            // build indices
            m.GetIndices(out int[] indices);
            index = 0;
            for (int y = 0; y < segV; y++)
            {
                int v = y * (segV + 1);
                for (int x = 0; x < segH; x++)
                {
                    indices[index] = v;
                    indices[index + 1] = v + 1;
                    indices[index + 2] = v + 1 + (segH + 1);

                    indices[index + 3] = v;
                    indices[index + 4] = v + 1 + (segH + 1);
                    indices[index + 5] = v + (segH + 1);

                    index += 6;
                    v++;
                }
            }

            // calc normals
            for (int i = 0; i < indices.Length; i += 3)
            {
                AGKVector3 v0 = position.GetDataVec3((uint)indices[i]);
                AGKVector3 v1 = position.GetDataVec3((uint)indices[i + 1]);
                AGKVector3 v2 = position.GetDataVec3((uint)indices[i + 2]);

                AGKVector3 nc = -((v1 - v0).Cross(v2 - v0)).Normalize();

                //AGKVector3 n = AGKVector3.Vector3Up;
                AGKVector3 n = (normal.GetDataVec3((uint)indices[i]) + nc);
                normal.SetData((uint)indices[i], n.Normal);

                n = (normal.GetDataVec3((uint)indices[i + 1]) + nc);
                normal.SetData((uint)indices[i + 1], n.Normal);

                n = (normal.GetDataVec3((uint)indices[i + 2]) + nc);
                normal.SetData((uint)indices[i + 2], n.Normal);
            }

            m.SetIndices(ref indices);
            m.ProcessVertexData();

            o.AddMesh(m);
        }

        // calculate normals of a mesh.
        static void RecalcNormals(AgkMesh mesh)
        {
            AgkVertexAttrib position = mesh.GetVertexAttribute("position");
            AgkVertexAttrib normal = mesh.GetVertexAttribute("normal");
            mesh.GetIndices(out int[] indices);

            // calc normals
            for (int i = 0; i < indices.Length; i += 3)
            {
                AGKVector3 v0 = position.GetDataVec3((uint)indices[i]);
                AGKVector3 v1 = position.GetDataVec3((uint)indices[i + 1]);
                AGKVector3 v2 = position.GetDataVec3((uint)indices[i + 2]);

                AGKVector3 nc = -((v1 - v0).Cross(v2 - v0)).Normalize();

                //AGKVector3 n = AGKVector3.Vector3Up;
                AGKVector3 n = (normal.GetDataVec3((uint)indices[i]) + nc);
                normal.SetData((uint)indices[i], n.Normal);

                n = (normal.GetDataVec3((uint)indices[i + 1]) + nc);
                normal.SetData((uint)indices[i + 1], n.Normal);

                n = (normal.GetDataVec3((uint)indices[i + 2]) + nc);
                normal.SetData((uint)indices[i + 2], n.Normal);
            }
        }