#include <iostream>
#include <vector>
using namespace std;
// IRRLICHT INCLUDES
// =====================================
#include <irrlicht.h>
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
// =====================================
// GLOBALS
// =====================================
const unsigned int g_nWidth = 800;
const unsigned int g_nHeight = 600;
IrrlichtDevice* device = 0;
IVideoDriver* driver = 0;
ISceneManager* smgr = 0;
IGUIEnvironment* guienv = 0;
/*
predictable systems behave predictably.
As i predict, so it is. So it will be.
*/
const unsigned int g_nSquaresInARow = 8;
const unsigned int g_nCenterOfARow = 4;
const unsigned int g_nFaces = 6;
const unsigned int g_nUnitSize = 2;
//
class MyEventReceiver : public IEventReceiver
{
public:
// This is the one method that we have to implement
virtual bool OnEvent(const SEvent& event)
{
// Remember whether each key is down or up
if (event.EventType == irr::EET_KEY_INPUT_EVENT)
KeyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;
return false;
}
// This is used to check whether a key is being held down
virtual bool IsKeyDown(EKEY_CODE keyCode) const
{
return KeyIsDown[keyCode];
}
MyEventReceiver()
{
for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
KeyIsDown[i] = false;
}
private:
// We use this array to store the current state of each key
bool KeyIsDown[KEY_KEY_CODES_COUNT];
};
//
struct Cube
{
bool Left [8][8];
bool Right [8][8];
bool Bottom[8][8];
bool Top [8][8];
bool Front [8][8];
bool Back[8][8];
void setFacialData(bool*** cells);
};
void Cube::setFacialData(bool*** cells)
{
for (unsigned int iii = 0; iii < g_nSquaresInARow; ++iii)
{
for (unsigned int jjj = 0; jjj < g_nSquaresInARow; ++jjj)
{
for (unsigned int lll = 0; lll < g_nSquaresInARow; ++lll)
{
Left[iii][jjj] = cells[iii][jjj][0];
Right[iii][jjj] = cells[iii][jjj][g_nSquaresInARow - 1];
Top[iii][jjj] = cells[g_nSquaresInARow - 1][jjj][lll];
Bottom[iii][jjj] = cells[0][jjj][lll];
Front[iii][jjj] = cells[iii][0][lll];
Back[iii][jjj] = cells[iii][g_nSquaresInARow-1][lll];
}
}
}
}
unsigned int xor128()
{
static unsigned int x = 8584732;
static unsigned int y = 6525464;
static unsigned int z = 3711115;
static unsigned int w = 9032831;
unsigned int t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = w ^ (w >> 19) ^ (t ^ (t >> 8));
}
unsigned int GetRandomNumber()
{
return xor128();
}
bool*** g_Cells = 0;
void InitCells()
{
g_Cells = new bool**[g_nSquaresInARow];
for (unsigned int yyy = 0; yyy < g_nSquaresInARow; ++yyy)
{
g_Cells[yyy] = new bool*[g_nSquaresInARow];
for (unsigned int xxx = 0; xxx < g_nSquaresInARow; ++xxx)
{
g_Cells[yyy][xxx] = new bool[g_nSquaresInARow];
for (unsigned int iii = 0; iii < g_nSquaresInARow; ++iii)
{
g_Cells[yyy][xxx][iii] = false;
}
}
}
}
void DeInitCells()
{
for (unsigned int yyy = 0; yyy < g_nSquaresInARow; ++yyy)
{
for (unsigned int xxx = 0; xxx < g_nSquaresInARow; ++xxx)
{
delete [] g_Cells[yyy][xxx];
g_Cells[yyy][xxx] = 0;
}
}
for (unsigned int yyy = 0; yyy < g_nSquaresInARow; ++yyy)
{
delete [] g_Cells[yyy];
g_Cells[yyy] = 0;
}
delete [] g_Cells;
g_Cells = 0;
}
void ResetCells()
{
for (unsigned int zzz = 0; zzz < g_nSquaresInARow; ++zzz)
{
for (unsigned int yyy = 0; yyy < g_nSquaresInARow; ++yyy)
{
for (unsigned int xxx = 0; xxx < g_nSquaresInARow; ++xxx)
{
g_Cells[zzz][yyy][xxx] = false;
}
}
}
}
struct Point3D
{
unsigned int X;
unsigned int Y;
unsigned int Z;
Point3D();
};
Point3D::Point3D() : X(g_nCenterOfARow), Y(g_nCenterOfARow), Z(g_nCenterOfARow)
{
}
class Object
{
public:
Object();
void setPos(Point3D position);
Point3D getPos();
void update();
void amendAcceleration(signed int nValX, signed int nValY, signed int nValZ);
void setMass(unsigned int nVal);
unsigned int getMass();
private:
Point3D m_position;
unsigned int m_nMass;
signed int m_nAccelerations[3];
};
Object::Object() : m_nMass(1)
{
}
void Object::setPos(Point3D position)
{
m_position = position;
}
Point3D Object::getPos()
{
return m_position;
}
void Object::update()
{
m_position.X = m_position.X + m_nAccelerations[0];
m_position.Y = m_position.Y + m_nAccelerations[1];
m_position.Z = m_position.Z + m_nAccelerations[2];
}
void Object::amendAcceleration(signed int nValX, signed int nValY, signed int nValZ)
{
m_nAccelerations[0] = nValX;
m_nAccelerations[1] = nValY;
m_nAccelerations[2] = nValZ;
}
void Object::setMass(unsigned int nVal)
{
m_nMass = nVal;
}
unsigned int Object::getMass()
{
return m_nMass;
}
std::vector<Object> g_objects;
std::vector<scene::ISceneNode*> g_nodes;
bool g_bNodesInitialized = false;
void MakeObjects()
{
if (g_objects.size() > 0)
{
g_objects.clear();
}
for (unsigned int iii = 0; iii < 25; ++iii)
{
Object object;
Point3D point;
point.X = GetRandomNumber() % (g_nSquaresInARow * g_nUnitSize);
point.Y = GetRandomNumber() % (g_nSquaresInARow * g_nUnitSize);
point.Z = GetRandomNumber() % (g_nSquaresInARow * g_nUnitSize);
object.setPos(point);
object.setMass(GetRandomNumber() % 8);
signed int nValX = GetRandomNumber() % 4;
if (GetRandomNumber() % 2 == 1)
{
nValX = -nValX;
}
signed int nValY = GetRandomNumber() % 4;
if (GetRandomNumber() % 2 == 1)
{
nValY = -nValY;
}
signed int nValZ = GetRandomNumber() % 4;
if (GetRandomNumber() % 2 == 1)
{
nValZ = -nValZ;
}
object.amendAcceleration(nValX, nValY, nValZ);
g_objects.push_back(object);
}
if (g_bNodesInitialized == false)
{
scene::ISceneNode * beacon_node = smgr->addSphereSceneNode();
beacon_node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));
beacon_node->setMaterialFlag(video::EMF_LIGHTING, false);
for (unsigned int iii = 0; iii < 25; ++iii)
{
scene::ISceneNode * node = smgr->addSphereSceneNode();
node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));
node->setMaterialFlag(video::EMF_LIGHTING, false);
Point3D point = g_objects[iii].getPos();
node->setPosition(core::vector3df(point.X,point.Y,point.Z));
g_nodes.push_back(node);
}
}
else
{
for (unsigned int iii = 0; iii < 25; ++iii)
{
scene::ISceneNode * node = g_nodes[iii];
Point3D point = g_objects[iii].getPos();
node->setPosition(core::vector3df(point.X,point.Y,point.Z));
}
}
if (g_bNodesInitialized == false)
{
g_bNodesInitialized = true;
}
}
void BoundaryCheck(Point3D point)
{
unsigned int maxZ = g_nUnitSize * g_nSquaresInARow;
unsigned int minZ = 0;
unsigned int maxY = g_nUnitSize * g_nSquaresInARow;
unsigned int minY = 0;
unsigned int maxX = g_nUnitSize * g_nSquaresInARow;
unsigned int minX = 0;
if (point.Z >= maxZ || point.Z <= minZ)
{
}
else if (point.Y >= maxY || point.Y <= minY)
{
}
else if (point.X >= maxX || point.X <= minX)
{
}
else
{
return;
}
g_Cells[point.Z % g_nSquaresInARow][point.Y % g_nSquaresInARow][point.X % g_nSquaresInARow] = true;
}
void Collide()
{
/*
for (unsigned int iii = 0; iii < g_objects.size(); ++iii)
{
for (unsigned int jjj = 0; jjj < g_objects.size(); ++jjj)
{
if (iii == jjj)
{
continue;
}
}
}
*/
}
signed int Test()
{
MyEventReceiver receiver;
device = createDevice(video::EDT_OPENGL, dimension2d<u32>(g_nWidth, g_nHeight), 16, false, false, false, &receiver);
if (device == 0)
return 1;
driver = device->getVideoDriver();
smgr = device->getSceneManager();
guienv = device->getGUIEnvironment();
//
irr::scene::ICameraSceneNode* pCameraNode = smgr->addCameraSceneNodeFPS();
pCameraNode->setPosition(core::vector3df(20.0f, 20.0f, 20.0f));
device->getCursorControl()->setVisible(false);
//
MakeObjects();
InitCells();
std::vector<Cube> measurements;
//
float fTimeElapsed = 0.0f;
float fTimeElapsedB = 0.0f;
irr::u32 then = device->getTimer()->getTime();
while (device->run())
{
const u32 now = device->getTimer()->getTime();
const f32 frameDeltaTime = (f32)(now - then) / 1000.f; // Time in seconds
then = now;
fTimeElapsed = fTimeElapsed + frameDeltaTime;
fTimeElapsedB = fTimeElapsedB + frameDeltaTime;
// INPUT
const f32 MOVEMENT_SPEED = 5.f;
core::vector3df nodePosition = pCameraNode->getPosition();
if(receiver.IsKeyDown(irr::KEY_KEY_W))
nodePosition.Y += MOVEMENT_SPEED * frameDeltaTime;
else if(receiver.IsKeyDown(irr::KEY_KEY_S))
nodePosition.Y -= MOVEMENT_SPEED * frameDeltaTime;
if(receiver.IsKeyDown(irr::KEY_KEY_A))
nodePosition.X -= MOVEMENT_SPEED * frameDeltaTime;
else if(receiver.IsKeyDown(irr::KEY_KEY_D))
nodePosition.X += MOVEMENT_SPEED * frameDeltaTime;
pCameraNode->setPosition(nodePosition);
// UPDATE
const float fTimeToElapseB = (float)0.1f;
if (fTimeElapsedB >= fTimeToElapseB)
{
for (unsigned int iii = 0; iii < g_objects.size(); ++iii)
{
g_objects[iii].update();
scene::ISceneNode * node = g_nodes[iii];
Point3D point = g_objects[iii].getPos();
node->setPosition(core::vector3df(point.X,point.Y,point.Z));
BoundaryCheck(g_objects[iii].getPos());
Collide();
Cube cube;
cube.setFacialData(g_Cells);
measurements.push_back(cube);
// TODO make objects collide
}
fTimeElapsedB = 0.0f;
}
const float fTimeToElapse = (float)g_nUnitSize;
if (fTimeElapsed >= fTimeToElapse)
{
g_objects.clear();
measurements.clear();
MakeObjects();
fTimeElapsed = 0.0f;
ResetCells();
}
driver->beginScene(true, true, SColor(255, 80, 255, 111));
smgr->drawAll();
guienv->drawAll();
driver->endScene();
}
device->drop();
DeInitCells();
return 0;
}
int main()
{
Test();
return 0;
}