int main()
{
	MyEventReceiver receiver;

    IrrlichtDevice* device = createDevice(video::EDT_OPENGL,
            core::dimension2d<u32>(640, 480), 16, false, false, false, &receiver);
	IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();
	smgr->addLightSceneNode(0,vector3df(50,50,50));
	ICameraSceneNode *camera = smgr->addCameraSceneNode();

	IMeshSceneNode *node = smgr->addCubeSceneNode();
	
	node->setPosition(vector3df(0,75,0));

	camera->setTarget(vector3df(0,1,0));

	
	smgr->getMeshManipulator()->setVertexColors(node->getMesh(), SColor(0,0,255,255));
	smgr->addLightSceneNode();

	while(device->run()){

		if(receiver.IsKeyDown(irr::KEY_LEFT)){
			node->setPosition(node->getPosition()+vector3df(0,0,-0.1));
		}
		else if(receiver.IsKeyDown(irr::KEY_RIGHT)){
			node->setPosition(node->getPosition()+vector3df(0,0,0.1));
		}
		else if(receiver.IsKeyDown(irr::KEY_SPACE)){
			
		}
		driver->beginScene(true, true, SColor(123,100,100,100));
        smgr->drawAll();
		driver->endScene();
	}



	return 0;
}

int main()
{
	
	srand(time(NULL));
	int numPlayers = 4;

	//Setup irrlicht
	MyEventReceiver Receiver;
	IrrlichtDevice *device = createDevice(EDT_OPENGL,dimension2d<u32>(SCREENX,SCREENY),32,FULLSCREEN,false,false,&Receiver);
	IVideoDriver* driver = device->getVideoDriver();
	ISceneManager* smgr = device->getSceneManager();
	IGUIEnvironment* guienv = device->getGUIEnvironment();

	//Load key config
	Receiver.KeyConfig.loadFromFile("KeyConfig.txt");

	//Generate maze
	MazeGenerator MG;
	/*
	MG.NewSize(495,497,495,497);
	MG.Generate("DrunkenWalk2",500,numPlayers);//500,numPlayers);
	MG.Minimise();
	MG.MinimalSolids(false);

	MG.ConvertLoneToCover();*/


	MG.MapFromFile("Maps/01g.txt", "Maps/01m.txt", "Maps/01e.txt");
	vector<int> PlayerStartPos;
	PlayerStartPos.push_back(10);
	PlayerStartPos.push_back(11);
	PlayerStartPos.push_back(12);
	PlayerStartPos.push_back(13);
	MG.ParseForPlayerStartPositions(PlayerStartPos);

	//Setup textures
	ITexture *FloorTexture = driver->getTexture("Textures/Floor.png");
	ITexture *WallTexture = driver->getTexture("Textures/Wall.png");
	ITexture *CoverTexture = driver->getTexture("Textures/Cover.png");

	//Import maze
	MazeRenderer MR;
	MR.CreateFromMazeGenerator( MG, smgr );
	MR.SetTextures( FloorTexture, WallTexture, CoverTexture );

	//Setup camera
	GameCamera gameCam(70);
	gameCam.camera = smgr->addCameraSceneNode();
	gameCam.camera->setPosition( vector3df( (MR.XSize/2)*MR.TileSize, 40, (MR.YSize/2)*MR.TileSize ) );
	gameCam.camera->setRotation( vector3df(0,90,90));

	//Create players (4) for testing
	//Have to use an array as you can't copy boost::threads which pushing into vectors does
	

	EntityManager PlayerManager(numPlayers);

	//Textures
	ITexture* PlayerTexture[4];
	PlayerTexture[0] = driver->getTexture("Textures/Player1.png");
	PlayerTexture[1] = driver->getTexture("Textures/Player2.png");
	PlayerTexture[2] = driver->getTexture("Textures/Player3.png");
	PlayerTexture[3] = driver->getTexture("Textures/Player4.png");

	//Names
	vector<std::string> PlayerName;
	PlayerName.push_back("Motoko");
	PlayerName.push_back("Saito");
	PlayerName.push_back("Batou");
	PlayerName.push_back("Togusa");

	//use this method to get starting cells for an enemy group
	vector<v2d> vv = GetFreeCells(MG.Convert(),MG.StartX,MG.StartY,4);
	
	//HUD test
	hud HUD(guienv,dimension2d<s32>(SCREENX,SCREENY),"Font\\myfont.xml");

	for (int i = 0; i < numPlayers; i++ )
	{
		PlayerManager.GetEntity(i)->Construct(smgr,MG.Convert(), PlayerTexture[i]);
		PlayerManager.GetEntity(i)->Stats.Name = PlayerName[i];
		PlayerManager.GetEntity(i)->Stats.MaxHealth = 100;
		PlayerManager.GetEntity(i)->Stats.RestoreAll();
		PlayerManager.GetEntity(i)->X = MG.XStarts[i];
		PlayerManager.GetEntity(i)->Y = MG.YStarts[i];
		PlayerManager.GetEntity(i)->Stats.MovementSteps = 5+i;
		PlayerManager.GetEntity(i)->ReachableTile = driver->getTexture("Textures/TurnReachable.png");
		PlayerManager.GetEntity(i)->UnreachableTile = driver->getTexture("Textures/TurnUnreachable.png");
		PlayerManager.GetEntity(i)->Stats.RealFiringDistance = 100;
		PlayerManager.GetEntity(i)->CellShootable = driver->getTexture("Textures/CellShootable.png");
		PlayerManager.GetEntity(i)->CellShootableCover = driver->getTexture("Textures/CellShootableCover.png");
		PlayerManager.GetEntity(i)->Position();
		path filename = "Avatars/";
		filename.append(PlayerName[i].c_str());
		filename.append(".png");
		PlayerManager.GetEntity(i)->Avatar = driver->getTexture( filename );

		//test stats
		PlayerManager.GetEntity(i)->Stats.Accuracy = 100;
		PlayerManager.GetEntity(i)->Stats.Attack = 100;
//.........这里部分代码省略.........

/*
The event receiver for keeping the pressed keys is ready, the actual responses
will be made inside the render loop, right before drawing the scene. So lets
just create an irr::IrrlichtDevice and the scene node we want to move. We also
create some other additional scene nodes, to show that there are also some
different possibilities to move and animate scene nodes.
*/
int main()
{
	// ask user for driver
	video::E_DRIVER_TYPE driverType=driverChoiceConsole();
	if (driverType==video::EDT_COUNT)
		return 1;

	// create device
	MyEventReceiver receiver;

	IrrlichtDevice* device = createDevice(driverType,
			core::dimension2d<u32>(640, 480), 16, false, false, false, &receiver);

	if (device == 0)
		return 1; // could not create selected driver.

	video::IVideoDriver* driver = device->getVideoDriver();
	scene::ISceneManager* smgr = device->getSceneManager();

	const io::path mediaPath = getExampleMediaPath();

	/*
	Create the node which will be moved with the WSAD keys. We create a
	sphere node, which is a built-in geometry primitive. We place the node
	at (0,0,30) and assign a texture to it to let it look a little bit more
	interesting. Because we have no dynamic lights in this scene we disable
	lighting for each model (otherwise the models would be black).
	*/
	scene::ISceneNode * node = smgr->addSphereSceneNode();
	if (node)
	{
		node->setPosition(core::vector3df(0,0,30));
		node->setMaterialTexture(0, driver->getTexture(mediaPath + "wall.bmp"));
		node->setMaterialFlag(video::EMF_LIGHTING, false);
	}

	/*
	Now we create another node, movable using a scene node animator. Scene
	node animators modify scene nodes and can be attached to any scene node
	like mesh scene nodes, billboards, lights and even camera scene nodes.
	Scene node animators are not only able to modify the position of a
	scene node, they can also animate the textures of an object for
	example. We create a cube scene node and attach a 'fly circle' scene
	node animator to it, letting this node fly around our sphere scene node.
	*/
	scene::ISceneNode* n = smgr->addCubeSceneNode();

	if (n)
	{
		n->setMaterialTexture(0, driver->getTexture(mediaPath + "t351sml.jpg"));
		n->setMaterialFlag(video::EMF_LIGHTING, false);
		scene::ISceneNodeAnimator* anim =
			smgr->createFlyCircleAnimator(core::vector3df(0,0,30), 20.0f);
		if (anim)
		{
			n->addAnimator(anim);
			anim->drop();
		}
	}

	/*
	The last scene node we add to show possibilities of scene node animators is
	a b3d model, which uses a 'fly straight' animator to run between to points.
	*/
	scene::IAnimatedMeshSceneNode* anms =
		smgr->addAnimatedMeshSceneNode(smgr->getMesh(mediaPath + "ninja.b3d"));

	if (anms)
	{
		scene::ISceneNodeAnimator* anim =
			smgr->createFlyStraightAnimator(core::vector3df(100,0,60),
			core::vector3df(-100,0,60), 3500, true);
		if (anim)
		{
			anms->addAnimator(anim);
			anim->drop();
		}

		/*
		To make the model look right we disable lighting, set the
		frames between which the animation should loop, rotate the
		model around 180 degrees, and adjust the animation speed and
		the texture. To set the right animation (frames and speed), we
		would also be able to just call
		"anms->setMD2Animation(scene::EMAT_RUN)" for the 'run'
		animation instead of "setFrameLoop" and "setAnimationSpeed",
		but this only works with MD2 animations, and so you know how to
		start other animations. But a good advice is to not use
		hardcoded frame-numbers...
		*/
		anms->setMaterialFlag(video::EMF_LIGHTING, false);

		anms->setFrameLoop(0, 13);
//.........这里部分代码省略.........

/*
The event receiver for keeping the pressed keys is ready, the actual responses
will be made inside the render loop, right before drawing the scene. So lets
just create an irr::IrrlichtDevice and the scene node we want to move. We also
create some other additional scene nodes, to show that there are also some
different possibilities to move and animate scene nodes.
*/
int main()
{
    // ask user for driver
    video::E_DRIVER_TYPE driverType=driverChoiceConsole();
    if (driverType==video::EDT_COUNT)
        return 1;

    // create device
    MyEventReceiver receiver;

    IrrlichtDevice* device = createDevice(driverType,
            core::dimension2d<u32>(1280, 800), 16, false, false, false, &receiver);

    if (device == 0)
        return 1; // could not create selected driver.

    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();

    /*
    Create the node which will be moved with the WSAD keys. We create a
    sphere node, which is a built-in geometry primitive. We place the node
    at (0,0,30) and assign a texture to it to let it look a little bit more
    interesting. Because we have no dynamic lights in this scene we disable
    lighting for each model (otherwise the models would be black).
    */
    scene::ISceneNode * node = smgr->addSphereSceneNode(EARTH_RADIUS, 36);
    if (node)
    {
        node->setPosition(core::vector3df(0,0,30));
#ifdef _MSC_VER
        node->setMaterialTexture(0, driver->getTexture("../../../src/vendor/irrlicht/media/wall.bmp"));
#else
        node->setMaterialTexture(0, driver->getTexture("../../src/vendor/irrlicht/media/wall.bmp"));
#endif
        node->setMaterialFlag(video::EMF_LIGHTING, false);
    }

    /*
    To be able to look at and move around in this scene, we create a first
    person shooter style camera and make the mouse cursor invisible.
    */
        scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
        camera->setPosition(core::vector3df(0, 0, -EARTH_RADIUS * START_DISTANCE));
        camera->setTarget(core::vector3df(0, 0, 0));

        const f32 ONE_AU = 149597870.0f;
#if(0)
        camera->setFarValue(ONE_AU);
#else
        camera->setFarValue(2<<23);
#endif

    device->getCursorControl()->setVisible(false);

    /*
    We have done everything, so lets draw it. We also write the current
    frames per second and the name of the driver to the caption of the
    window.
    */
    int lastFPS = -1;

    // In order to do framerate independent movement, we have to know
    // how long it was since the last frame
    u32 then = device->getTimer()->getTime();

    // This is the movemen speed in units per second.
//#if(1)
    const f32 MOVEMENT_SPEED = .5f;
//#else
    //const f32 MOVEMENT_SPEED = EARTH_RADIUS;
//#endif

    Skybox skybox(smgr, driver);

    while(device->run())
    {
        // Work out a frame delta time.
        const u32 now = device->getTimer()->getTime();
        const f32 frameDeltaTime = (f32)(now - then) / 1000.f; // Time in seconds
        then = now;

        /* Check if keys W, S, A or D are being held down, and move the
        sphere node around respectively. */
        core::vector3df nodePosition = node->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;
//.........这里部分代码省略.........

int main(int argc, char* argv[])
{
	// ask user for driver
	video::E_DRIVER_TYPE driverType=driverChoiceConsole();
	if (driverType==video::EDT_COUNT)
		return 1;

	MyEventReceiver receiver;
	IrrlichtDevice* device = createDevice(driverType,
			core::dimension2du(800, 600), 32, false, false, false,
			&receiver);

	if(device == 0)
		return 1;

	IVideoDriver *driver = device->getVideoDriver();
	ISceneManager *smgr = device->getSceneManager();
	device->setWindowCaption(L"Irrlicht Example for SMesh usage.");

	/*
	Create the custom mesh and initialize with a heightmap
	*/
	TMesh mesh;
	HeightMap hm = HeightMap(255, 255);
	hm.generate(eggbox);
	mesh.init(hm, 50.f, grey, driver);

	// Add the mesh to the scene graph
	IMeshSceneNode* meshnode = smgr -> addMeshSceneNode(mesh.Mesh);
	meshnode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);

	// light is just for nice effects
	ILightSceneNode *node = smgr->addLightSceneNode(0, vector3df(0,100,0),
		SColorf(1.0f, 0.6f, 0.7f, 1.0f), 500.0f);
	if (node)
	{
		node->getLightData().Attenuation.set(0.f, 1.f/500.f, 0.f);
		ISceneNodeAnimator* anim = smgr->createFlyCircleAnimator(vector3df(0,150,0),250.0f);
		if (anim)
		{
			node->addAnimator(anim);
			anim->drop();
		}
	}

	ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
	if (camera)
	{
		camera->setPosition(vector3df(-20.f, 150.f, -20.f));
		camera->setTarget(vector3df(200.f, -80.f, 150.f));
		camera->setFarValue(20000.0f);
	}

	/*
	Just a usual render loop with event handling. The custom mesh is
	a usual part of the scene graph which gets rendered by drawAll.
	*/
	while(device->run())
	{
		if(!device->isWindowActive())
		{
			device->sleep(100);
			continue;
		}

		if(receiver.IsKeyDown(irr::KEY_KEY_W))
		{
			meshnode->setMaterialFlag(video::EMF_WIREFRAME, !meshnode->getMaterial(0).Wireframe);
		}
		else if(receiver.IsKeyDown(irr::KEY_KEY_1))
		{
			hm.generate(eggbox);
			mesh.init(hm, 50.f, grey, driver);
		}
		else if(receiver.IsKeyDown(irr::KEY_KEY_2))
		{
			hm.generate(moresine);
			mesh.init(hm, 50.f, yellow, driver);
		}
		else if(receiver.IsKeyDown(irr::KEY_KEY_3))
		{
			hm.generate(justexp);
			mesh.init(hm, 50.f, yellow, driver);
		}

		driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, SColor(0xff000000));
		smgr->drawAll();
		driver->endScene();
	}

	device->drop();

	return 0;
}

/*
We create an irr::IrrlichtDevice and the scene nodes. One occluder, one
occluded. The latter is a complex sphere, which has many triangles.
*/
int main()
{
	// ask user for driver
	video::E_DRIVER_TYPE driverType=driverChoiceConsole();
	if (driverType==video::EDT_COUNT)
		return 1;

	// create device
	MyEventReceiver receiver;

	IrrlichtDevice* device = createDevice(driverType,
			core::dimension2d<u32>(640, 480), 16, false, false, false, &receiver);

	if (device == 0)
		return 1; // could not create selected driver.

	video::IVideoDriver* driver = device->getVideoDriver();
	scene::ISceneManager* smgr = device->getSceneManager();

	const io::path mediaPath = getExampleMediaPath();

	smgr->getGUIEnvironment()->addStaticText(L"Press Space to hide occluder.", core::recti(10,10, 200,50));

	/*
	Create the node to be occluded. We create a sphere node with high poly count.
	*/
	scene::ISceneNode * node = smgr->addSphereSceneNode(10, 64);
	if (node)
	{
		node->setPosition(core::vector3df(0,0,60));
		node->setMaterialTexture(0, driver->getTexture(mediaPath + "wall.bmp"));
		node->setMaterialFlag(video::EMF_LIGHTING, false);
	}

	/*
	Now we create another node, the occluder. It's a simple plane.
	*/
	scene::ISceneNode* plane = smgr->addMeshSceneNode(smgr->addHillPlaneMesh(
		"plane", core::dimension2df(10,10), core::dimension2du(2,2)), 0, -1,
		core::vector3df(0,0,20), core::vector3df(270,0,0));

	if (plane)
	{
		plane->setMaterialTexture(0, driver->getTexture(mediaPath + "t351sml.jpg"));
		plane->setMaterialFlag(video::EMF_LIGHTING, false);
		plane->setMaterialFlag(video::EMF_BACK_FACE_CULLING, true);
	}

	/*
	Here we create the occlusion query. Because we don't have a plain mesh scene node
	(ESNT_MESH or ESNT_ANIMATED_MESH), we pass the base geometry as well. Instead,
	we could also pass a simpler mesh or the bounding box. But we will use a time
	based method, where the occlusion query renders to the frame buffer and in case
	of success (occlusion), the mesh is not drawn for several frames.
	*/
	driver->addOcclusionQuery(node, ((scene::IMeshSceneNode*)node)->getMesh());

	/*
	We have done everything, just a camera and draw it. We also write the
	current frames per second and the name of the driver to the caption of the
	window to examine the render speedup.
	We also store the time for measuring the time since the last occlusion query ran
	and store whether the node should be visible in the next frames.
	*/
	smgr->addCameraSceneNode();
	int lastFPS = -1;
	u32 timeNow = device->getTimer()->getTime();
	bool nodeVisible=true;

	while(device->run())
	{
		plane->setVisible(!receiver.IsKeyDown(irr::KEY_SPACE));

		driver->beginScene(video::ECBF_COLOR | video::ECBF_DEPTH, video::SColor(255,113,113,133));
		/*
		First, we draw the scene, possibly without the occluded element. This is necessary
		because we need the occluder to be drawn first. You can also use several scene
		managers to collect a number of possible occluders in a separately rendered
		scene.
		*/
		node->setVisible(nodeVisible);
		smgr->drawAll();
		smgr->getGUIEnvironment()->drawAll();

		/*
		Once in a while, here every 100 ms, we check the visibility. We run the queries,
		update the pixel value, and query the result. Since we already rendered the node
		we render the query invisible. The update is made blocking, as we need the result
		immediately. If you don't need the result immediately, e.g. because you have other
		things to render, you can call the update non-blocking. This gives the GPU more
		time to pass back the results without flushing the render pipeline.
		If the update was called non-blocking, the result from getOcclusionQueryResult is
		either the previous value, or 0xffffffff if no value has been generated at all, yet.
		The result is taken immediately as visibility flag for the node.
		*/
		if (device->getTimer()->getTime()-timeNow>100)
//.........这里部分代码省略.........

int main()
{
	sockets_init();
	atexit(sockets_cleanup);

	/*
		Run unit tests
	*/
	if(ENABLE_TESTS)
		run_tests();
	
	//return 0; //DEBUG
		
	/*
		Initialization
	*/

	srand(time(0));

	g_viewing_range_nodes_mutex.Init();
	assert(g_viewing_range_nodes_mutex.IsInitialized());

	MyEventReceiver receiver;

	// create device and exit if creation failed

	/*
		Host selection
	*/
	char connect_name[100];
	std::cout<<std::endl<<std::endl;
	std::cout<<"Address to connect to [empty = host a game]: ";
	std::cin.getline(connect_name, 100);
	
	bool hosting = false;
	if(connect_name[0] == 0){
		snprintf(connect_name, 100, "127.0.0.1");
		hosting = true;
	}
	std::cout<<"-> "<<connect_name<<std::endl;
	
	std::cout<<"Port [empty=30000]: ";
	char templine[100];
	std::cin.getline(templine, 100);
	unsigned short port;
	if(templine[0] == 0)
		port = 30000;
	else
		port = atoi(templine);

	/*
		Resolution selection
	*/

	u16 screenW = 800;
	u16 screenH = 600;

	/*
	u16 resolutions[][2] = {
		{640,480},
		{800,600},
		{1024,768},
		{1280,1024}
	};

	u16 res_count = sizeof(resolutions)/sizeof(resolutions[0]);
	
	std::cout<<"Select window resolution "
			<<"(type a number and press enter):"<<std::endl;
	for(u16 i=0; i<res_count; i++)
	{
		std::cout<<(i+1)<<": "<<resolutions[i][0]<<"x"
				<<resolutions[i][1]<<std::endl;
	}
	u16 r0;
	std::cin>>r0;
	if(r0 > res_count || r0 == 0)
		r0 = 0;
	u16 screenW = resolutions[r0-1][0];
	u16 screenH = resolutions[r0-1][1];
	*/

	//

	video::E_DRIVER_TYPE driverType;

#ifdef _WIN32
	//driverType = video::EDT_DIRECT3D9; // Doesn't seem to work
	driverType = video::EDT_OPENGL;
#else
	driverType = video::EDT_OPENGL;
#endif

	IrrlichtDevice *device;
	device = createDevice(driverType,
			core::dimension2d<u32>(screenW, screenH),
			16, false, false, false, &receiver);

	if (device == 0)
		return 1; // could not create selected driver.
//.........这里部分代码省略.........

/*
   Now ask for the driver and create the Windows specific window.
*/
int main()
{
/*
	{
		int vertIndex = 0;
		for( int Row=0; Row<=16*8; Row++ )
		{
			GuidVertex[vertIndex].x = 0;
			GuidVertex[vertIndex].y = 0;
			GuidVertex[vertIndex].z = Row * 2.0f;
		
			GuidVertex[vertIndex].VertexColor[0] = (Row == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[1] = (Row == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[2] = (Row == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[3] = 1.0f;
			vertIndex++;

			GuidVertex[vertIndex].x = 2*8*16;
			GuidVertex[vertIndex].y = 0;
			GuidVertex[vertIndex].z = Row * 2.0f;
		
			GuidVertex[vertIndex].VertexColor[0] = (Row == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[1] = (Row == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[2] = (Row == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[3] = 1.0f;
			vertIndex++;
		}

		for( int Col=0; Col<=16*8; Col++ )
		{
			GuidVertex[vertIndex].x = Col * 2.0f;
			GuidVertex[vertIndex].y = 0;
			GuidVertex[vertIndex].z = 0;
		
			GuidVertex[vertIndex].VertexColor[0] = (Col == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[1] = (Col == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[2] = (Col == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[3] = 1.0f;
			vertIndex++;

			GuidVertex[vertIndex].x = Col * 2.0f;
			GuidVertex[vertIndex].y = 0;
			GuidVertex[vertIndex].z = 2*8*16;
		
			GuidVertex[vertIndex].VertexColor[0] = (Col == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[1] = (Col == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[2] = (Col == 0) ? 0 : 0.588f;
			GuidVertex[vertIndex].VertexColor[3] = 1.0f;
			vertIndex++;
		}
	}
*/



	// create log
	ConsoleLogger logger( String("Hello World") );
	logger.setLogLevel( ELL_DEBUG );
	Logger::setCurrentLogger( &logger );

	// create device
	MyEventReceiver receiver;

	SGPDevice* device = createDevice(
		SGPDT_OPENGL,
		1024, 768, 32, 
		false, false, false,
		true,
		&logger,
		&receiver);

	// could not create selected driver.
	if (device == NULL)
	{
		Logger::setCurrentLogger(nullptr);
		return 1;
	}

	device->setResizable(true);

	ISGPRenderDevice* renderdevice = device->getRenderDevice();
	Random* globalrandom = device->getRandomizer();

	// could not get render driver or globalrandom.
	if (!renderdevice || !globalrandom)
	{
		Logger::setCurrentLogger(nullptr);
		return 1;
	}

	// Setting Working Dir
	String WorkingDir = File::getSpecialLocation(File::currentExecutableFile).getParentDirectory().getParentDirectory().getParentDirectory().getFullPathName();
	WorkingDir = WorkingDir + File::separatorString + String("Data");
	renderdevice->setWorkingDirection(WorkingDir);


	// Camera
//.........这里部分代码省略.........

int main(int argc, char **argv) {

	// Help?
	if (argv[1] && argv[1][0] == '-') die(helpmsg);

	putenv((char *) "vblank_mode=0"); // No vsync for us, thanks.

	MyEventReceiver *r = new MyEventReceiver();
	IrrlichtDevice *dev = createDevice(EDT_OPENGL, core::dimension2d<u32>(1024,768), 32,
				false, false, false, r);
	if (!dev) die("Can't initialize Irrlicht");

	IVideoDriver *drv = dev->getVideoDriver();
	ISceneManager *smgr = dev->getSceneManager();
	IGPUProgrammingServices *gpu = drv->getGPUProgrammingServices();
	ICameraSceneNode *cam = NULL;
	ITexture *pic = NULL;
	IMeshSceneNode *ball = NULL;
	bool showpic = false;

	IReadFile *areamap = createMemoryReadFile(AreaMap33, sizeof(AreaMap33), "AreaMap33", false);
	if (!areamap) die("Failed to load areamap");
	ITexture *areamaptex = drv->getTexture(areamap);
	areamap->drop();

	// If there's an argument, assume it is a pic to load; otherwise, draw a sphere

	if (argv[1] && access(argv[1], R_OK) == 0) {
		showpic = true;
		pic = drv->getTexture(argv[1]);
		if (!pic) die("Can't load image");

		cam = smgr->addCameraSceneNode();
	} else {
		cam = smgr->addCameraSceneNodeMaya();
		cam->setTarget(vector3df(0, 0, 0));
		ball = smgr->addSphereSceneNode(40, 8);

		int ballshader = gpu->addHighLevelShaderMaterial(rnd,0,EVST_VS_1_1,0);
		ball->setMaterialType((E_MATERIAL_TYPE) ballshader);

		ISceneNodeAnimator *cool = smgr->createRotationAnimator(vector3df(-0.1, 0.1, -0.1));
		ball->addAnimator(cool);
		cool->drop();
	}

	// Set up static defines, RTTs, quads
	dimension2d<u32> screensize = drv->getScreenSize();
	char defines[128];
	snprintf(defines, 128,
		"#define PIXEL_SIZE vec2(1.0f / %u.0, 1.0f / %u.0)\n"
		"#define MAX_SEARCH_STEPS 8.0\n#define MAX_DISTANCE 33.0\n",
		screensize.Width, screensize.Height);

	ITexture *rt1 = drv->addRenderTargetTexture(screensize, "rt1", ECF_A8R8G8B8);
	ITexture *rt2 = drv->addRenderTargetTexture(screensize, "rt2", ECF_A8R8G8B8);
	ITexture *rt3 = drv->addRenderTargetTexture(screensize, "rt3", ECF_A8R8G8B8);
	if (!rt1 || !rt2 || !rt3) die("No RTT");

	ScreenQuad *def = new ScreenQuad(drv);
	ScreenQuad *sq = new ScreenQuad(drv);
	ScreenQuad *sq2 = new ScreenQuad(drv);
	ScreenQuad *sq3 = new ScreenQuad(drv);
	ScreenQuad *norm = new ScreenQuad(drv);
	if (showpic) def->SetTexture(pic);
	sq->SetTexture(rt1);
	sq->GetMaterial().setFlag(EMF_BILINEAR_FILTER, false);
	norm->SetTexture(rt1);
	norm->GetMaterial().setFlag(EMF_BILINEAR_FILTER, false);

	sq2->SetTexture(rt2);
	sq2->SetTexture(rt2, 1);
	sq2->SetTexture(areamaptex, 2);
	sq2->GetMaterial().TextureLayer[2].BilinearFilter = false;

	sq3->SetTexture(rt3);
	sq3->GetMaterial().setFlag(EMF_BILINEAR_FILTER, false);
	sq3->SetTexture(rt1,1);
	state_t state = MLAA_OFF;

	stringc tmp1, tmp2;
	tmp1 = defines;
	tmp1 += offsetvs;
	tmp2 = defines;
	tmp2 += color1fs;

	// Load shaders
	int edge = gpu->addHighLevelShaderMaterial(tmp1.c_str(),0,EVST_VS_1_1,tmp2.c_str());
	sq->SetMaterialType((E_MATERIAL_TYPE) edge);

	tmp2 = defines;
	tmp2 += blend2fs;

	blendcb *bcb = new blendcb();
	edge = gpu->addHighLevelShaderMaterial(tmp1.c_str(),0,EVST_VS_1_1,tmp2.c_str(),0,EPST_PS_1_1,bcb);
	sq2->SetMaterialType((E_MATERIAL_TYPE) edge);

	tmp2 = defines;
	tmp2 += neigh3fs;

//.........这里部分代码省略.........

int main()
{

    MyEventReceiver receiver;

    IrrlichtDevice *device =
        createDevice( video::EDT_OPENGL, dimension2d<u32>(1280, 800), 16,
        false, false, false, &receiver);

    if (!device)
        return 1;

    IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();
    IGUIEnvironment* guienv = device->getGUIEnvironment();

    scene::ISceneNode* o = smgr->addSphereSceneNode(20);
    //o->setMaterialFlag(video::EMF_LIGHTING, false);
    o->setPosition(core::vector3df(0,0,0));
    SMaterial &m = o->getMaterial(0);
    m.EmissiveColor = SColor(255, 255, 0, 0);


    vector3df sssPos(0, 60, 0);

    scene::ISceneNode* sss = smgr->addCubeSceneNode(30);
    sss->setMaterialFlag(video::EMF_LIGHTING, true);
    //sss->setMaterialTexture(0, driver->getTexture("wall.bmp"));
    sss->setPosition(sssPos);
    SMaterial &sssm = sss->getMaterial(0);
    sssm.EmissiveColor = SColor(100, 255, 255, 255);


    scene::ISceneNode*  hp = smgr->addSphereSceneNode(10);
    SMaterial &hpm = hp->getMaterial(0);
    hpm.EmissiveColor = SColor(255, 0, 0, 255);
    scene::ISceneNode*  hd = smgr->addSphereSceneNode(10);
    SMaterial &hdm = hd->getMaterial(0);
    hdm.EmissiveColor = SColor(255, 0, 0, 100);


    scene::ISceneNode* node[10];
    for (int i = 0; i < 10; ++i)
    {
        node[i] = smgr->addSphereSceneNode(5);
        //node[i]->setMaterialFlag(video::EMF_LIGHTING, false);
        node[i]->setVisible(false);
        SMaterial &m = node[i]->getMaterial(0);
        m.EmissiveColor = SColor(255, 255, 0, 0);
    }

    scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS();

    vector3df camPos(0,0,200);
    vector3df camshift(0,0,0);

    cam->setPosition(camPos);
    cam->setTarget(core::vector3df(0,0,0));

    u32 then = device->getTimer()->getTime();
    const f32 MOVEMENT_SPEED = 50.f;



    irr::video::S3DVertex m_cPlaneVertices[4];
    irr::u16 m_iPlaneIndices[6];

    m_cPlaneVertices[0] = irr::video::S3DVertex(-100.0f, -100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 0.0f, 0.0f);
    m_cPlaneVertices[1] = irr::video::S3DVertex(-100.0f,  100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 0.0f, 1.0f);
    m_cPlaneVertices[2] = irr::video::S3DVertex( 100.0f,  100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 1.0f, 1.0f);
    m_cPlaneVertices[3] = irr::video::S3DVertex( 100.0f, -100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 1.0f, 0.0f);

    m_iPlaneIndices[0] = 0;
    m_iPlaneIndices[1] = 2;
    m_iPlaneIndices[2] = 1;
    m_iPlaneIndices[3] = 0;
    m_iPlaneIndices[4] = 3;
    m_iPlaneIndices[5] = 2;


    SMaterial m_cRenderMaterial;
    m_cRenderMaterial.Wireframe = false;
    m_cRenderMaterial.Lighting = false;
    m_cRenderMaterial.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP;
    m_cRenderMaterial.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP;
    
    ITexture      *m_pRenderTexture = 0;

    CvCapture *capture;
    IplImage *frame;
    char AviFileName[]="Accel World.mp4";
    capture = cvCaptureFromAVI(AviFileName);

    if (driver->queryFeature(irr::video::EVDF_RENDER_TO_TARGET))
    {
        m_pRenderTexture = driver->addRenderTargetTexture(irr::core::dimension2d<irr::u32>((irr::u32)(720), (irr::u32)(480)));
        m_cRenderMaterial.setTexture(0, m_pRenderTexture);
    }

//     m_pRenderTexture = driver->getTexture("wall.bmp");
//.........这里部分代码省略.........

int main(int argc, const char** argv)
{
/*	- deviceType: Type of the device. This can currently be the Null-device,
	   one of the two software renderers, D3D8, D3D9, or OpenGL. In this
	   example we use EDT_SOFTWARE, but to try out, you might want to
	   change it to EDT_BURNINGSVIDEO, EDT_NULL, EDT_DIRECT3D8,
	   EDT_DIRECT3D9, or EDT_OPENGL.
	*/
	MyEventReceiver receiver;
	ISoundEngine* music = createIrrKlangDevice();
	IrrlichtDevice *device =
		createDevice( EDT_DIRECT3D9, dimension2d<u32>(640, 480), 32,
			false, false, false, &receiver);

	music->play2D("../media/MUSIC/Dark Impetus.mp3",true,false,true);

	IVideoDriver* driver = device->getVideoDriver();
	ISceneManager* smgr = device->getSceneManager();
	IGUIEnvironment* guienv = device->getGUIEnvironment();
	ICameraSceneNode *camera = smgr->addCameraSceneNode();
	IGUIFont* font = device->getGUIEnvironment()->getFont("../media/fonthaettenschweiler.bmp");
	camera->setFarValue(900);

	IAnimatedMesh* map = smgr->getMesh(DC_01);
	IAnimatedMeshSceneNode* mapnode = smgr->addAnimatedMeshSceneNode(map);
	mapnode->setMaterialFlag(EMF_LIGHTING,false);

	IAnimatedMesh* player1 = smgr->getMesh(SORA);
	IAnimatedMeshSceneNode* p1node = smgr->addAnimatedMeshSceneNode(player1);
	p1node->setMaterialFlag(EMF_LIGHTING, false);
	p1node->setScale(SORA_VECTOR3D);

	IAnimatedMesh* player2 = smgr->getMesh(AQUA);
	IAnimatedMeshSceneNode* p2node = smgr->addAnimatedMeshSceneNode(player2);
	p2node->setMaterialFlag(EMF_LIGHTING, false);
	p2node->setScale(NORMAL_VECTOR3D);

	vector3df Position = p1node->getPosition();
	vector3df P2Pos = p2node->getPosition();
	vector3df PosCam = p1node->getPosition();
	vector3df Rotate = p1node->getPosition();

	int CurrentHP = 300;
	int MaxHP = 400;
	int HeartP = 10;
	bool LockOn = false;
	bool LockCheck = false;
	stringw CoorCheck;

	while(device->run())
	{
		CoorCheck +=L"Your position\nX:";
		CoorCheck +=Position.X;
		CoorCheck +=L"\nY:";
		CoorCheck +=Position.Y;
		CoorCheck +=L"\nZ:";
		CoorCheck +=Position.Z;
		CoorCheck +=L"\n\nTarget Position:";
		CoorCheck +=P2Pos.X;
		if(LockCheck != true){
			if(receiver.IsKeyDown(KEY_KEY_J)){LockOn = true; LockCheck = true;}}
		else{
			if(receiver.IsKeyDown(KEY_KEY_J)){LockOn = false;LockCheck = false;}}

		//3D Rendering.
		MaximizeKey(receiver,device);
		GetCaption(driver,device);
		driver->beginScene(true, true, SColor(255,100,101,140));
		p1node->setPosition(Position);
		camera->setPosition(vector3df(PosCam.X,PosCam.Y+2,PosCam.Z+3));
		if(LockOn != false){camera->setTarget(P2Pos);}
		else{camera->setTarget(Position);}
		smgr->drawAll();

		//2D Rendering.
		if(CurrentHP<=0){font->draw(L"You are dead!!!",rect<s32>(120,140,250,210),SColor(255,255,255,255));}
		else{if(receiver.IsKeyDown(KEY_KEY_L)){--CurrentHP;}}
		if(CurrentHP>=MaxHP){}else{if(receiver.IsKeyDown(KEY_KEY_K)){++CurrentHP;}}

		if(receiver.IsKeyDown(KEY_KEY_N)){++MaxHP;}
		if(receiver.IsKeyDown(KEY_KEY_M) && CurrentHP<MaxHP){--MaxHP;}
		if(HeartP>=86){}else{
			if(receiver.IsKeyDown(KEY_KEY_F)){++HeartP;}}

		font->draw
		(L"Press O for full screen.\nPress Up-Down-Left-right to move.\nPress L to hurt the character.\nPress K to heal the character.\nPress N to increase Max HP.\nPress M to decrease Max HP.\nPress F to fill the Heart gauge.",rect<s32>(20,40,150,110),SColor(255,0,0,0));
		font->draw(CoorCheck,rect<s32>(20,140,150,110),SColor(255,0,0,0));

		//Button detection.
		if(receiver.IsKeyDown(KEY_UP)){
			Position.Z -= 0.1f;
			PosCam.Z = Position.Z;
			p1node->setRotation(vector3df(Rotate.X,Rotate.Y = 0,Rotate.Z));
			p1node->setPosition(Position);}
		if(receiver.IsKeyDown(KEY_DOWN)){
			Position.Z += 0.1f;
			PosCam.Z = Position.Z;
			p1node->setRotation(vector3df(Rotate.X,Rotate.Y -180,Rotate.Z));
			p1node->setPosition(Position);}
		if(receiver.IsKeyDown(KEY_LEFT)){
//.........这里部分代码省略.........

int main()
{
  // Initialization of Device, Video Driver and Scene Manager
  video::E_DRIVER_TYPE driverType=video::EDT_OPENGL; 
  MyEventReceiver receiver;  
  IrrlichtDevice* device = createDevice(driverType,
					core::dimension2d<u32>(960, 720), 16, false, false, false, &receiver);
  if (device == 0) return 1; 
  video::IVideoDriver* driver = device->getVideoDriver();
  scene::ISceneManager* smgr = device->getSceneManager();

  // Building the scene.

  // open level file
  ifstream infile;
  infile.open("enigma3d.app/Contents/Resources/field.lvl");
  if (infile.fail()) error("Could not open level file\n");

  // checking the file starts with "Enigma-3D"
  string line;
  infile >> line;
  if (line!="Enigma-3D") error("Illegal Level file: "+line+"\n"); 

  // Playground is a two-dimensional array of pointers to fields:
  Field * playground[dimx][dimy];
  
  // now reading from level file one number for each field
  // and creating a wall or floor of the appropriate sub-class
  for(int j=0; j<dimy; j++){
    for(int i=0; i<dimx; i++){
      // determine filed type
      int fieldtype;
      infile >> fieldtype;

      playground[i][j]=makefield(fieldtype,smgr,driver,i,j,playground);
    } 
  } 
  // the level file may contain additional requests for introducing
  // some fields to each other:
  while ((infile >> line), line!="end"){
    // must have the form "introduce x1 y1 to x1 y2"
    if (line!="introduce") error("Level File: mistake in introduce lines");
    int x1,x2,y1,y2;
    infile >> x1 >> y1 >> line >> x2 >> y2;
    if (   (x1 < 0) || x1>=dimx 
	|| (x2 < 0) || x2>=dimx 
        || (y1 < 0) || y1>=dimy 
	|| (y2 < 0) || y2>=dimy 
	|| line !="to" )
      error("Level File: mistake in introduce lines");
    // call the introduceTo method of field x1 y1:
    playground[x1][y1]->introduceTo(*(playground[x2][y2]));
  }
  infile.close();


  Sphere *sphere=new Sphere(smgr,driver);

  scene::ICameraSceneNode* camera=smgr->addCameraSceneNode(NULL,core::vector3df(offsety+50.f,100.f,offsetx),
							        core::vector3df(offsety,0.f,offsetx));
  // to change the camera position use: 
  //    camera->setPosition(core::vector3df(...));
  // see docmentation of  ICameraSceneNode  for more (like setting target, rotation, aspect)

  // hide the mouse cursor
  device->getCursorControl()->setVisible(false);

  // for time measurement: get an initial time reference 
  u32 then = device->getTimer()->getTime();

  // for mouse-move measurement: get an initial mouse position
  core::position2di RefPosition=receiver.Position;

  // compute the field number where the sphere is and notify that field
  int fieldx=getFieldx(sphere->getPosition());
  int fieldy=getFieldy(sphere->getPosition());
  playground[fieldx][fieldy]->sphereEnter(*sphere);

  // Running function introduceSphere for every wall/floor ONCE
  for(int j=0; j<dimy; j++)
    for(int i=0; i<dimx; i++)
      playground[i][j]-> introduceSphere(*sphere); 
	 

  while(device->run())
    {
      if(receiver.IsKeyDown(irr::KEY_KEY_Q)) exit(0); // quit game on key Q
      
      // Adapt speed by the difference in mouse position
      core::position2di mousemove;
      mousemove.X=(receiver.Position.X-RefPosition.X);
      mousemove.Y=(receiver.Position.Y-RefPosition.Y);
      // eliminating too rapid movements of the mouse
      if (fabs((float)mousemove.X)>10) mousemove.X=0;
	  if (fabs((float)mousemove.Y)>10) mousemove.Y = 0;
      // remember current mouse position
      RefPosition=receiver.Position;

      // Measure the time that has passed since last round 
      const u32 now = device->getTimer()->getTime();
//.........这里部分代码省略.........

int main()
{
    scene::IMesh* testMesh;
    scene::IMeshSceneNode* testNode;
    scene::ITriangleSelector* selector;
    core::matrix4 matrix = core::matrix4();
    scene::ICameraSceneNode* camera;
    core::vector3df cameraOffset = core::vector3df( 0.0f, 2.0f, 0.0f );

    MyEventReceiver receiver;
    IrrlichtDevice* device = createDevice( video::EDT_OPENGL,
            core::dimension2du( 800, 600 ), 32, false, true, false,
            &receiver );
    if ( device == 0 ) exit( 1 );
    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr  = device->getSceneManager();
    scene::IMeshManipulator* meshManipulator = smgr->getMeshManipulator();
    scene::ISceneCollisionManager* colliman = smgr->getSceneCollisionManager();

    // load, scale and place mesh
    driver->setTransform( video::ETS_WORLD, core::matrix4() );
    testMesh = meshManipulator->createMeshCopy(
            smgr->getMesh( "just_a_mesh.3ds" ) );
    matrix.setScale( core::vector3df(
            200.0f + 0.001f, 200.0f, 200.0f + 0.001f ) );
    matrix.setTranslation(
            core::vector3df(
                    99 * 400.0f + 200.0f,
                    0.0f,
                    99 * 400.0f + 200.0f
            )
    );
    meshManipulator->transform( testMesh, matrix );
    meshManipulator->recalculateNormals( testMesh, true );

    // setHardwareMappingHint
    for ( register u32 i = 0; i < testMesh->getMeshBufferCount(); ++i )
    {
        scene::IMeshBuffer* buffer = testMesh->getMeshBuffer( i );
        buffer->setHardwareMappingHint( scene::EHM_STATIC );
        buffer->setDirty();
        buffer->recalculateBoundingBox();
    }

    // create node from mesh
    testNode = smgr->addMeshSceneNode( testMesh );
    testMesh->drop();

    // set material
    testNode->setMaterialTexture(
            0, driver->getTexture( "just_a_texture.jpg" ) );
    testNode->setMaterialType( video::EMT_SOLID );
    testNode->setMaterialFlag( video::EMF_LIGHTING, false );
    testNode->setVisible( true );

    // add node to collision detection
    selector = smgr->createOctreeTriangleSelector(
            testNode->getMesh(), testNode, 900 );
    testNode->setTriangleSelector( selector );
    selector->drop();

    // add a camera
    camera = smgr->addCameraSceneNodeFPS( 0, 360.0f, 0.01f );
    camera->setPosition( core::vector3df(39936.0f, 0.0f, 39755.0f) );
    camera->setTarget( camera->getPosition() + core::vector3df( 1.0f, 0.0f, 1.0f ) );
    camera->updateAbsolutePosition();
    camera->setFarValue( 300.0f );
    camera->setNearValue( 0.1f );
    camera->setFOV( 1.25f );
    camera->setAspectRatio( 4.0f / 3.0f );
    camera->setInputReceiverEnabled( true );
    smgr->setActiveCamera( camera );
    device->getCursorControl()->setVisible( false );

    while( device->run() )
    {
        if ( !device->isWindowActive() ) device->yield();
        if ( receiver.IsKeyDown( irr::KEY_ESCAPE ) ) device->closeDevice();

        core::vector3df pos = camera->getPosition() - cameraOffset;
        pos.Y = getHeight( pos.X, pos.Z, colliman, testNode );
        if ( pos.Y > 999.0f ) printf( "gap at x=%f, z=%f!\n", pos.X, pos.Z );
        camera->setPosition( pos + cameraOffset );

        driver->beginScene( true, true );
        smgr->drawAll();
        driver->endScene();
    }

    device->drop();
    return 0;
}

int main(void){
    MyEventReceiver receiver;

    //Device, driver et graphe de scene
    irr::IrrlichtDevice* device = irr::createDevice(irr::video::EDT_OPENGL, irr::core::dimension2d<irr::u32>(800, 600), 32, false, false, false, &receiver);
    irr::video::IVideoDriver* driver = device->getVideoDriver();
        /*irr::video::SMaterial material;
        material.FrontfaceCulling = true;
        driver->setMaterial(material);*/
    irr::scene::ISceneManager *sceneManager = device->getSceneManager();

    //On rend invisible le curseur
    //device->getCursorControl()->setVisible(false);


    RubicCube *cube = new RubicCube(sceneManager);


    irr::scene::IMeshSceneNode *c_centre = sceneManager->addCubeSceneNode(BLOC_S, 0, 33, irr::core::vector3df(0, 0, 0));
    c_centre->setMaterialType(irr::video::EMT_SOLID);
    c_centre->setMaterialTexture(0, driver->getTexture("E:\\Codage\\Rubirrks\\Ressources\\blue.jpg"));

    irr::scene::IMeshSceneNode *c_up = sceneManager->addCubeSceneNode(BLOC_S, 0, 34, irr::core::vector3df(-(BLOC_S+BLOC_SPC), 0, 0));
    c_up->setMaterialType(irr::video::EMT_SOLID);
    c_up->setMaterialTexture(0, driver->getTexture("E:\\Codage\\Rubirrks\\Ressources\\red.jpg"));

    irr::scene::IMeshSceneNode *c_down = sceneManager->addCubeSceneNode(BLOC_S, 0, 35, irr::core::vector3df(BLOC_S+BLOC_SPC, 0, 0));
    c_down->setMaterialType(irr::video::EMT_SOLID);
    c_down->setMaterialTexture(0, driver->getTexture("E:\\Codage\\Rubirrks\\Ressources\\red.jpg"));

    irr::scene::IMeshSceneNode *c_north = sceneManager->addCubeSceneNode(BLOC_S, 0, 36, irr::core::vector3df(0, BLOC_S+BLOC_SPC, 0));
    c_north->setMaterialType(irr::video::EMT_SOLID);
    c_north->setMaterialTexture(0, driver->getTexture("E:\\Codage\\Rubirrks\\Ressources\\red.jpg"));

    irr::scene::IMeshSceneNode *c_south = sceneManager->addCubeSceneNode(BLOC_S, 0, 37, irr::core::vector3df(0, -(BLOC_S+BLOC_SPC), 0));
    c_south->setMaterialType(irr::vi