int CUIMain::LoadWorld(void) { Ogre::SceneNode* RootNode = mSceneMgr->getRootSceneNode(); Ogre::Plane plane(Ogre::Vector3::UNIT_Y, -1); //1 unit under the ground Ogre::MeshManager::getSingleton().createPlane("ground", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 2000,2000,20,20,true,1,5,5,Ogre::Vector3::UNIT_Z); Ogre::Entity *GroundEnt = mSceneMgr->createEntity("GroundEntity", "ground"); GroundEnt->setQueryFlags(QUERY_MASK_MOUSE_MOVEMENT); GroundEnt->setMaterialName("Rockwall"); RootNode->createChildSceneNode()->attachObject(GroundEnt); CharacterInfo local_player_info; mWorld.LocalPlayer = new CLocalPlayer(mWorld, RootNode->createChildSceneNode()); AttachMeshes(mWorld.LocalPlayer, local_player_info); mWorld.LocalPlayer->SetMoveSpeed(100); mWorld.LocalPlayer->SetState(State_Idle); //Test: CreateNewPlayer(0, CharacterInfo()); Ogre::SceneNode *DestMarkerNode = RootNode->createChildSceneNode(); Ogre::Entity *DestMarker = mSceneMgr->createEntity("Ent-DestMarker", "arrow.mesh"); DestMarker->setQueryFlags(0); DestMarkerNode->attachObject(DestMarker); DestMarkerNode->setVisible(false); mWorld.LocalPlayer->SetDestinationMarker(DestMarkerNode, DestMarker); mMoveDestinationIndicator = RootNode->createChildSceneNode(); Ogre::Entity* MouseIndicatorEntity = mSceneMgr->createEntity("Ent-MouseIndicator", "arrow.mesh"); MouseIndicatorEntity->setQueryFlags(0); MouseIndicatorEntity->setMaterialName("ArrowTransparent"); mMoveDestinationIndicator->attachObject(MouseIndicatorEntity); mMoveDestinationIndicator->scale(0.8, 0.8, 0.8); mEntityHoveringIndicator = RootNode->createChildSceneNode(); mEntitySelectionIndicator = RootNode->createChildSceneNode(); Ogre::Entity* HoverIndicatorEntity = mSceneMgr->createEntity("Ent-HoveringIndicator", "arrows.mesh"); Ogre::Entity* SelectionIndicatorEntity = mSceneMgr->createEntity("Ent-SelectionIndicator", "arrows.mesh"); HoverIndicatorEntity->setQueryFlags(0); SelectionIndicatorEntity->setQueryFlags(0); HoverIndicatorEntity->setMaterialName("ArrowTransparent"); mEntitySelectionIndicator->setInheritOrientation(false); mEntityHoveringIndicator->attachObject(HoverIndicatorEntity); mEntitySelectionIndicator->attachObject(SelectionIndicatorEntity); mEntityHoveringIndicator->setVisible(false); mEntitySelectionIndicator->setVisible(false); return 1; }
bool PlayerCamera::onGhostAdd(TNL::GhostConnection *theConnection) { if(!Parent::onGhostAdd(theConnection)) return false; //A parent had an error #ifdef CLIENT_SIDE if(owner() == Player::myId()) { qDebug() << "========= Got My Camera"; return(true); } else { qDebug() << "========= Got user camera:" << owner(); Ogre::Entity *entity; char entname[100]; snprintf(entname, 100, "crateent%i", entnum); entity = Application::instance()->getScene()->createEntity(entname, "cube.mesh"); entity->setQueryFlags(1 << 2); char entname2[100]; snprintf(entname2, 100, "crateent%i", entnum); _node = Application::instance()->getScene()->getRootSceneNode()->createChildSceneNode(entname2); _node->attachObject(entity); entnum++; } #endif return(true); }
void PlayersManager::createPlayer(zappy::Player *player) { Ogre::Entity *ent; Ogre::SceneNode *node; Ogre::AnimationState *anim; std::string id(NumberToString<unsigned int>(player->getId())); OPlayer *toAdd; ent = this->mSceneMgr->createEntity("Player" + id, "robot.mesh"); node = this->mSceneMgr->getRootSceneNode()-> createChildSceneNode(PLAYERNODENAME + id, Ogre::Vector3(player->getX() * Constants::SquareSize, 0, player->getY() * Constants::SquareSize)); ent->setQueryFlags(Constants::PLAYER_MASK); anim = ent->getAnimationState("Idle"); anim->setLoop(true); anim->setEnabled(true); node->attachObject(ent); player->setRendered(true); toAdd = new OPlayer(ent, node); toAdd->setSpell(this->mSceneMgr->createParticleSystem("Aureola" + id, "Examples/Aureola")); toAdd->setBroad(this->mSceneMgr->createParticleSystem("Purple" + id, "Examples/PurpleFountain")); this->mOPlayers.push_back(toAdd); }
AnimateableCharacter::AnimateableCharacter(Ogre::String name, Ogre::SceneManager *sceneMgr, OgreDetourCrowd* detourCrowd, bool debugDraw, Ogre::Vector3 position) : Character(name, sceneMgr, detourCrowd, position), mAnimState(NULL), mAnimSpeedScale(1), mDebugNode(NULL) { mNode = sceneMgr->getRootSceneNode()->createChildSceneNode(name+"Node"); mEnt = sceneMgr->createEntity(name, "Gamechar-male.mesh"); // Assign random texture int i = (int)Ogre::Math::RangeRandom(0,14); if (i > 13) i = 13; mEnt->setMaterialName("GameChar_Male_Mat_"+Ogre::StringConverter::toString(i)); mEnt->setQueryFlags(OgreRecastApplication::DEFAULT_MASK); // Exclude from ray queries mNode->attachObject(mEnt); mNode->setPosition(position); // Assign animation mAnimState= mEnt->getAnimationState("Walk"); mAnimState->setEnabled(true); mAnimState->setLoop(true); Ogre::Vector3 bBoxSize = mEnt->getBoundingBox().getSize(); Ogre::Real agentRadius = mDetourCrowd->getAgentRadius(); Ogre::Real agentHeight = mDetourCrowd->getAgentHeight(); // Set Height to match that of agent //mNode->setScale((agentRadius*2)/bBoxSize.y, agentHeight/bBoxSize.y, (agentRadius*2)/bBoxSize.y); Ogre::Real scale = agentHeight/bBoxSize.y; mNode->setScale(scale, scale, scale); // Set animation speed scaling mAnimSpeedScale = 0.35*(scale*4); // Debug draw agent mDebugNode = mNode->createChildSceneNode(name+"AgentDebugNode"); mDebugNode->setPosition(0, mDetourCrowd->m_recast->getNavmeshOffsetFromGround(), 0); Ogre::Entity* debugEnt = sceneMgr->createEntity(name+"AgentDebug", "Cylinder.mesh"); debugEnt->setMaterialName("Cylinder/Wires/LightBlue"); mDebugNode->attachObject(debugEnt); // Set marker scale to size of agent mDebugNode->setInheritScale(false); mDebugNode->setScale(agentRadius*2, agentHeight, agentRadius*2); debugEnt->setQueryFlags(OgreRecastApplication::DEFAULT_MASK); // Exclude from ray queries mDebugNode->setVisible(debugDraw); }
Ogre::Entity* ManipulatorObject::AddEntity( const STRING& meshname, const POS& worldPos, bool bOp, const ORIENT& orient, const SCALE& scale ) { static int counter = 0; Ogre::String entName("Entity_"); entName += Ogre::StringConverter::toString(counter++); Ogre::Entity* newEntity = RenderManager.m_pSceneMgr->createEntity(entName, meshname); if(!newEntity) return nullptr; Ogre::SceneNode* pNode = RenderManager.m_pSceneMgr->getRootSceneNode()->createChildSceneNode(worldPos, orient); pNode->setScale(scale); pNode->attachObject(newEntity); //每个Entity创建一个包围盒节点 Ogre::WireBoundingBox* aabb = new Ogre::WireBoundingBox; aabb->setMaterial("BaseWhiteNoLighting"); aabb->setRenderQueueGroup(Ogre::RENDER_QUEUE_OVERLAY); Ogre::SceneNode* aabbNode = pNode->createChildSceneNode(entName); aabbNode->attachObject(aabb); aabbNode->setVisible(false); _UpdateAABBOfEntity(newEntity); //设置查询掩码 newEntity->setQueryFlags(eQueryMask_Entity); SObjectInfo* objInfo = new SObjectInfo; objInfo->m_meshname = meshname; objInfo->m_pos = worldPos; objInfo->m_rot = orient; objInfo->m_scale = scale; m_objects.insert(std::make_pair(newEntity, objInfo)); //可撤销操作 if (bOp) { opObjectAddRemove* op = ManipulatorSystem.GetOperation().NewOperation<opObjectAddRemove>(); opObjectAddRemove::SOpItem item; item.bAddOrRemove = true; item.ent = newEntity; item.objInfo = *objInfo; op->AddOp(item); ManipulatorSystem.GetOperation().Commit(op); } return newEntity; }
void SceneLoader::createWall( Ogre::Vector3 pos, Ogre::Real scale ) { Ogre::Entity* ent = mSceneMgr->createEntity("atd_cube.mesh"); // Ogre::MeshPtr mesh = ent->getMesh(); // mesh->freeEdgeList(); // mesh->buildEdgeList(); ent->setCastShadows(true); ent->setQueryFlags(AugmentedTowerDefense::MASK_WALLS); Ogre::SceneNode* node = mSceneRootNode->createChildSceneNode("Wall_" + AugmentedTowerDefense::HelperClass::ToString(mWallCount)); node->setPosition(pos); node->setScale(Ogre::Vector3::UNIT_SCALE*scale); node->attachObject(ent); mWallCount++; }
void OgreWidget::placeObjectOnTerrain(const QString meshName, const Ogre::Vector3 position, const float rotationY, const Ogre::Vector3 scale) { Ogre::Quaternion rotation; QString name(meshName); name.replace(".mesh", ""); Ogre::Entity* entity = mSceneManager->createEntity(name.toStdString(), meshName.toStdString()); entity->setQueryFlags(0xFFFFFFFF); rotation.FromAngleAxis(Ogre::Degree(rotationY), Ogre::Vector3::UNIT_Y); Ogre::SceneNode* sceneNode = mSceneManager->getRootSceneNode()->createChildSceneNode( position + Ogre::Vector3(0, mTerrainGroup->getHeightAtWorldPosition(position) + mTerrainPos.y - 0.2, 0), rotation); sceneNode->setScale(scale); sceneNode->attachObject(entity); addMeshInformation(entity, sceneNode); }
/* * Create a fake Plane for Drag and Drop */ void MyFrameListener::createBackGround() { Ogre::SceneManager* mSceneMgr = Ogre::Root::getSingleton(). getSceneManager("mainSM"); Ogre::Plane *mPlane = new Ogre::Plane(Ogre::Vector3::UNIT_Z, -2); Ogre::MeshManager::getSingleton().createPlane("backPlane", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, *mPlane,800, 800, 20, 20, true, 1, 5, 5 , Ogre::Vector3::UNIT_Y); Ogre::Entity* plane = mSceneMgr->createEntity("backPlane"); plane->setQueryFlags(PLANE_DRAG_DROP); plane->setMaterialName("sheet"); Ogre::Root::getSingleton(). getSceneManager("mainSM")->getRootSceneNode()-> attachObject(plane); }
// add a control point Ogre::String CTrack::mAdd( ControlPoint tCP ) { Ogre::Entity *ent; char name[16]; sprintf(name, "ControlPoint%d", mCount++); ent = mSm->createEntity(name, "point.mesh"); ent->setQueryFlags(ObjectControl::CONTROL_POINT); Ogre::SceneNode *mCurrentObject = mSm->getRootSceneNode()->createChildSceneNode(std::string(name) + "Node", tCP.pos); mCurrentObject->attachObject(ent); mCurrentObject->setScale(0.05f, 0.05f, 0.05f); tCP.name = mCurrentObject->getName(); CPs.push_back(tCP); return mCurrentObject->getName(); }
Ogre::SceneNode* JunctionPoints::allocNode(void) { Ogre::SceneNode* node; if (mFreeNodes.empty()) { node = getIndicatorRootSceneNode()->createChildSceneNode(); Ogre::Entity* entity = getSceneManager()->createEntity(node->getName(), mBaseMesh->getName()); entity->setQueryFlags(0); //david-<< //entity->setNormaliseNormals(true); //david->> node->attachObject(entity); } else { node = mFreeNodes.back(); mFreeNodes.pop_back(); getIndicatorRootSceneNode()->addChild(node); } node->setScale(mScale, mScale, mScale); return node; }
/** * @brief Ctor. * @param entity The entity which the marker is attached to. * @param sceneManager A scene manager used to create nodes and entities. * @param terrainManager Provides height data. * @param point The location which will be marked. */ EntityPointMarker(Eris::Entity& entity, Ogre::SceneManager& sceneManager, const IHeightProvider& heightProvider, const WFMath::Point<3>& point) : mEntity(entity), mMarkerEntity(0), mMarkerNode(0), mMarkerDirectionIndicator(0), mHeightProvider(heightProvider), mPoint(point) { mMarkerNode = sceneManager.getRootSceneNode()->createChildSceneNode(); try { mMarkerEntity = sceneManager.createEntity("3d_objects/primitives/models/sphere.mesh"); //start out with a normal material mMarkerEntity->setMaterialName("/global/authoring/point"); //The material is made to ignore depth checks, so if we put it in a later queue we're //making sure that the marker is drawn on top of everything else, making it easier to interact with. mMarkerEntity->setRenderQueueGroup(Ogre::RENDER_QUEUE_9); mMarkerEntity->setRenderingDistance(300); mMarkerEntity->setQueryFlags(MousePicker::CM_NONPICKABLE); mMarkerNode->attachObject(mMarkerEntity); } catch (const std::exception& ex) { S_LOG_WARNING("Error when creating marker node." << ex); return; } mMarkerNode->setVisible(true); mMarkerDirectionIndicator = new ShapeVisual(*sceneManager.getRootSceneNode(), false); mEntity.Moved.connect(sigc::mem_fun(*this, &EntityPointMarker::entityMoved)); }
ObjectEditHandler::ObjectEditHandler(SceneDoc *Owner) { mOwner = Owner; mMode = OEM_NONE; mAxisMode = AM_NONE; mTarget = NULL; mObjectEditNode = mOwner->getSceneManager()->getRootSceneNode()->createChildSceneNode(); mRayQuery = mOwner->getSceneManager()->createRayQuery(Ogre::Ray()); mMaterials[0] = Ogre::MaterialManager::getSingletonPtr()->getByName("Editor/RedMat"); mMaterials[1] = Ogre::MaterialManager::getSingletonPtr()->getByName("Editor/GreenMat"); mMaterials[2] = Ogre::MaterialManager::getSingletonPtr()->getByName("Editor/BlueMat"); mMaterials[3] = Ogre::MaterialManager::getSingletonPtr()->getByName("Editor/ObjectIndicatorWhiteMat"); mMaterials[4] = Ogre::MaterialManager::getSingletonPtr()->getByName("Editor/ObjectIndicatorYellowMat"); ////////////////////////////////////////////////// // 碰撞检测 ////////////////////////////////////////////////// mCollisionManager = new OgreOpcode::CollisionManager(Owner->getSceneManager()); mCollisionManager->addCollClass("Object"); mCollisionManager->addCollType("Object", "Object", OgreOpcode::COLLTYPE_IGNORE); mCollisionContext = mCollisionManager->createContext("SceneObject"); Ogre::MovableObjectFactory* Factory = Ogre::Root::getSingleton().getMovableObjectFactory(Ogre::EntityFactory::FACTORY_TYPE_NAME); Ogre::NameValuePairList Params; ////////////////////////////////////////////////// // 平移放缩指示器 ////////////////////////////////////////////////// mIndicatorContext = mCollisionManager->createContext("TransScale"); mTransScaleNode = mObjectEditNode->createChildSceneNode("TransScaleIndicator"); mTransScaleNode->setScale(200.0f, 200.0f, 200.0f); // x Ogre::SceneNode *SubNode = mTransScaleNode->createChildSceneNode(); SubNode->roll(Ogre::Degree(-90.0f)); Ogre::Entity *Entity = Owner->getSceneManager()->createEntity("TransScaleXLine", "MoveArrowLineVisible.mesh"); //Entity->setQueryFlags(0); // 参与查询 Entity->setCastShadows(false); Entity->setMaterial(mMaterials[0]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_TRANS_SCALE_X] = Entity; Entity = Owner->getSceneManager()->createEntity("TransScaleXCone", "MoveArrowConeVisible.mesh"); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[0]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); Params["mesh"] = "MoveArrowCollision.mesh"; Entity = (Ogre::Entity*)Factory->createInstance("TransScaleXCol", Owner->getSceneManager(), &Params); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setVisible(false); SubNode->attachObject(Entity); OgreOpcode::CollisionObject *CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_TRANS_SCALE_X; // y SubNode = mTransScaleNode; Entity = Owner->getSceneManager()->createEntity("TransScaleYLine", "MoveArrowLineVisible.mesh"); //Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[1]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_TRANS_SCALE_Y] = Entity; Entity = Owner->getSceneManager()->createEntity("TransScaleYCone", "MoveArrowConeVisible.mesh"); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[1]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); Params["mesh"] = "MoveArrowCollision.mesh"; Entity = (Ogre::Entity*)Factory->createInstance("TransScaleYCol", Owner->getSceneManager(), &Params); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setVisible(false); SubNode->attachObject(Entity); CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_TRANS_SCALE_Y; // z SubNode = mTransScaleNode->createChildSceneNode(); SubNode->pitch(Ogre::Degree(90)); Entity = Owner->getSceneManager()->createEntity("TransScaleZLine", "MoveArrowLineVisible.mesh"); //Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[2]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_TRANS_SCALE_Z] = Entity; Entity = Owner->getSceneManager()->createEntity("TransScaleZCone", "MoveArrowConeVisible.mesh"); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[2]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); Params["mesh"] = "MoveArrowCollision.mesh"; Entity = (Ogre::Entity*)Factory->createInstance("TransScaleZCol", Owner->getSceneManager(), &Params); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setVisible(false); SubNode->attachObject(Entity); CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_TRANS_SCALE_Z; // box SubNode = mTransScaleNode; Params["mesh"] = "Box1m.mesh"; Entity =(Ogre::Entity*)Factory->createInstance("TransScaleAll", Owner->getSceneManager(), &Params); //Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[3]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_TRANS_SCALE_ALL] = Entity; CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_TRANS_SCALE_ALL; mIndicatorContext->reset(); mObjectEditNode->removeChild(mTransScaleNode); ////////////////////////////////////////////////// // 旋转指示器 ////////////////////////////////////////////////// mIndicatorContext = mCollisionManager->createContext("Rotate"); mRotateNode = mObjectEditNode->createChildSceneNode("RotateIndicator"); mRotateNode->setScale(200.0f, 200.0f, 200.0f); // x SubNode = mRotateNode->createChildSceneNode(); SubNode->roll(Ogre::Degree(90)); Entity = Owner->getSceneManager()->createEntity("RotateX", "RotationRingVisible.mesh"); //Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[0]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_ROTATE_X] = Entity; Params["mesh"] = "RotationRingCollision.mesh"; Entity =(Ogre::Entity*)Factory->createInstance("RotateXCol", Owner->getSceneManager(), &Params); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setVisible(false); SubNode->attachObject(Entity); CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_ROTATE_X; // y SubNode = mRotateNode; Entity = Owner->getSceneManager()->createEntity("RotateY", "RotationRingVisible.mesh"); //Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[1]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_ROTATE_Y] = Entity; Params["mesh"] = "RotationRingCollision.mesh"; Entity =(Ogre::Entity*)Factory->createInstance("RotateYCol", Owner->getSceneManager(), &Params); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setVisible(false); SubNode->attachObject(Entity); CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_ROTATE_Y; // z SubNode = mRotateNode->createChildSceneNode(); SubNode->pitch(Ogre::Degree(90.0f)); Entity = Owner->getSceneManager()->createEntity("RotateZ", "RotationRingVisible.mesh"); //Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setMaterial(mMaterials[2]); Entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_8); SubNode->attachObject(Entity); mTransformEntities[AM_ROTATE_Z] = Entity; Params["mesh"] = "RotationRingCollision.mesh"; Entity =(Ogre::Entity*)Factory->createInstance("RotateZCol", Owner->getSceneManager(), &Params); Entity->setQueryFlags(0); Entity->setCastShadows(false); Entity->setVisible(false); SubNode->attachObject(Entity); CollisionObject = AddCollisionEntity(mIndicatorContext, Entity); mCollisionObjectToAxisMode[CollisionObject] = AM_ROTATE_Z; mIndicatorContext->reset(); mObjectEditNode->removeChild(mRotateNode); }
//这个函数会在初始化调用 void FCScene::doEnable(void) { _map->active(); using namespace Ogre; //从系统中得到Ogre的场景管理器 SceneManager * sm = OgreGraphicsManager::getSingleton().getSceneManager(); //把其场景清空 sm->clearScene(); Plane plane; plane.normal = Vector3::UNIT_Y; plane.d = 100; FCKnowledge::getSingleton().mapInfo().setGround(-plane.d); FCKnowledge::getSingleton().mapInfo().enable(); MeshManager::getSingleton().createPlane("Myplane", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 512, 512,20,20,true,1,60,60,Vector3::UNIT_Z); Ogre::Entity* pPlaneEnt = sm->createEntity( "plane", "Myplane" ); pPlaneEnt->setMaterialName("Examples/Rockwall"); pPlaneEnt->setQueryFlags(0); sm->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt); //设置环境光 sm->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); //创建天空盒 //sm->setSkyBox(true, "Examples/SpaceSkyBox", 50 ); // 创建一个光源 Light* l = sm->createLight("MainLight"); //设置光源位置 l->setPosition(20,80,50); //下面代码随机 放置砖块 NameValueList par; for(int i = 1; i< 16 *16; ++i) { if(rand()%2 == 0) { par["pos"] = i; ActorPtr wall = Orz::GameFactories::getInstance().createActor("FCWall",IDManager::BLANK, &par ); getWorld()->comeIn(wall); _walls.push_back(wall); } } //在这里我们通过XML文件FighteingClub.xml 得到两个格斗者的名字,然后创建他们 并给他们位置和ID XMLFighterLoader loader; if(loader.load("FighteingClub.xml")) { { par["pos"] = 10; par["id"] = 0; ActorPtr fighter = Orz::GameFactories::getInstance().createActor(loader.getFighter1(),IDManager::BLANK, &par ); getWorld()->comeIn(fighter); _enemies.push_back(fighter); } { par["pos"] = 20; par["id"] = 1; ActorPtr fighter = Orz::GameFactories::getInstance().createActor(loader.getFighter2(),IDManager::BLANK, &par ); getWorld()->comeIn(fighter); _enemies.push_back(fighter); } } else//如果XML读取失败 那么就采用默认的 "FCFighter" { for(int i =0; i<2; ++i) { par["id"] = i; par["pos"] = i*10; ActorPtr fighter = Orz::GameFactories::getInstance().createActor("FCFighter",IDManager::BLANK, &par ); getWorld()->comeIn(fighter); _enemies.push_back(fighter); } } }
void ObjectNode::createEntities(Ogre::SceneNode *target_node, Ogre::SceneManager *scene_manager, LibGens::ModelLibrary *model_library, LibGens::MaterialLibrary *material_library, LibGens::ObjectProduction *object_production, string slot_id_name) { string model_name=object->queryEditorModel(slot_id_name, OBJECT_NODE_UNKNOWN_MESH); string skeleton_name=object->queryEditorSkeleton(slot_id_name, ""); string animation_name=object->queryEditorAnimation(slot_id_name, ""); string preview_box_x=object->queryExtraName(OBJECT_NODE_EXTRA_PREVIEW_BOX_X, ""); string preview_box_y=object->queryExtraName(OBJECT_NODE_EXTRA_PREVIEW_BOX_Y, ""); string preview_box_z=object->queryExtraName(OBJECT_NODE_EXTRA_PREVIEW_BOX_Z, ""); string preview_box_x_scale=object->queryExtraName(OBJECT_NODE_EXTRA_PREVIEW_BOX_X_SCALE, ""); string preview_box_y_scale=object->queryExtraName(OBJECT_NODE_EXTRA_PREVIEW_BOX_Y_SCALE, ""); string preview_box_z_scale=object->queryExtraName(OBJECT_NODE_EXTRA_PREVIEW_BOX_Z_SCALE, ""); if ((preview_box_x.size()) || (preview_box_y.size()) || (preview_box_z.size())) { LibGens::ObjectElementFloat *p_x = (LibGens::ObjectElementFloat *) object->getElement(preview_box_x); LibGens::ObjectElementFloat *p_y = (LibGens::ObjectElementFloat *) object->getElement(preview_box_y); LibGens::ObjectElementFloat *p_z = (LibGens::ObjectElementFloat *) object->getElement(preview_box_z); Ogre::Vector3 new_scale = preview_box_node->getScale(); float scale_f=0.0f; float scale_x = 1.0f; float scale_y = 1.0f; float scale_z = 1.0f; if (preview_box_x_scale.size()) FromString<float>(scale_x, preview_box_x_scale, std::dec); if (preview_box_y_scale.size()) FromString<float>(scale_y, preview_box_y_scale, std::dec); if (preview_box_z_scale.size()) FromString<float>(scale_z, preview_box_z_scale, std::dec); // Check if elements were found. If not, try reading the float value from the string if (p_x) new_scale.x = p_x->value; else { FromString<float>(scale_f, preview_box_x, std::dec); new_scale.x = scale_f; } if (p_y) new_scale.y = p_y->value; else { FromString<float>(scale_f, preview_box_y, std::dec); new_scale.y = scale_f; } if (p_z) new_scale.z = p_z->value; else { FromString<float>(scale_f, preview_box_z, std::dec); new_scale.z = scale_f; } new_scale.x = new_scale.x * scale_x; new_scale.y = new_scale.y * scale_y; new_scale.z = new_scale.z * scale_z; // Check for valid scaling values if (new_scale.x <= 0.0) new_scale.x = 0.1; if (new_scale.y <= 0.0) new_scale.y = 0.1; if (new_scale.z <= 0.0) new_scale.z = 0.1; preview_box_node->setScale(new_scale); } if ((object->getName() == OBJECT_NODE_OBJECT_PHYSICS) && object_production) { bool found_model=false; LibGens::ObjectElement *element=object->getElement(OBJECT_NODE_OBJECT_PHYSICS_ELEMENT_TYPE); if (element) { string type_name=static_cast<LibGens::ObjectElementString *>(element)->value; if (type_name != current_type_name) { current_type_name = type_name; destroyAllAttachedMovableObjects(target_node); } else { return; } LibGens::ObjectPhysics *object_physics = object_production->getObjectPhysics(type_name); if (object_physics) { vector<string> models=object_physics->getModels(); vector<string> motions=object_physics->getMotions(); vector<string> motion_skeletons=object_physics->getMotionSkeletons(); for (size_t i=0; i<models.size(); i++) { string model_id=models[i]; string skeleton_id = ""; string animation_id = ""; LibGens::Model *model=model_library->getModel(model_id); if (i < motions.size()) { animation_id = motions[i]; } if (i < motion_skeletons.size()) { skeleton_id = motion_skeletons[i]; } if (model) { prepareSkeletonAndAnimation(skeleton_id, animation_id); buildModel(target_node, model, model->getName(), skeleton_id, scene_manager, material_library, EDITOR_NODE_QUERY_OBJECT, GENERAL_MESH_GROUP, false); createAnimationState(animation_id); found_model = true; } } } } if (found_model) { return; } else { current_model_name = ""; } } if ((model_name != current_model_name) || (skeleton_name != current_skeleton_name) || (animation_name != current_animation_name)) { current_model_name = model_name; current_skeleton_name = skeleton_name; current_animation_name = animation_name; destroyAllAttachedMovableObjects(target_node); } else { return; } string model_id=model_name; model_id.resize(model_id.size() - ((string)OBJECT_NODE_MODEL_EXTENSION).size()); string skeleton_id=""; if (skeleton_name.size()) { skeleton_id=skeleton_name; skeleton_id.resize(skeleton_id.size() - ((string)OBJECT_NODE_SKELETON_EXTENSION).size()); } string animation_id=""; if (animation_name.size()) { animation_id=animation_name; animation_id.resize(animation_id.size() - ((string)OBJECT_NODE_ANIMATION_EXTENSION).size()); } if (model_name.find(OBJECT_NODE_MODEL_EXTENSION) != string::npos) { LibGens::Model *model=model_library->getModel(model_id); if (model) { prepareSkeletonAndAnimation(skeleton_id, animation_id); buildModel(target_node, model, model->getName(), skeleton_id, scene_manager, material_library, EDITOR_NODE_QUERY_OBJECT, GENERAL_MESH_GROUP, false); } else { Ogre::Entity *entity = scene_manager->createEntity(OBJECT_NODE_UNKNOWN_MESH); entity->setQueryFlags(EDITOR_NODE_QUERY_OBJECT); target_node->attachObject(entity); } } else if (model_name.find(OBJECT_NODE_MESH_EXTENSION) != string::npos) { Ogre::Entity *entity = scene_manager->createEntity(model_name); entity->setQueryFlags(EDITOR_NODE_QUERY_OBJECT); target_node->attachObject(entity); } createAnimationState(animation_id); // Create PreviewBox if necessary if ((preview_box_x.size()) || (preview_box_y.size()) || (preview_box_z.size())) { preview_box_entity = scene_manager->createEntity("preview_box.mesh"); preview_box_entity->setRenderQueueGroup(Ogre::RENDER_QUEUE_MAX); preview_box_entity->setQueryFlags(EDITOR_NODE_QUERY_PREVIEW_BOX); preview_box_node->attachObject(preview_box_entity); } }
void GameRenderer::initialize(){ DEBUG("GameRenderer::initialize"); Client::getInstance().getOgreManager().getRoot()->addFrameListener(this); // Tray manager, hacky fix for intel graphics mTrayMgr = new OgreBites::SdkTrayManager( "InterfaceName", Client::getInstance().getOgreManager().getWindow(), Client::getInstance().getOISManager().getMouse(), this); mTrayMgr->showFrameStats(OgreBites::TL_BOTTOMLEFT); mTrayMgr->toggleAdvancedFrameStats(); mTrayMgr->showLogo(OgreBites::TL_BOTTOMRIGHT); mTrayMgr->hideCursor(); //cameraMan = new OgreBites::SdkCameraMan(Client::getInstance().getOgreManager().getCamera()); Client::getInstance().getOISManager().addMouseListener(this); Client::getInstance().getOISManager().addKeyListener(this); Ogre::Plane plane(Ogre::Vector3::UNIT_Y, 0); Ogre::MeshManager::getSingleton().createPlane("ground", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 1500, 1500, 20, 20, true, 1, 5, 5, Ogre::Vector3::UNIT_Z); Ogre::Entity* entGround = Client::getInstance() .getOgreManager() .getSceneManager() ->createEntity("GroundEntity", "ground"); Ogre::SceneNode* groundNode = Client::getInstance().getOgreManager().getSceneManager()->getRootSceneNode()->createChildSceneNode(); groundNode->attachObject(entGround); groundNode->scale(.1, .1, .1); entGround->setMaterialName("Examples/Rockwall"); entGround->setCastShadows(false); entGround->setQueryFlags(0); //point light Ogre::Light* pointLight = Client::getInstance().getOgreManager().getSceneManager()->createLight("pointLight"); pointLight->setType(Ogre::Light::LT_POINT); pointLight->setPosition(Ogre::Vector3(0, 10, 10)); pointLight->setDiffuseColour(1.0, 1.0, 1.0); pointLight->setSpecularColour(1.0, 1.0, 1.0); Client::getInstance() .getOgreManager() .getSceneManager() ->setAmbientLight(Ogre::ColourValue(0.5, 0.5, 0.5)); orb = new OgreOrb(Client::getInstance().getOgreManager().getSceneManager()); felhound = new OgreFelhound(Client::getInstance().getOgreManager().getSceneManager(),0); //TODO: magic strings cameraStyles["TOCameraMan"] = new TOCameraManStyle(); cameraStyles["WC3Style"] = new WC3CameraStyle(); //TODO: configurable default setCameraStyle("WC3Style"); DEBUG("GameRenderer::initialize done"); }
void WalkabilityMap::init(TWalkabilityMapParameters tWalkabilityMapParameters,Ogre::SceneManager * pSceneManager,Ogre::SceneNode * pDebugObjects) { unsigned int i,j; mDebugObjects=pDebugObjects; mSceneManager=pSceneManager; mName=tWalkabilityMapParameters.name; mDebugObjects->createChildSceneNode("walkability#"+tWalkabilityMapParameters.name); myLines.clear(); myNodes.clear(); mDisplays.clear(); //init node numbers mNodeNumbers.clear(); for(i=0;i<tWalkabilityMapParameters.walkabilityNodes.size();i++) { mNodeNumbers[tWalkabilityMapParameters.walkabilityNodes[i].nodeName]=i; } //init graph mGraph.clear(); mGraph = Graph(mNodeNumbers.size()); Ogre::SceneNode * pSceneNode; Ogre::Entity * pEntity; Ogre::SceneNode * pEntityDebugNode; ObjectTextDisplay* pDisplay; //create graph nodes for(i=0;i<tWalkabilityMapParameters.walkabilityNodes.size();i++) { //Logger::getInstance()->log("Adding node "+tWalkabilityMapParameters.walkabilityNodes[i].nodeName); if(pSceneManager->hasSceneNode(tWalkabilityMapParameters.walkabilityNodes[i].nodeName)) { pSceneNode=pSceneManager->getSceneNode(tWalkabilityMapParameters.walkabilityNodes[i].nodeName); } else { pSceneNode=pSceneManager->getRootSceneNode()->createChildSceneNode(tWalkabilityMapParameters.walkabilityNodes[i].nodeName); pSceneNode->setPosition(tWalkabilityMapParameters.walkabilityNodes[i].position); pSceneNode->setOrientation(tWalkabilityMapParameters.walkabilityNodes[i].orientation); } mGraph[getNodeNumber(tWalkabilityMapParameters.walkabilityNodes[i].nodeName)].mSceneNode=pSceneNode; //create graphics debug objects std::string debugName="walkability#"+tWalkabilityMapParameters.name+"#"+tWalkabilityMapParameters.walkabilityNodes[i].nodeName; pEntityDebugNode=mDebugObjects->createChildSceneNode(debugName); pEntityDebugNode->setPosition(pSceneNode->getPosition()); pEntityDebugNode->setVisible(mVisible); pEntity=pSceneManager->createEntity(debugName,"node.mesh"); pEntity->setMaterialName("red"); pEntity->setVisible(mVisible); pEntity->setCastShadows(false); pEntity->setQueryFlags(OUAN::QUERYFLAGS_NONE); pEntityDebugNode->attachObject(pEntity); myNodes.push_back(pEntity); pDisplay = new ObjectTextDisplay(pEntity,Application::getInstance()->getCameraManager()->getCamera()); pDisplay->setText(tWalkabilityMapParameters.walkabilityNodes[i].nodeName); pDisplay->enable(mVisible); mDisplays.push_back(pDisplay); } //add graph edges for(i=0;i<tWalkabilityMapParameters.walkabilityNodes.size();i++) { for(j=0;j<tWalkabilityMapParameters.walkabilityNodes[i].neighbors.size();j++) { //Logger::getInstance()->log("Adding edge "+tWalkabilityMapParameters.walkabilityNodes[i].nodeName+"-" // +tWalkabilityMapParameters.walkabilityNodes[i].neighbors[j]); if(hasNode(tWalkabilityMapParameters.walkabilityNodes[i].neighbors[j])) { add_edge(getNodeNumber(tWalkabilityMapParameters.walkabilityNodes[i].nodeName.c_str()), getNodeNumber(tWalkabilityMapParameters.walkabilityNodes[i].neighbors[j].c_str()), mGraph); } } } //set graph edges properties Graph::vertex_descriptor v1,v2; Ogre::SceneNode * pSceneNode1; Ogre::SceneNode * pSceneNode2; Graph::edge_descriptor e; boost::graph_traits<Graph>::edge_iterator eit,eend; boost::property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, mGraph); i=0; Line3D *myLine; for (tie(eit, eend) = edges(mGraph); eit != eend; ++eit) { Graph::edge_descriptor e = *eit; v1=source(e, mGraph); v2=target(e, mGraph); pSceneNode1=mGraph[v1].mSceneNode; pSceneNode2=mGraph[v2].mSceneNode; weightmap[e]=pSceneNode1->getPosition().distance(pSceneNode2->getPosition()); //create graphics debug objects myLine = new Line3D(); myLine->addPoint(pSceneNode1->getPosition()); myLine->addPoint(pSceneNode2->getPosition()); myLine->setMaterial("black"); myLine->setCastShadows(false); myLine->drawLines(); mDebugObjects->attachObject(myLine); mDebugObjects->setVisible(mVisible); myLines.push_back(myLine); } //print graph information Logger::getInstance()->log("[TrajectoryManager] Walkability map vertices"); boost::graph_traits<Graph>::vertex_iterator vit,vend; for (tie(vit, vend) = vertices(mGraph); vit != vend; ++vit) { Logger::getInstance()->log("Vertex "+mGraph[*vit].mSceneNode->getName()); } Logger::getInstance()->log("[TrajectoryManager] Walkability map edges"); for (tie(eit, eend) = edges(mGraph); eit != eend; ++eit) { v1=source(*eit, mGraph); v2=target(*eit, mGraph); Logger::getInstance()->log("Edge "+mGraph[v1].mSceneNode->getName()+"-"+mGraph[v2].mSceneNode->getName()+ " distance:"+Ogre::StringConverter::toString(Ogre::Real(weightmap[*eit]))); } }