int main() { IrrlichtDevice* irrDevice = createDevice(EDT_OPENGL,dimension2d<s32>(800,600),32,false,false,false,0); IVideoDriver* irrVideo = irrDevice->getVideoDriver(); ISceneManager* irrSceneMgr = irrDevice->getSceneManager(); TMovie* movie = new TMovie(irrDevice->getTimer()); movie->LoadMovie("Mymovie.avi"); irrVideo->setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, false); u32 w = movie->getMovieWidth(); u32 h = movie->getMovieHeight(); ITexture* movTxtr = irrVideo->addTexture(dimension2d<s32>(w<513?512:1024,h<513?512:1024),"imovie"); irrSceneMgr->addCameraSceneNode(0, vector3df(0,0,-20), vector3df(0,0,0)); CSampleSceneNode* myNode = new CSampleSceneNode(irrSceneMgr->getRootSceneNode(), irrSceneMgr, 666); myNode->setMaterialTexture( 0, movTxtr); myNode->drop(); ISceneNodeAnimator* anim = irrSceneMgr->createRotationAnimator(vector3df(0,0.1f,0)); myNode->addAnimator(anim); anim->drop(); while(irrDevice->run()) { irrVideo->beginScene(true, true, SColor(0,200,200,200)); if (movie->NextMovieFrame()) movie->DrawMovie(0,0,movTxtr); irrSceneMgr->drawAll(); irrVideo->endScene(); } irrDevice->drop(); return 0; }
int example_customscenenode() { // create device IrrlichtDevice *device = startup(); if (device == 0) return 1; // could not create selected driver. // create engine and camera EventReceiver_basic receiver(device); device->setEventReceiver(&receiver); IVideoDriver* driver = device->getVideoDriver(); ISceneManager* smgr = device->getSceneManager(); IGUIEnvironment* guienv = device->getGUIEnvironment(); smgr->addCameraSceneNode(0, vector3df(0, -40, 0), vector3df(0, 0, 0)); CSampleSceneNode *myNode = new CSampleSceneNode(smgr->getRootSceneNode(), smgr, 666); ISceneNodeAnimator* anim = smgr->createRotationAnimator(vector3df(0.8f, 0, 0.8f)); if (anim) { myNode->addAnimator(anim); anim->drop(); anim = 0; // As I shouldn't refer to it again, ensure that I can't } myNode->drop(); myNode = 0; // As I shouldn't refer to it again, ensure that I can't return run(device); }
/********************************************************************* * Animates a muzzle flash billboard with firing sound and does * damage to borbie. This method is only called when the soldier * is within range and has direct line of sight. He has an 80% * chance of hitting his target. *********************************************************************/ void Soldier::fire(int distance){ lastFireTime = gameInstance->getDevice()->getTimer()->getTime(); IBillboardSceneNode * bill; bill = smgr->addBillboardSceneNode(); bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR ); bill->setMaterialTexture(0, driver->getTexture("assets/textures/muzFlash.png")); bill->setMaterialFlag(video::EMF_LIGHTING, false); bill->setMaterialFlag(video::EMF_ZBUFFER, false); float randomNum = Random::randomFloat(-10.0, 15.0); bill->setSize(core::dimension2d<f32>(30.0+randomNum, 30.0+randomNum)); bill->setID(0);//not pickable by ray caster //get enemy position, adjust muzzle flash height to barrel vector3df start = sceneNode->getPosition(); start.Y+=60; bill->setPosition(start); this->audioSystem->playSound3d(gameInstance->gunShot1, this); const int MUZZLE_FLASH_TIME = 50; ISceneNodeAnimator* anim = gameInstance->getSceneManager()->createDeleteAnimator(MUZZLE_FLASH_TIME); bill->addAnimator(anim); anim->drop(); if (!miss(distance)) gameInstance->player->applyBulletDamage(BULLET_DAMAGE); else gameInstance->player->ricochet(); }
void CRaycastTankExample::createMuzzleFlash(irr::scene::IBoneSceneNode *node) { IBillboardSceneNode *muzzleFlash = device->getSceneManager()->addBillboardSceneNode(0, dimension2d<f32>(30.0f, 30.0f), node->getAbsoluteTransformation().getTranslation()); muzzleFlash->setMaterialFlag(EMF_LIGHTING, false); muzzleFlash->setMaterialTexture(0,device->getVideoDriver()->getTexture("particlewhite.bmp")); muzzleFlash->setMaterialType(EMT_TRANSPARENT_ADD_COLOR); ISceneNodeAnimator* deleteAnim = device->getSceneManager()->createDeleteAnimator(100); muzzleFlash->addAnimator(deleteAnim); deleteAnim->drop(); }
int Java_zte_irrlib_scene_SceneNode_nativeAddDeleteAnimator( JNIEnv *env, jobject defaultObj, jint ms, jint id) { ISceneNode* node = smgr->getSceneNodeFromId(id); if (!node) { WARN_NODE_NOT_FOUND(id, AddDeleteAnimator); return -1; } ISceneNodeAnimator* anim = smgr->createDeleteAnimator(ms); node->addAnimator(anim); anim->drop(); return 0; }
int Java_zte_irrlib_scene_SceneNode_nativeAddRotationAnimator( JNIEnv* env, jobject defaultObj, jdouble x, jdouble y, jdouble z, jint id) { ISceneNode* node = smgr->getSceneNodeFromId(id); if (!node) { WARN_NODE_NOT_FOUND(id, AddRotationAnimator); return -1; } ISceneNodeAnimator* anim = smgr->createRotationAnimator(vector3df(x,y,z)); node->addAnimator(anim); anim->drop(); return 0; }
/** Tests the offset capability of the fly circle animator */ bool flyCircleAnimator(void) { IrrlichtDevice *device = createDevice(video::EDT_BURNINGSVIDEO, core::dimension2du(160,120), 32); if (!device) return false; IVideoDriver* driver = device->getVideoDriver(); ISceneManager* smgr = device->getSceneManager(); const f32 offsetDegrees[] = { 0.f, 45.f, 135.f, 270.f }; for(u32 i = 0; i < sizeof(offsetDegrees) / sizeof(offsetDegrees[0]); ++i) { IBillboardSceneNode * node = smgr->addBillboardSceneNode(); // Have the animator rotate around the Z axis plane, rather than the default Y axis ISceneNodeAnimator * animator = smgr->createFlyCircleAnimator( vector3df(0, 0, 0), 30.f, 0.001f, vector3df(0, 0, 1), (offsetDegrees[i] / 360.f)); if(!node || !animator) return false; node->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR ); node->setMaterialTexture(0, driver->getTexture("../media/particle.bmp")); node->setMaterialFlag(video::EMF_LIGHTING, false); node->addAnimator(animator); animator->drop(); } (void)smgr->addCameraSceneNode(0, vector3df(0, 0, -50), vector3df(0, 0, 0)); bool result = false; // Don't do device->run() since I need the time to remain at 0. if (driver->beginScene(true, true, video::SColor(0, 80, 80, 80))) { smgr->drawAll(); driver->endScene(); result = takeScreenshotAndCompareAgainstReference(driver, "-flyCircleAnimator.png", 100); } device->closeDevice(); device->run(); device->drop(); return result; }
/********************************************************************* * Moves the soldier toward the enemy, only gets called when * there is a direct line of sight *********************************************************************/ void Soldier::moveToPlayer(){ vector3df start = sceneNode->getPosition(); destination = gameInstance->getCamera()->getPosition(); destination.X = start.X + 0.2*(destination.X-start.X); destination.Z = start.Z + 0.2*(destination.Z-start.Z); destination.Y = 70;//ground height f32 length = (f32)ray.start.getDistanceFrom(destination); const int SOLDIER_MOVE_SPEED = 1.5; f32 time = length * SOLDIER_MOVE_SPEED; ISceneNodeAnimator* anim = gameInstance->getSceneManager()->createFlyStraightAnimator(start, destination, time, false); sceneNode->addAnimator(anim); anim->drop(); moving = true; }
void Entity::addCollision(Entity coll, f32 tx, f32 ty, f32 tz, f32 sx, f32 sy, f32 sz, f32 gx, f32 gy, f32 gz) { ITriangleSelector* selector = 0; if(coll.type == MESH_TYPE) { selector = Scene->createTriangleSelector(coll.tmesh, coll.sceneNode); coll.sceneNode->setTriangleSelector(selector); } if(coll.type == ANIM_TYPE) { selector = Scene->createTriangleSelector(coll.animNode->getMesh(), coll.animNode); coll.animNode->setTriangleSelector(selector); } if(coll.type == MAP_TYPE) { selector = Scene->createOctreeTriangleSelector(coll.bmesh->getMesh(0), coll.sceneNode); coll.sceneNode->setTriangleSelector(selector); } ISceneNodeAnimator* anim; if(type == MESH_TYPE) { anim = Scene->createCollisionResponseAnimator(selector, sceneNode, vector3df(sx,sy,sz), \ vector3df(gx,gy,gz), vector3df(tx,ty,tz)); sceneNode->addAnimator(anim); } if(type == ANIM_TYPE) { anim = Scene->createCollisionResponseAnimator(selector, animNode, vector3df(sx,sy,sz), \ vector3df(gx,gy,gz), vector3df(tx,ty,tz)); animNode->addAnimator(anim); } if(type == MAP_TYPE) { anim = Scene->createCollisionResponseAnimator(selector, sceneNode, vector3df(sx,sy,sz), \ vector3df(gx,gy,gz), vector3df(tx,ty,tz)); sceneNode->addAnimator(anim); } else return; selector->drop(); anim->drop(); }
int Java_zte_irrlib_scene_SceneNode_nativeAddCollisionResponseAnimator( JNIEnv *env, jobject defaultObj, jint selId, jobject jradius, jboolean bbox, jboolean octree, jint id) { ISceneNode* selNode = smgr->getSceneNodeFromId(selId); if (!selNode) { WARN_NODE_NOT_FOUND(selId, AddCollisionResponseAnimator); return -1; } ISceneNode* node = smgr->getSceneNodeFromId(id); if (!node) { WARN_NODE_NOT_FOUND(id, AddCollisionResponseAnimator); return -1; } ITriangleSelector* selector = 0; if (bbox) selector = smgr->createTriangleSelectorFromBoundingBox(selNode); else if (!octree) selector = smgr->createTriangleSelector(((IMeshSceneNode*)selNode)->getMesh(), selNode); else selector = smgr->createTriangleSelector(((IMeshSceneNode*)selNode)->getMesh(), selNode); node->updateAbsolutePosition(); const aabbox3d<f32>& box = node->getTransformedBoundingBox(); vector3df radius; if (jradius == 0) radius = box.MaxEdge-box.getCenter(); else radius = utils->createvector3dfFromVector3d(env, jradius); vector3df translation = -(box.getCenter() - node->getAbsolutePosition()); //LOGD("max, %f, %f, %f", box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z); //LOGD("min, %f, %f, %f", box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z); //LOGD("trans, %f, %f, %f", translation.X, translation.Y, translation.Z); ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(selector, node, radius, vector3df(),/*gravity*/ translation, 0.0005f ); selector->drop(); node->addAnimator(anim); anim->drop(); }
//! creates a scene node animator based on its type id ISceneNodeAnimator* CBulletAnimatorManager::createSceneNodeAnimator(ESCENE_NODE_ANIMATOR_TYPE type, ISceneNode* target) { ESCENE_NODE_BULLET_ANIMATOR_TYPE animType = (ESCENE_NODE_BULLET_ANIMATOR_TYPE)type; ISceneNodeAnimator* anim = NULL; switch (animType) { case ESNAT_BULLET_WORLD: { // create bullet world animator //if (BulletWorldAnimator != NULL) { BulletWorldAnimator->drop(); BulletWorldAnimator = NULL; } anim = createEmptyBulletWorldAnimator(sceneManager, target); } break; case ESNAT_BULLET_OBJECT: { // create object anim = createEmptyBulletObjectAnimator(sceneManager, target); } break; //나중에 확장을... case ESNAT_BULLET_OBJECT_FPS_CTRL: { // create object //anim = new CBulletFpsCamAnimator(); //anim = createBulletFpsCamAnimator(sceneManager, target); } break; case ESNAT_BULLET_OBJECT_CHACTER_CTRL: { // create object anim = new CBulletChracterAnimator(); target->addAnimator(anim); anim->drop(); //anim = createBulletCharcterAnimator(sceneManager, target,0,); } break; } if (anim && target) { target->addAnimator(anim); } return anim; }
int Java_zte_irrlib_scene_SceneNode_nativeAddFlyCircleAnimator( JNIEnv* env, jobject defaultObj, jdouble cx, jdouble cy, jdouble cz, jdouble radius, jdouble speed, jdouble ax, jdouble ay, jdouble az, jdouble startPosition, jdouble radiusEllipsoid, jint id) { ISceneNode* node = smgr->getSceneNodeFromId(id); if (!node) { WARN_NODE_NOT_FOUND(id, AddFlyCircleAnimator); return -1; } ISceneNodeAnimator* anim = smgr->createFlyCircleAnimator(vector3df(cx,cy,cz),radius,speed,vector3df(ax, ay, az), startPosition, radiusEllipsoid); node->addAnimator(anim); anim->drop(); return 0; }
int Java_zte_irrlib_scene_SceneNode_nativeAddFlyStraightAnimator( JNIEnv* env, jobject defaultObj, jdouble sx, jdouble sy, jdouble sz, jdouble dx, jdouble dy, jdouble dz, jdouble time, jboolean loop, jboolean pingpong, jint id) { ISceneNode* node = smgr->getSceneNodeFromId(id); if (!node) { WARN_NODE_NOT_FOUND(id, AddFlyStraightAnimator); return -1; } vector3df start(sx,sy,sz); vector3df end(dx, dy, dz); ISceneNodeAnimator* anim = smgr->createFlyStraightAnimator (start, end, time, loop, pingpong); node->addAnimator(anim); anim->drop(); return 0; }
void Player::SetGravity(vector3df gravityVector) { //Set the new collision vector collisionAnimator->setGravity(gravityVector); //Remove the outdated response animator fpsCamera->GetCamera()->removeAnimator(collisionAnimator); //Set the new collision response animator fpsCamera->GetCamera()->addAnimator(collisionAnimator); //TODO: If player is falling, make descent slower. if(collisionAnimator->isFalling()) { ISceneNodeAnimator* anim = smgr->createFlyStraightAnimator(fpsCamera->GetPosition(), vector3df(0,-100, 0), 1000, false); fpsCamera->GetCamera()->addAnimator(anim); anim->drop(); } }//end SetGravity()
void load_map() { IAnimatedMesh* mesh = smgr->getMesh("resources/nodes/maps/room.3ds"); smgr->getMeshManipulator()->makePlanarTextureMapping(mesh->getMesh(0), 0.008f); ISceneNode* node = 0; node = smgr->addAnimatedMeshSceneNode(mesh); node->setMaterialTexture(0, driver->getTexture("resources/textures/maps/wall.jpg")); node->getMaterial(0).SpecularColor.set(0,0,0,0); mesh = smgr->addHillPlaneMesh("myHill", dimension2d<f32>(20,20), dimension2d<u32>(40,40), 0, 0, dimension2d<f32>(0,0), dimension2d<f32>(10,10) ); node = smgr->addWaterSurfaceSceneNode(mesh->getMesh(0), 3.0f, 300.0f, 30.0f); node->setPosition(vector3df(0,7,0)); node->setMaterialTexture(0, driver->getTexture("resources/textures/maps/stones.jpg")); node->setMaterialTexture(1, driver->getTexture("resources/textures/maps/water.jpg")); node->setMaterialType(video::EMT_REFLECTION_2_LAYER); // create light node = smgr->addLightSceneNode(0, vector3df(0,0,0), SColorf(1.0f, 0.6f, 0.7f, 1.0f), 600.0f); ISceneNodeAnimator* anim = 0; anim = smgr->createFlyCircleAnimator (vector3df(0,150,0),250.0f); node->addAnimator(anim); anim->drop(); // attach billboard to light node = smgr->addBillboardSceneNode(node, dimension2d<f32>(50, 50)); node->setMaterialFlag(EMF_LIGHTING, false); node->setMaterialType(EMT_TRANSPARENT_ADD_COLOR); node->setMaterialTexture(0, driver->getTexture("resources/textures/particles/particlewhite.bmp")); }
//! reads animators of a node void CSceneLoaderIrr::readAnimators(io::IXMLReader* reader, ISceneNode* node) { while(reader->read()) { const wchar_t* name = reader->getNodeName(); switch(reader->getNodeType()) { case io::EXN_ELEMENT_END: if (IRR_XML_FORMAT_ANIMATORS == name) return; break; case io::EXN_ELEMENT: if (IRR_XML_FORMAT_ATTRIBUTES == name) { // read animator data from attribute list io::IAttributes* attr = FileSystem->createEmptyAttributes(SceneManager->getVideoDriver()); attr->read(reader); if (node) { core::stringc typeName = attr->getAttributeAsString("Type"); ISceneNodeAnimator* anim = SceneManager->createSceneNodeAnimator(typeName.c_str(), node); if (anim) { anim->deserializeAttributes(attr); anim->drop(); } } attr->drop(); } break; default: break; } } }
/********************************************************************* * Moves the soldier toward the Borbie over a longer distance, using * A* algorithm to find a shortest path using roads. *********************************************************************/ void Soldier::aStarToPlayer(){ // Find shortest path using the MapSearcher from this soldier to the player // using the closest available road intersection points. MapSearcher *searcher = this->gameInstance->getMapSearcher(); vector3df curPosition = this->sceneNode->getPosition(); std::vector<RoadIntersection> path = searcher->getShortestPath( curPosition, this->gameInstance->getCamera()->getPosition()); // If path is unavailable, or already near Borbie, do nothing. int numPathPoints = path.size(); if(numPathPoints == 0) return; // set up a list of coordinates to move through, starting with the // soldier's current position. array<vector3df> coords; coords.push_back(this->sceneNode->getPosition()); for(int i=0; i<numPathPoints; ++i){ vector3df point; point.X = path[i].X; point.Y = curPosition.Y; point.Z = path[i].Y; coords.push_back(point); } // set the destination to the location of the last coordinate this->destination.X = path[numPathPoints-1].X; this->destination.Y = curPosition.Y; this->destination.Z = path[numPathPoints-1].Y; // create a spline animator (follows the path of coordinates) to animate // the soldier to move to Borbie. ISceneNodeAnimator *anim = smgr->createFollowSplineAnimator( this->gameInstance->currentGameTime, coords, 0.1f, 0.0, false); sceneNode->addAnimator(anim); anim->drop(); moving = true; }
void Game::init() { #ifdef WIN32 device = createDevice(video::EDT_DIRECT3D9, core::dimension2d<s32>(640, 480)); #else device = createDevice(video::EDT_OPENGL, core::dimension2d<s32>(640, 480)); #endif driver = device->getVideoDriver(); smgr = device->getSceneManager(); guienv = device->getGUIEnvironment(); device->setWindowCaption(L"Not So Much Super Offroad - By Andreas Kröhnke"); IMeshSceneNode *node = smgr->addMeshSceneNode( smgr->getMesh("data/car3.3ds")->getMesh(0) ); GameObject *car = new GameObject(); car->setSceneNode(node); node->setMaterialFlag(EMF_LIGHTING, false); node->setScale(vector3df(0.09,0.09,0.09)); node->setRotation(vector3df(0,0,0)); node->setPosition(vector3df(3454,500,1256)); //node->setDebugDataVisible(EDS_BBOX); object->push_back(car); ITerrainSceneNode *terrain = smgr->addTerrainSceneNode("data/level1.bmp"); GameObject *go_terrain = new GameObject(); go_terrain->setSceneNode(terrain); terrain->setMaterialFlag(EMF_LIGHTING, false); terrain->setScale(core::vector3df(18, 3.0f, 18)); terrain->setMaterialFlag(video::EMF_LIGHTING, false); terrain->setMaterialTexture(0, driver->getTexture("data/terrain-texture.jpg")); terrain->setMaterialTexture(1, driver->getTexture("data/detailmap3.jpg")); terrain->setMaterialType(video::EMT_DETAIL_MAP); terrain->scaleTexture(1.0f, 20.0f); terrain->setDebugDataVisible(EDS_BBOX); object->push_back(go_terrain); // Camera Camera *cam = new Camera(); cam->setSceneNode(smgr->addCameraSceneNode()); object->push_back(cam); cam->followNode(car->getSceneNode()); reciever = new EventReciever(); reciever->setSteer(car->getSceneNode()); device->setEventReceiver(reciever); // create triangle selector for the terrain ITriangleSelector* selector = smgr->createTerrainTriangleSelector(terrain, 0); terrain->setTriangleSelector(selector); selector->drop(); // create collision response animator and attach it to the camera ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(selector, car->getSceneNode(), core::vector3df(10,10,10), core::vector3df(0,-5.0f,0), core::vector3df(0,0,0) ); car->getSceneNode()->addAnimator(anim); anim->drop(); // Skybox smgr->addSkyBoxSceneNode( driver->getTexture("data/irrlicht2_up.jpg"), driver->getTexture("data/irrlicht2_dn.jpg"), driver->getTexture("data/irrlicht2_lf.jpg"), driver->getTexture("data/irrlicht2_rt.jpg"), driver->getTexture("data/irrlicht2_ft.jpg"), driver->getTexture("data/irrlicht2_bk.jpg")); // Checkpoints pair<vector3df, vector3df> cp1(vector3df(3112,393,1234), vector3df(90,90,0)); addCheckPoint(cp1.first, cp1.second); pair<vector3df, vector3df> cp2(vector3df(2531,281,1389), vector3df(90,120,0)); addCheckPoint(cp2.first, cp2.second); addCheckPoint(vector3df(2304,160,1826), vector3df(90,140,0)); addCheckPoint(vector3df(2132,111,2672), vector3df(90,120,0)); addCheckPoint(vector3df(1130,415,3313), vector3df(90,75,0)); addCheckPoint(vector3df(746,471,1753), vector3df(90,0,0)); addCheckPoint(vector3df(1985,269,1457), vector3df(90,-120,0)); addCheckPoint(vector3df(2475,146,2868), vector3df(90,-120,0)); addCheckPoint(vector3df(3707,417,2915), vector3df(90,-60,0)); // Arrows addArrow(vector3df(3012,320,1234), vector3df(100,-55,0)); addArrow(vector3df(2531,220,1389), vector3df(100,-10,0)); //addArrow(vector3df(2304,110,1826), vector3df(90,10,0)); addArrow(vector3df(2232,20,2272), vector3df(90,-20,0)); // HUD info = guienv->addStaticText(L"USE ARROW KEYS TO PLAY", rect<int>(10,10,200,60), true); info->setOverrideColor(SColor(255, 255, 255, 255)); //IGUIStaticText *quick_info = guienv->addStaticText(L"Arrow keys to play\n", rect<int>(10,50,200,50), true); //quick_info->setOverrideColor(SColor(255,255,255,255)); initSound(); }
/** Test functionality of the ISceneNodeAnimator implementations. */ bool sceneNodeAnimator(void) { IrrlichtDevice * device = irr::createDevice(video::EDT_NULL, dimension2d<u32>(160, 120)); assert_log(device); if(!device) return false; ISceneManager * smgr = device->getSceneManager(); // Test the hasFinished() method. ISceneNodeAnimatorCollisionResponse* collisionResponseAnimator = smgr->createCollisionResponseAnimator(0, 0); ISceneNodeAnimator* deleteAnimator = smgr->createDeleteAnimator(1); ISceneNodeAnimator* flyCircleAnimator = smgr->createFlyCircleAnimator(); ISceneNodeAnimator* flyStraightAnimator = smgr->createFlyStraightAnimator(vector3df(0, 0, 0), vector3df(0, 0, 0), 1, false); ISceneNodeAnimator* flyStraightAnimatorLooping = smgr->createFlyStraightAnimator(vector3df(0, 0, 0), vector3df(0, 0, 0), 1, true); ISceneNodeAnimator* rotationAnimator = smgr->createRotationAnimator(vector3df(0, 0, 0)); array<vector3df> points; points.push_back(vector3df(0, 0, 0)); points.push_back(vector3df(0, 0, 0)); ISceneNodeAnimator* followSplineAnimator = smgr->createFollowSplineAnimator(0, points, 1000.f); array<video::ITexture*> textures; textures.push_back(0); textures.push_back(0); ISceneNodeAnimator* textureAnimator = smgr->createTextureAnimator(textures, 1, false); ISceneNodeAnimator* textureAnimatorLooping = smgr->createTextureAnimator(textures, 1, true); bool result = true; ISceneNode * deletedNode = smgr->addEmptySceneNode(); deletedNode->addAnimator(deleteAnimator); ISceneNode * testNode = smgr->addEmptySceneNode(); testNode->addAnimator(collisionResponseAnimator); testNode->addAnimator(deleteAnimator); testNode->addAnimator(flyCircleAnimator); testNode->addAnimator(flyStraightAnimator); testNode->addAnimator(flyStraightAnimatorLooping); testNode->addAnimator(rotationAnimator); testNode->addAnimator(followSplineAnimator); testNode->addAnimator(textureAnimator); testNode->addAnimator(textureAnimatorLooping); result &= !collisionResponseAnimator->hasFinished(); result &= !deleteAnimator->hasFinished(); result &= !flyCircleAnimator->hasFinished(); result &= !flyStraightAnimator->hasFinished(); result &= !flyStraightAnimatorLooping->hasFinished(); result &= !rotationAnimator->hasFinished(); result &= !followSplineAnimator->hasFinished(); result &= !textureAnimator->hasFinished(); result &= !textureAnimatorLooping->hasFinished(); device->run(); device->sleep(10); device->run(); smgr->drawAll(); // These animators don't have an endpoint. result &= !collisionResponseAnimator->hasFinished(); result &= !flyCircleAnimator->hasFinished(); result &= !rotationAnimator->hasFinished(); result &= !followSplineAnimator->hasFinished(); // These animators are looping and so can't finish. result &= !flyStraightAnimatorLooping->hasFinished(); result &= !textureAnimatorLooping->hasFinished(); // These have an endpoint and have reached it. result &= deleteAnimator->hasFinished(); result &= flyStraightAnimator->hasFinished(); result &= textureAnimator->hasFinished(); collisionResponseAnimator->drop(); deleteAnimator->drop(); flyCircleAnimator->drop(); flyStraightAnimator->drop(); flyStraightAnimatorLooping->drop(); rotationAnimator->drop(); followSplineAnimator->drop(); textureAnimator->drop(); textureAnimatorLooping->drop(); device->closeDevice(); device->run(); device->drop(); if(!result) { logTestString("One or more animators has a bad hasFinished() state\n."); assert_log(false); } return result; }
/****************************************************************************** * Constructor for the gameInstance * Param: smgr the iSceneManager for the game * Param: guienv the GUI environment used by the game to draw gui's * Param: driver the IVideoDriver for the game * Param: device the IrrlichtDevice for the game * Param: audioSystm used from making both 3d and 2d sound in the game * Param: runMode used to determine if the debug flag has been set * Param: game the encompassing game object for gameInstance *****************************************************************************/ GameInstance::GameInstance( ISceneManager *smgr, IGUIEnvironment *guienv, IVideoDriver *driver, IrrlichtDevice *device, AudioSystem *audioSystem, unsigned int runMode, IEventReceiver *receiver, Game *game) { this->game=game; /*** Setup Pointers and Irrlicht Objects ***/ // keep pointers to Irrlicht rendering pointers this->smgr = smgr; this->guienv = guienv; this->driver = driver; this->device = device; this->audioSystem = audioSystem; this->receiver = receiver; this->timer = device->getTimer(); // initialize all game timers to 0 this->currentGameTime = this->timer->getTime(); this->nextPunchTime = 0; ((BorbiesEventReceiver*)(this->receiver))->setGameInstance(this); /*** Setup Sounds and Music ***/ this->bgSound = audioSystem->createSound2d("assets/sounds/yumyum.ogg"); this->bgSoundDead = audioSystem->createSound2d("assets/sounds/angryWorld.ogg"); this->borbieDead = audioSystem->createSound2d("assets/sounds/soundEffects/wut.mp3"); //Start the shitty music and loop! audioSystem->playMusicLoop(bgSound); audioSystem->setMusicVolume(0.5); // setup global collision meta selector this->metaTriSelector = smgr->createMetaTriangleSelector(); this->burningSound = audioSystem->createSound3d("assets/sounds/soundEffects/burning.mp3"); this->explosionSound1 = audioSystem->createSound3d("assets/sounds/soundEffects/rocketHit.wav"); this->death1 = audioSystem->createSound3d("assets/sounds/soundEffects/meinLeiben.wav"); this->gunShot1 = audioSystem->createSound3d("assets/sounds/soundEffects/burst.mp3"); this->gunShot2 = audioSystem->createSound3d("assets/sounds/soundEffects/bigAssGun.mp3"); /*** Setup Runtime Flags ***/ float gravity = GLOBAL_GRAVITY; bool noVerticalMovement = true; // disabled float playerMoveSpeed = PLAYER_MOVEMENT_SPEED; // if debug mode, turn off gravity and enable vertical movement if(runMode & BORBIE_DEBUG_MODE){ gravity = 0.f; // no gravity noVerticalMovement = false; // vertical movement enabled playerMoveSpeed = PLAYER_MOVEMENT_SPEED_DEBUG; } /*** create textures for in game menu ***/ this->menu = driver->getTexture("assets/textures/deathMenu.jpg"); /*** Setup Environment ***/ // Add Terrain and collision this->terrain = new Terrain(driver, smgr, metaTriSelector); addCollision(this->terrain->getTriSelector()); // add skybox this->skybox = new Sky(smgr, driver); // add lighting this->light = new WorldLight(smgr); //set shadow color: dark purplish smgr->setShadowColor(video::SColor(120,35,20,47)); this->rainParticleSystem = 0; /*** Setup Game Objects (BUILDINGS, VEHICLES) ***/ // Read the map file into the global static MapReader object. this->mapReader = new MapReader("assets/map/coords.bor"); this->mapSearcher = this->mapReader->getMapSearcher(); // add the buildings and generate city based on coordinate file this->buildings = new Buildings(metaTriSelector, this); this->buildings->generateObjects(); // add the vehicles and generate initial spawns this->vehicles = new Vehicles(metaTriSelector, this); this->vehicles->generateObjects(); // default vehicle throwing variables to nothing this->carriedVehicle = 0; this->vehicleThrown = false; this->targetPos = vector3df(0,0,0); // add and generate enemies this->enemies = new Enemies (metaTriSelector, this); this->enemies->generateObjects(); /*** Setup User Interface (HUD) ***/ // add the hud object this->hud = new Hud(this); /*** Setup Camera ***/ // set key bindings (WASD=move, SPACE=jump) to camera SKeyMap keyMap[9]; KeyBindings *keys = new KeyBindings(&keyMap[0]); keys->setKeys(); // added: (remove if setKeys() becomes static) delete keys; // setup camera camera = smgr->addCameraSceneNodeFPS( 0, // parent (none) PLAYER_ROTATE_SPEED, // rotate speed playerMoveSpeed, // move speed IDFlag_IsPickable, // ID keyMap, // keymap 9, // keymap size noVerticalMovement, // no vertical movement (true = up/down disabled) PLAYER_JUMP_SPEED // jump speed ); //TODO: read camera position from map file camera->setPosition(vector3df(2500, 1000, 4450)); // set view distance camera->setFarValue(30000.0f); // hide cursor device->getCursorControl()->setVisible(false); // add automatic collision response to camera ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(metaTriSelector, camera, core::vector3df(60, 150, 60), // radius core::vector3df(0, gravity, 0), // gravity (negative y = go down) core::vector3df(0, PLAYER_HEIGHT, 0), //radius offset 0.1f); // sliding value TODO tweak as needed camera->addAnimator(anim); anim->drop(); //create beatDown ray selector selector = new CastRay(smgr, camera); highlightedSceneNode = 0; //create objectCarrier for picking shit up objCarry = new ObjectCarrier(smgr, device, camera); //tell the mouse listener that right mouse isn't pressed to start with ((BorbiesEventReceiver *)receiver)->setRightMouse(false); /*** Add Hands ***/ hands = new Hands(this); /*** Add The Borbie ***/ this->player = new Borbie(this); this->nextScoreEvent = 10000; // initialize world state to fabulous this->setWorldState(FABULOUS); }
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; neighcb *ncb = new neighcb(); edge = gpu->addHighLevelShaderMaterial(tmp1.c_str(),0,EVST_VS_1_1,tmp2.c_str(),0,EPST_PS_1_1,ncb); sq3->SetMaterialType((E_MATERIAL_TYPE) edge); // Record start time int lastfps = -1, minfps = 10000; unsigned long long total_frames = 0, fxtimer = 0, tmplong, onframes = 0; struct timeval starttime, tick1, tick2; float glsltime = 0; gettimeofday(&starttime, NULL); wchar_t cap[20]; glEnable(GL_STENCIL_TEST); unsigned char firstrun = 1; // To avoid the glsl compiler in the timing // Main loop while (dev->run()) { gettimeofday(&tick1, NULL); drv->beginScene(); switch (state) { case MLAA_OFF: if (showpic) def->Render(false); else smgr->drawAll(); break; case MLAA_ON: if (showpic) def->Render(rt1); else { drv->setRenderTarget(rt1); smgr->drawAll(); } glClear(GL_STENCIL_BUFFER_BIT); glStencilFunc(GL_ALWAYS, 1, ~0); glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); sq->Render(rt2); glStencilFunc(GL_EQUAL, 1, ~0); glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); sq2->Render(rt3); drv->setRenderTarget(rt1, false, false); // Overlay the smoothed edges on the initial image sq3->Render(false); // Blit the final image to the framebuffer glStencilFunc(GL_ALWAYS, 1, ~0); norm->Render(); break; } drv->endScene(); if (state == MLAA_ON) { gettimeofday(&tick2, NULL); if (!firstrun) { tmplong = (tick2.tv_sec - tick1.tv_sec) * 10000; tmplong += (tick2.tv_usec - tick1.tv_usec) / 100; fxtimer += tmplong; onframes++; } else { firstrun = 0; glsltime = tick2.tv_sec - tick1.tv_sec; glsltime += (tick2.tv_usec - tick1.tv_usec) / 1000000.0; } } int fps = drv->getFPS(); if (minfps > fps) minfps = fps; if (lastfps != fps) { swprintf(cap, 20, L"%d fps, MLAA %s", fps, state == MLAA_ON ? "on" : "off"); dev->setWindowCaption(cap); lastfps = fps; } if (r->IsKeyDown(KEY_KEY_M)) { if (state == MLAA_ON) state = MLAA_OFF; else state = MLAA_ON; lastfps++; } usleep(1); // 16? total_frames++; } dev->drop(); delete ncb; delete bcb; delete def; delete sq; delete sq2; delete sq3; delete norm; delete r; struct timeval endtime; gettimeofday(&endtime, NULL); float sec = endtime.tv_sec - starttime.tv_sec; sec += ((float) endtime.tv_usec - starttime.tv_usec) / 1000000; printf("\nRan %.3fs, ", sec); sec -= glsltime; printf("average fps %.2f, min %d\n", (float) total_frames/sec, minfps); if (onframes) { printf("\nAverage on fps %.2f, average off fps %.2f\n\n", (float) onframes/(fxtimer/10000.0), (float) (total_frames - onframes)/(sec - (fxtimer/10000.0))); // printf("MLAA took on average %.1fms\n", (float) (fxtimer / onframes) / 10.0); } return 0; }
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; }