Sorry your browser is not supported!

#include "darkgdk.h"
#include "global.h"
#include "Block.h"
#ifndef CHUNK_H
#define CHUNK_H
static const int CHUNK_SIZE = 64;
int CHUNK_DATA[4096] = {0};
class Chunk
{
public:
Chunk(char* heightData)
{
	//generate height info from height map
	int img = FindFreeObject();
	dbLoadImage("Height.bmp",img);
	ChunkIterator=0;
	DWORD color;
	dbOpenToWrite(1,heightData);
	while(ChunkIterator<(CHUNK_SIZE*CHUNK_SIZE))
	{
		dbPasteImage(img,0,0);
		dbSync();
		
		

		for(int x = 0; x < CHUNK_SIZE; x++)
		{
			for(int y = 0; y < CHUNK_SIZE; y++)
			{
				dbPasteImage(img,0,0);
				color=dbPoint(x,y);
				CHUNK_DATA[ChunkIterator] = dbRGBR(color);
				dbWriteLong(1,CHUNK_DATA[ChunkIterator]);
				ChunkIterator++;
			}
		}
		
		dbCloseFile(1);
		dbWait(10);
	


}
}
~Chunk()
{ 
	delete[] CHUNK_DATA;
}

void GenerateChunk(int xp, int zp)
{
	ChunkIterator = 0;
	for(int x = 0; x < CHUNK_SIZE; x++)
	{
		for(int z = 0; z < CHUNK_SIZE; z++)
		{
			int y = CHUNK_DATA[ChunkIterator]/16;
			
			
				int Texture;
				if(y<5) Texture = 1;
				if(y>=5) Texture = 3;
			block.MakeBlock(xp+(x*10),(y)*10,zp+(z*10),Texture);
			
			ChunkIterator++;
		}
	}
}
void Update()
{
	block.Update();
}
protected:
	int ChunkIterator;
	Block_Manager block;

};
#endif

#include "darkgdk.h"
#ifndef BLOCK_H
#define BLOCK_H
class Block
{
public:
	Block(int x, int y, int z, int type)
	{
		ID = FindFreeObject();
		
		if(type==1) dbInstanceObject(ID,BLOCKS); 
		if(type==2) dbInstanceObject(ID,BLOCKD);
		if(type==3) dbInstanceObject(ID,BLOCKG);
		
		
		
		
		dbPositionObject(ID,x,y,z);
	}
	void Update()
	{
		int Dist = Distance(ID);
		if(Dist<100000)
		{
			dbExcludeObjectOff(ID);
		}
		if(Dist>=100000)
		{
			dbExcludeObjectOn(ID);
		}
	}
protected:
	int ID;
	

};

class Block_Manager
{
	std::vector<Block> blocks;
public:
	Block_Manager() {}
	~Block_Manager()
	{
		for(unsigned i = 0; i < blocks.size(); i++)
		{
			blocks.erase(blocks.begin()+i);
		}
		
	}
	void MakeBlock(int x, int y, int z, int type)
	{
		Block block(x,y,z,type);
		blocks.push_back(block);
	}

	void Update()
	{
		for(unsigned i = 0; i < blocks.size(); i++)
		{
			blocks[i].Update();
		}
	}
protected:
};
#endif

const int BLOCKS = 1;
const int BLOCKD = 2;
const int BLOCKG = 3;
const int SAND = 1;
const int DIRT = 2;
const int GRASS = 3;

const int SKY = 4;

#include "DarkGDK.h"
#include "Chunk.h"



void LoadMedia();
void DarkGDK ( void )
{

	
	

	
	dbSyncOn();
	dbSyncRate(60);
	LoadMedia();

	Chunk chunk("test.map");
	for(int x = 0; x < 2; x++)
	{
		for(int y = 0; y < 2; y++)
		{
			chunk.GenerateChunk(x*(10*64),y*(10*64));
		}
	}
	
	
	dbCLS();
	dbPositionCamera(0,100,0);
	while ( LoopGDK ( ) )
	{
		dbPrint(dbScreenFPS()*1.0);
			dbControlCameraUsingArrowKeys(0,1,1);
			chunk.Update();
		dbSync();
	
	}

	return;
}


void LoadMedia()
{
	dbSetCameraRange(1,1000000000);
	dbLoadImage("media/Textures/sand.jpg",SAND);
	dbLoadImage("media/Textures/dirt.png",DIRT);
	dbLoadImage("media/Textures/grass.png",GRASS);
	dbLoadImage("media/sky.jpg",SKY);

	dbMakeObjectSphere(SKY,-10000000);
	dbSetObjectFog(SKY,0);
	dbFogOn();
	dbFogDistance(300);
	dbRotateObject(SKY,180,0,0);
	dbTextureObject(SKY,SKY);
	dbSetObjectLight(SKY,0);
	dbMakeObjectCube(BLOCKS,10);
	dbTextureObject(BLOCKS,SAND);
	dbMakeObjectCube(BLOCKD,10);
	dbTextureObject(BLOCKD,DIRT);
	dbMakeObjectCube(BLOCKG,10);
	dbTextureObject(BLOCKG,GRASS);

	
}

for(int x = 0; x < 2; x++)//cant change to 3 in either for loop
	{
		for(int y = 0; y < 2; y++)
		{
			chunk.GenerateChunk(x*(10*64),y*(10*64));
		}
	}

class OctreeChunk
{
          public :
              OctreeChunk(const AABB &aabb_);
              ~OctreeChunk();          
             
               /* Inserts an object into the Octree, */
               void add(Object * object);
           
              const AABB & getAABB() const
              { 
                    return aabb;
              } 
       
        private :
               OctreeChunk * subChunks[8];     // The 8 sub chunks of this chunk.NULL if there are no sub chunks
               OctreeChunk * parentChunk;       // The parent chunk of this Octree chunk. If it's the root chunk , it's NULL
               std::vector<Object * > objects;     // And an array of objects (in this case blocks) 
              AABB aabb;     // the aabb of this chunk;
          
              bool fitsIntoSubChunk(Object * object); // Checks if object fits into one of the sub chunks.If yes inserts the object and returns true

};

OctreeChunk::OctreeChunk(const AABB &aabb_):
   parentChunk(NULL),
   aabb(aabb_)
{
      for (int c =0; c < 8 c++) subChunks[c] = NULL;
}

OctreeChunk::~OctreeChunk()
{
        if (subChunks[0])
       {
             for (int c =0; c < 8 c++) 
             {
                   delete subChunks[c];
                   subChunks[c] = NULL;
             }
       }
}

bool OctreeChunk::add(Object * object)
{
       // First check does the object fully fit inside this chunk.If not , return false. No further action needed.If doesn't fit into this chunk, we can be sure it won't fit it into it's sub chunks
      if (!object->isFullyInside(this->getAABB()) return false;

      // First try to add to sub chunks.If it was successful , return true 
       if (subChunks[0])
       {
              for (int c =0; c < 8 c++) 
              {
                      if (subChunks[c]->Add(object)) return true;
              }
       }

      // If we reached this part , that means our object doesn't fit into this chunk's sub chunks , so simply add to this
     this->objects.push_back(object);
     
     // now only one think left.If we reached the max objects per chunks and its not already split , split this node
    if (objects.size() > MAX_OBJECTS_PER_CHUNK && !subChunks[0])
    {
         for (int c = 0; c < 8 c++) 
         {
                subChunks[c] = new OctreeChunk(someAABB);
                subChunks[c]->parent = this;
         }

         // now resort our objects...
         std::vector<Object*>::iterator it = objects.begin();
         while (it != objects.end())
         {
                 if (fitsIntoSubChunk((*it))
                 {
                        it = objects.erase(it);
                 }     
                 else
                 {
                         it++;
                 } 
         }
    }

    return true;
}

bool OctreeChunk::fitsIntoSubChunk(Object * object)
{
          for (int c = 0; c < 8 c++)
          {
                 if (object->IsFullyInside(this->getAABB())
                 {
                         subChunks[c]->object.push_back(object);
                         return true;
                 }
          }
          return false;
}

class Octree
{
       public :
               Octree(int maxSubChunks , int maxObjectsPerChunk);
               ~Octree();
              void add(Object * object);

       private:
             OctreeChunk * rootChunk;
             int maxSubChunks , maxObjectsPerChunks;
};

Octree::Octree(int maxSubChunks_ , int maxObjectsPerChunks_):
    maxSubChunks(maxSubChunks_),
    maxObjectsPerChunks(maxObjectsPerChunks_),
    rootChunk(NULL)
{
      rootChunk = new OctreeChunk(someAABB);
}

Octree::~Octree()
{
    delete rootChunk;
}

void Octree::add(Object * object)
{
         rootChunk->add(object);
}

// etc...