// Test that getCollisionPoint() actually uses the closest point, not the closest triangle.
static bool getCollisionPoint_ignoreTriangleVertices(IrrlichtDevice * device,
ISceneManager * smgr,
ISceneCollisionManager * collMgr)
{
// Create a cube with a Z face at 5, but corners close to 0
ISceneNode * farSmallCube = smgr->addCubeSceneNode(10, 0, -1, vector3df(0, 0, 10));
// Create a cube with a Z face at 0, but corners far from 0
ISceneNode * nearBigCube = smgr->addCubeSceneNode(100, 0, -1, vector3df(0, 0, 50));
IMetaTriangleSelector * meta = smgr->createMetaTriangleSelector();
ITriangleSelector * selector = smgr->createTriangleSelectorFromBoundingBox(farSmallCube);
meta->addTriangleSelector(selector);
selector->drop();
// We should expect a hit on this cube
selector = smgr->createTriangleSelectorFromBoundingBox(nearBigCube);
meta->addTriangleSelector(selector);
selector->drop();
line3df ray(0, 0, -5, 0, 0, 100);
vector3df hitPosition;
triangle3df hitTriangle;
ISceneNode* hitNode;
bool collision = collMgr->getCollisionPoint(ray, meta, hitPosition, hitTriangle, hitNode);
meta->drop();
if(hitNode != nearBigCube)
{
logTestString("getCollisionPoint_ignoreTriangleVertices: hit the wrong node.\n");
return false;
}
if(!collision)
{
logTestString("getCollisionPoint_ignoreTriangleVertices: didn't get a hit.\n");
return false;
}
if(hitPosition != vector3df(0, 0, 0))
{
logTestString("getCollisionPoint_ignoreTriangleVertices: unexpected hit position %f %f %f.\n",
hitPosition.X, hitPosition.Y, hitPosition.Z );
return false;
}
smgr->clear();
return true;
}
int main()
{
const int nRobots = 2;
//given robot numbers will be controlled by humans
vector<int> humanBrainIds;
//humanBrainIds.push_back(1);
//humanBrainIds.push_back(0);
//-- device ------------------------------------------------------------//
IrrlichtDevice* device;
device = createDevice(
EDT_OPENGL, //driverType
windowSize,
16, //bits
false,
false, //stencilbuffer
false, //vsync
NULL //receiver
);
//advanced device params
//SIrrlichtCreationParameters params;
//params.DeviceType = EIDT_CONSOLE;
//params.DriverType = EDT_OPENGL;
//params.WindowSize = windowSize;
//device = createDeviceEx(params);
if (device == 0)
return EXIT_FAILURE; // could not create selected driver.
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
//-- lights ------------------------------------------------------------//
//ambient light
//smgr->setAmbientLight( SColorf(1.0f,1.0f,1.0f,1.0f) );
//smgr->setAmbientLight( SColorf(.3f,.3f,.3f,1.0f) );
//diffusive light
SLight light_data;
light_data.AmbientColor = SColorf(.3,.3,.3);
//light_data.Attenuation = vector3df(.3,.3,.3); //Attenuation cte, linear quadratic TODO ??
light_data.DiffuseColor = SColorf(.0,.0,.0);
light_data.SpecularColor = SColorf(.0,.0,.0);
light_data.CastShadows = true;
light_data.Radius = 100.0f;
light_data.Type = ELT_DIRECTIONAL;
//ELT_POINT point light, it has a position in space and radiates light in all directions
//ELT_SPOT spot light, it has a position in space, a direction, and a limited cone of influence
//ELT_DIRECTIONAL directional light, coming from a direction from an infinite distance
ILightSceneNode* light = smgr->addLightSceneNode(0, core::vector3df(.5f,.0f,.5f));
light->setLightData(light_data);
//-- objects ------------------------------------------------------------//
IMesh* mesh;
ISceneNode * node;
float HEIGHT=1000.f, WIDTH=1.f;
//height between center/sky == height bottom/center
//large so that scene looks 2d on interactive test mode.
//on automatic mode, only middle pixel row is taken, so this does not matter
//outter boundary
//square
node = smgr->addCubeSceneNode(
2.f*WIDTH, // width
0, // parent
-1, // id
vector3df(0, 0, 0), // center
vector3df(0, 0, 0), // rotation
vector3df(1.0f, HEIGHT, 1.0f)*-1.f // scale. *-1 turns it inside out. to use both faces make two cubes.
);
//circle
//mesh = smgr->getGeometryCreator()->createCylinderMesh(
//1.f, //radius
//1., //length
//50, //tesselation
//SColor(0,0,0,255), //color
//false, //closeTop
//0.f //oblique
//);
//node = smgr->addMeshSceneNode(
//mesh,
//0, //ISceneNode * parent
//-1, //s32 id
//vector3df(0, -HEIGHT, 0), //const core::vector3df & position
//vector3df(0, 0, 0), //const core::vector3df & rotation
//vector3df(1.0f, 2.f*HEIGHT, 1.0f) //const core::vector3df & scale
//);
node->getMaterial(0).AmbientColor.set(0,0,0,0);
node->getMaterial(0).DiffuseColor.set(0,0,0,0);
//node->getMaterial(0).SpecularColor.set(255,255,255,255);
//node->getMaterial(0).Shininess = 20.0f;
//node->getMaterial(0).EmissiveColor.set(0,0,0,0);
//node->setMaterialFlag(EMF_WIREFRAME,true); //wireframe only
//left cube
node = smgr->addCubeSceneNode(
0.2, // width
0, // parent
-1, // id
vector3df(-.3, 0, 0), // center
vector3df(0, 0, 0), // rotation
vector3df(1.0f, HEIGHT, 1.0f) // scale
);
node->getMaterial(0).AmbientColor.set(0,255,0,0);
node->getMaterial(0).DiffuseColor.set(0,255,0,0);
//right cube
node = smgr->addCubeSceneNode(
.2f, // width
0, // parent
-1, // id
vector3df(.3, 0, 0), // center
vector3df(0, 0, 0), // rotation
vector3df(1.0f, HEIGHT, 1.0f) // scale
);
node->getMaterial(0).AmbientColor.set(0,0,255,0);
node->getMaterial(0).DiffuseColor.set(0,0,255,0);
//cylinder
//mesh = smgr->getGeometryCreator()->createCylinderMesh(
//.1f, //radius
//1., //length
//50, //tesselation
//SColor(), //color
//false, //closeTop
//0.f //oblique
//);
//node = smgr->addMeshSceneNode(
//mesh,
//0, //ISceneNode * parent
//-1, //s32 id
//vector3df(0, -HEIGHT, 0), //const core::vector3df & position
//vector3df(0, 0, 0), //const core::vector3df & rotation
//vector3df(1.0f, 2.*HEIGHT, 1.0f) //const core::vector3df & scale
//);
//node->getMaterial(0).AmbientColor.set(0,0,0,255);
//node->getMaterial(0).DiffuseColor.set(0,0,0,255);
//sphere
//node = smgr->addSphereSceneNode(
//0.1, // radius
//50, // poly count
//0, // parent
//FruitID, // id
//vector3df(0, 0, 0), // center
//vector3df(0, 0, 0), // rotation
//vector3df(1.0f, 1.0f, 1.0f) // scale
//);
//node->getMaterial(0).AmbientColor.set(0,0,0,255);
//node->getMaterial(0).DiffuseColor.set(0,0,0,255);
//node->getMaterial(0).Lighting = true;
//-- collision ------------------------------------------------------------//
/* Put everything we want to do collision checking with inside the meta selector. */
IMetaTriangleSelector * meta = smgr->createMetaTriangleSelector();
array<ISceneNode *> nodes;
smgr->getSceneNodesFromType(ESNT_ANY, nodes); // Find all nodes
for (u32 i=0; i < nodes.size(); ++i)
{
ISceneNode * node = nodes[i];
ITriangleSelector * selector = 0;
switch(node->getType())
{
case ESNT_CUBE:
case ESNT_ANIMATED_MESH:
// Because the selector won't animate with the mesh,
// and is only being used for camera collision, we'll just use an approximate
// bounding box instead of ((IAnimatedMeshSceneNode*)node)->getMesh(0)
selector = smgr->createTriangleSelectorFromBoundingBox(node);
break;
case ESNT_MESH:
case ESNT_SPHERE: // Derived from IMeshSceneNode
selector = smgr->createTriangleSelector(((IMeshSceneNode*)node)->getMesh(), node);
break;
case ESNT_TERRAIN:
selector = smgr->createTerrainTriangleSelector((ITerrainSceneNode*)node);
break;
case ESNT_OCTREE:
selector = smgr->createOctreeTriangleSelector(((IMeshSceneNode*)node)->getMesh(), node);
break;
default:
// Don't create a selector for this node type
break;
}
if(selector)
{
// Add it to the meta selector, which will take a reference to it
meta->addTriangleSelector(selector);
// And drop my reference to it, so that the meta selector owns it.
selector->drop();
}
}
//-- robots ------------------------------------------------------------//
//create robots
Fly2D::Brain* brains[nRobots];
//all to a default type
//for ( int i=0; i<nRobots; i++ )
//{
//brains[i] = new Fly2D::BrainForward;
////brains[i] = new Fly2D::BrainCircle();
//}
brains[0] = new Fly2D::BrainForward;
brains[1] = new Fly2D::BrainForward;
//decide human control
vector<Fly2D::BrainHuman*> hBrains;
for (
vector<int>::iterator i = humanBrainIds.begin();
i != humanBrainIds.end();
++i
)
{
if ( *i > nRobots )
{
cerr << "no such robot: " << *i << endl;
exit(EXIT_FAILURE);
}
delete brains[*i];
Fly2D::BrainHuman* hBrain = new Fly2D::BrainHuman;
brains[*i] = hBrain;
hBrains.push_back(hBrain);
}
Fly2D::ReceiverHuman hReceiver = Fly2D::ReceiverHuman( hBrains );
device->setEventReceiver( &hReceiver );
Robot* robots[nRobots];
robots[0] = new Fly2D::Robot( *device, *meta, *brains[0], vector3df(0,0,-0.5f), vector3df(0,0, 0.5f), 0.01 );
robots[1] = new Fly2D::Robot( *device, *meta, *brains[1], vector3df(0,0,0.5f), vector3df(0,0, -0.5f), 0.01 );
meta->drop(); // As soon as we're done with the selector, drop it.
//-- run ------------------------------------------------------------//
//TEST
vector3df oldpos, oldtarget;
//END TEST
int nFrames = 0;
ITimer* timer = device->getTimer();
int t0 = timer->getTime();
int w = driver->getScreenSize().Width;
int h = driver->getScreenSize().Height;
int dh = h/nRobots;
int observeRobot = 0;
while(device->run())
{
//if (device->isWindowActive()) //only work if window has focus.
//draw
driver->setViewPort(rect<s32>(0,0,w,h));
driver->beginScene(true,true,0);
for(int i=0; i<nRobots; i++)
{
driver->setViewPort(rect<s32>(0,dh*i,w,dh*(i+1)));
//only part of window gets drawn into
smgr->setActiveCamera(robots[i]->camera);
smgr->drawAll();
//draws on window scene of active camera
robots[i]->update();
}
driver->endScene();
//TEST
//if
//(
//robots[observeRobot].getPosition() != oldpos
//|| robots[observeRobot].getTarget() != oldtarget
//)
//oldpos = robots[observeRobot].getPosition();
//oldtarget = robots[observeRobot].getTarget();
cout << robots[observeRobot]->str();
//FPS info
//cout << "frame no:" << endl << nFrames << endl;;
//cout << "average fps:" << endl << 1000*nFrames/(float)(timer->getTime()-t0) << endl;
//nFrames++;
cout << "fps:" << endl << driver->getFPS() << endl;
//END TEST
}
device->drop();
return 0;
}
