Ball* Application::createBall(Ogre::String nme, GameObject::objectType tp, Ogre::String meshName, int x, int y, int z, Ogre::Real scale, Ogre::SceneManager* scnMgr, GameManager* ssm, Ogre::Real mss, Ogre::Real rest, Ogre::Real frict, bool kinematic, Simulator* mySim) { createRootEntity(nme, meshName, x, y, z); Ogre::SceneNode* sn = mSceneManager->getSceneNode(nme); Ogre::Entity* ent = SceneHelper::getEntity(mSceneManager, nme, 0); const btTransform pos; OgreMotionState* ms = new OgreMotionState(pos, sn); sn->setScale(scale,scale,scale); ent->setMaterialName("ball"); Ball* obj = new Ball(nme, tp, mSceneManager, ssm, sn, ent, ms, mySim, mss, rest, frict, scale, kinematic); obj->addToSimulator(); return obj; }
Ogre::SceneNode* createBox(Ogre::SceneManager* sceneMgr, Ogre::String name) { // create an ordinary Ogre mesh with texture Ogre::Entity* boxEnt = sceneMgr->createEntity(name , "cube.mesh"); // we need the bounding box of the cube.mesh to set the size of the Bullet box Ogre::AxisAlignedBox boxBb = boxEnt->getBoundingBox(); //Ogre::Vector3 size = boxBb.getSize(); boxEnt->setMaterialName("Examples/BumpyMetal"); // create the node Ogre::SceneNode* boxNode = sceneMgr->getRootSceneNode()->createChildSceneNode(); boxNode->attachObject( boxEnt ); return boxNode; }
Penguin::Penguin(Ogre::SceneManager* sceneMgr, std::string name) { Ogre::Entity* entPenguin = sceneMgr->createEntity(name, "penguin.mesh"); mAnimationState = entPenguin->getAnimationState("amuse"); mAnimationState->setLoop(true); mAnimationState->setEnabled(true); entPenguin->setCastShadows(true); Ogre::SceneNode* penguinNode = sceneMgr->getRootSceneNode()->createChildSceneNode(name, Ogre::Vector3(0,30,0)); penguinNode->attachObject(entPenguin); penguinNode->scale(60 / 63.0057, 50 / 47.99059, 50 / 49.27139); Ogre::Camera* cam = sceneMgr->getCamera("GameCam"); cameraNode = penguinNode->createChildSceneNode("CameraNode"); cameraNode->attachObject(cam); setNode(penguinNode); }
void RenderEntityComp::_create(const ZEntityResource* res, Ogre::SceneManager* scnMgr, Ogre::SceneNode* node) { Ogre::Entity* ent = scnMgr->createEntity(res->getKey(), res->getResourceName()); ent->setMaterialName("PRJZ/MinecraftCharacter"); auto scale = World::WorldScale::computeAWorldScale(); if(!ent) OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Failed to create Entity", "RenderEntityComp::_create"); //Assume the center is is at units / 2.0 _node = node->createChildSceneNode(); _node->attachObject(ent); _node->setScale(scale.metersPerUnit, scale.metersPerUnit, scale.metersPerUnit); // childNode->translate(0.0f, -scale.unitsPerMeter / 2.0, 0.0f); _node->setVisible(false); }
void SelectionBox::performSelection(std::list<AgentId> &selection, Ogre::Camera *mCamera) { if((mRight - mLeft) * (mBottom - mTop) < 0.0001) return; float left = (mLeft + 1.f) / 2.f; float right = (mRight + 1.f) / 2.f; float top = (1.f - mBottom) / 2.f; float bottom = (1.f - mTop) / 2.f; Ogre::Ray topLeft = mCamera->getCameraToViewportRay(left, top); Ogre::Ray topRight = mCamera->getCameraToViewportRay(right, top); Ogre::Ray bottomLeft = mCamera->getCameraToViewportRay(left, bottom); Ogre::Ray bottomRight = mCamera->getCameraToViewportRay(right, bottom); // These planes have now defined an "open box" which extends to infinity in front of the camera. You can think of // the rectangle we drew with the mouse as being the termination point of the box just in front of the camera. Ogre::PlaneBoundedVolume vol; const Ogre::Real min = .1, max = 500; vol.planes.push_back(Ogre::Plane(topLeft.getPoint(min), topRight.getPoint(min), bottomRight.getPoint(min))); // front plane vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), topLeft.getPoint(max), topRight.getPoint(max))); // top plane vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), bottomLeft.getPoint(max), topLeft.getPoint(max))); // left plane vol.planes.push_back(Ogre::Plane(bottomLeft.getOrigin(), bottomRight.getPoint(max), bottomLeft.getPoint(max))); // bottom plane vol.planes.push_back(Ogre::Plane(topRight.getOrigin(), topRight.getPoint(max), bottomRight.getPoint(max))); // right plane Ogre::PlaneBoundedVolumeList volList; volList.push_back(vol); mVolQuery->setVolumes(volList); Ogre::SceneQueryResult result = mVolQuery->execute(); // Finally we need to handle the results of the query. First we will deselect all previously selected objects, // then we will select all objects which were found by the query. std::list<Ogre::SceneNode *> nodes; Ogre::SceneQueryResultMovableList::iterator iter; for(iter = result.movables.begin(); iter != result.movables.end(); ++iter) { Ogre::MovableObject *movable = *iter; if(movable->getMovableType().compare("Entity") == 0) { Ogre::Entity *pentity = static_cast<Ogre::Entity *>(movable); nodes.push_back(pentity->getParentSceneNode()); } } mEngine->level()->getAgentsIdsFromSceneNodes(nodes, selection); }
void RttManager::CDepthReflectionListener::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt) { Hydrax *mHydrax = mRttManager->mHydrax; mHydrax->getMesh()->getEntity()->setVisible(false); Ogre::SceneManager::MovableObjectIterator EntityIterator = mHydrax->getSceneManager()->getMovableObjectIterator("Entity"); Ogre::Entity* CurrentEntity; unsigned int k; mMaterials.empty(); while (EntityIterator.hasMoreElements()) { CurrentEntity = static_cast<Ogre::Entity*>(EntityIterator.peekNextValue()); for(k = 0; k < CurrentEntity->getNumSubEntities(); k++) { mMaterials.push(CurrentEntity->getSubEntity(k)->getMaterialName()); CurrentEntity->getSubEntity(k)->setMaterialName(mHydrax->getMaterialManager()->getMaterial(MaterialManager::MAT_DEPTH)->getName()); } EntityIterator.moveNext(); } mRttManager->mPlanes[RTT_DEPTH_REFLECTION]->getParentNode()->translate(0,-mHydrax->getPlanesError(),0); bool IsInUnderwaterError = false; if (mHydrax->getCamera()->getDerivedPosition().y > mRttManager->mPlanes[RTT_DEPTH_REFLECTION]->getParentNode()->getPosition().y) { mCameraPlaneDiff = 0; IsInUnderwaterError = true; } else { mCameraPlaneDiff = 0; } mHydrax->getCamera()->enableReflection(mRttManager->mPlanes[RTT_DEPTH_REFLECTION]); if (!IsInUnderwaterError) { mHydrax->getCamera()->enableCustomNearClipPlane(mRttManager->mPlanes[RTT_DEPTH_REFLECTION]); } }
void MainWindow::updateOGRE() { QMutexLocker locker(&mutex); static bool updateGUI=true; Ogre::Root* mRoot = Ogre::Root::getSingletonPtr(); mRoot->_fireFrameStarted(); // loop through ogre widgets and update animation QList<OgreWidget*> rendlist = this->findChildren<OgreWidget*>(); foreach (OgreWidget* w, rendlist) { // update animation for OgreWidget's sceneManager if (w->mRenderWindow && w->updatesEnabled()) { // update OgreWidget w->update(); //emit w->paintEvent(new QPaintEvent(w->rect())); for (Ogre::SceneManager::MovableObjectIterator mit = w->getSceneManager()->getMovableObjectIterator("Entity"); mit.hasMoreElements(); mit.moveNext() ) { Ogre::Entity *entity = static_cast<Ogre::Entity*>(mit.peekNextValue()); if (updateGUI) { updateGUI = false; } // check has skeleton to avoid crash for non animable entities if (entity->hasSkeleton()) { for (Ogre::AnimationStateIterator animIt = entity->getAllAnimationStates()->getAnimationStateIterator(); animIt.hasMoreElements(); animIt.moveNext() ) { Ogre::AnimationState *animState = animIt.peekNextValue(); if ( animState->getEnabled() ) { //std::cout << entity->getName() << " ZZZZZZZZZZZ " << animState->getAnimationName(); animState->addTime(w->getRenderWindow()->getBestFPS()/10000); } } } } } } mRoot->_fireFrameRenderingQueued(); mRoot->_fireFrameEnded(); }
//----------------------------------------------------------------------------- Ogre::SceneNode* SSAOApp::_loadMesh(const Ogre::String &_name, const Ogre::Vector3 &_pos) { std::string entityName = _name+Ogre::StringConverter::toString(mScenePairs.size()); Ogre::Entity *ent = mSceneMgr->createEntity(entityName, _name+".mesh"); Ogre::SceneNode *node = mSceneMgr->getRootSceneNode()->createChildSceneNode(ent->getName()+"Node", _pos); ent->setMaterialName("SSAO/DiffuseLight_GBuffer"); node->attachObject(ent); mScenePairs.push_back(SSAOApp::ScenePair(ent, node)); return node; }
OgreCharacterController::OgreCharacterController(Ogre::Camera * Camera, const Ogre::String& name, const Ogre::Vector3& position) : CharacterController(Camera, position, name, "Sinbad.mesh", Ogre::Vector3(3, 3, 3)), lastTop(0), lastBase(0), mSword1(0), mSword2(0), swordsOut(false), sliceDir(false), animTimer(0) { Ogre::SceneManager * smgr = Camera->getSceneManager(); Ogre::Entity * ent = getEntity(); ent->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE); mSword1 = smgr->createEntity("Sword1", "Sword.mesh"); mSword2 = smgr->createEntity("Sword2", "Sword.mesh"); ent->attachObjectToBone("Sheath.L", mSword1); ent->attachObjectToBone("Sheath.R", mSword2); getTargetNode()->setFixedYawAxis(true); }
/* * 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); }
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); }
Mesh* OgreSubsystem::createMesh(String mesh,String name) { String nombre = name; if(name=="AUTO_NAME_ME") { nombre = "OryxSceneNodeAutoNamed"+StringUtils::toString(mAutoNameIndex); ++mAutoNameIndex; } Ogre::Entity* ent = mSceneManager->createEntity(nombre,mesh); Ogre::SceneNode* node = mSceneManager->createSceneNode(nombre); node->attachObject(ent); ent->setCastShadows(false); Mesh* m = new Mesh(nombre,node,ent); mSceneNodes.push_back(m); return m; }
void Player::stopAnimation(std::string anim) { Ogre::SceneManager::MovableObjectIterator iterator = SceneManager()->getMovableObjectIterator("Entity"); while(iterator.hasMoreElements()) { Ogre::Entity* e = static_cast<Ogre::Entity*>(iterator.getNext()); if (e->hasSkeleton()) { Ogre::AnimationState *animation = e->getAnimationState(anim); animation->setEnabled(false); animation->setTimePosition(0); } } }
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 GameMain::createScene(void) { createCamera(); // Camera createViewports(); // Viewport createEnvir(); // Environment: Light, Sky, etc. //------------------------- // 地平面 Ogre::MeshManager::getSingleton().createPlane("floor", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::Plane(Ogre::Vector3::UNIT_Y, 0), 100, 100, 10, 10, true, 1, 10, 10, Ogre::Vector3::UNIT_Z); // create a floor entity, give it a material, and place it at the origin Ogre::Entity* floor = mSceneMgr->createEntity("Floor", "floor"); floor->setMaterialName("Examples/Rockwall"); floor->setCastShadows(false); mSceneMgr->getRootSceneNode()->attachObject(floor); //------------------------- // 创建障碍物分布地图 //------------------------- // 创建障碍物 /*Ogre::SceneNode * boxNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); Entity * boxEntity = mSceneMgr->createEntity("Box","cube.mesh"); boxEntity->setMaterialName("Examples/BumpyMetal"); boxNode->attachObject( boxEntity ); boxNode->scale( 0.01f, 0.01f, 0.01f ); boxNode->setPosition( 0,0.5,0 ); boxNodes.push_back( boxNode ); boxEntitys.push_back( boxEntity );*/ Ogre::SceneNode * ogreHeadNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); Entity * ogreHeadEntity = mSceneMgr->createEntity("OgreHead","ogrehead.mesh"); ogreHeadNode->attachObject( ogreHeadEntity ); ogreHeadNode->scale( 0.02f, 0.02f, 0.02f ); //ogreHeadNode->setPosition( 1, 0, 1 ); ogreHeadNode->setPosition( 15, 0.5, -20 ); boxNodes.push_back( ogreHeadNode ); boxEntitys.push_back( ogreHeadEntity ); //------------------------- // 创建角色 mPlayer = new GamePlayer( mCamera, ogreHeadNode ); }
void Actor::AddBoneVisualizer() { SkeletonInstance* pSkeletonInstance = _pBodyEntity->getSkeleton(); if (!pSkeletonInstance) { return; } Skeleton::BoneIterator it = pSkeletonInstance->getBoneIterator(); while (it.hasMoreElements()) { Bone* pBone = it.getNext(); Bone::ChildNodeIterator cit = pBone->getChildIterator(); int iCount = 0; while (cit.hasMoreElements()) { Node* pChild = cit.getNext(); iCount++; String strName = pBone->getName() + "_" + pChild->getName(); Ogre::Entity* ent = OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity(strName, "bone.mesh"); TagPoint* pTag = _pBodyEntity->attachObjectToBone(pBone->getName(), ent); ent->setVisible(_bShowBone); _Entitys.push_back(ent); _BoneVisuals[pTag] = pChild; } if (iCount == 0) { Ogre::Entity* ent = OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity(pBone->getName(), "bone.mesh"); TagPoint* pTag = _pBodyEntity->attachObjectToBone(pBone->getName(), ent); ent->setVisible(_bShowBone); _Entitys.push_back(ent); _BoneVisuals[pTag] = 0; } } _UpdateBoneVisualizer(); }
void Cube::save(Ogre::String file) { if (rndCounter == 0) { std::ofstream output(file.c_str()); // Write cube size output << size << std::endl; for (int i = 0; i < size; ++i) for (int j = 0; j < size; ++j) for (int k = 0; k < size; ++k) { CubeElement *e = data[i][j][k]; Ogre::Entity *ent = static_cast<Ogre::Entity*>(e->node->getAttachedObject(0)); Ogre::SceneNode *node = e->node; // Write name, indexes and position output << node->getName() << "\n" << "\t" << i << " " << j << " " << k << "\n" // index in data array << "\t" << node->getPosition().x << " " << node->getPosition().y << " " << node->getPosition().z << "\n"; // position // Write orientation Ogre::Vector3 orient_axis; Ogre::Degree orient_angle; node->getOrientation().ToAngleAxis(orient_angle, orient_axis); output << "\t" << orient_axis.x << " " << orient_axis.y << " " << orient_axis.z << " " // orientation axis << orient_angle.valueDegrees() << "\n"; // orientation angle output << "\t" << ent->getSubEntity(0)->getMaterialName() << "\n" << "\t" << ent->getSubEntity(1)->getMaterialName() << "\n" << "\t" << ent->getSubEntity(2)->getMaterialName() << "\n" << "\t" << ent->getSubEntity(3)->getMaterialName() << "\n" << "\t" << ent->getSubEntity(4)->getMaterialName() << "\n" << "\t" << ent->getSubEntity(5)->getMaterialName() << "\n"; // Write pivot info output << "\t" << e->isPivot << "\n"; if (e->isPivot) { // pivot indexes output << "\t" << e->pivotArrays[0] << " " << e->pivotArrayIndexes[0] << "\n" << "\t" << e->pivotArrays[1] << " " << e->pivotArrayIndexes[1] << "\n"; } // flush output << std::endl; } output.close(); } }
const char *mesh_anim_name ( void *mesh, int index ) { Ogre::Entity *e = static_cast<Ogre::Entity *> ( mesh ); auto iter = e->getAllAnimationStates()->getAnimationStateIterator(); int c = 0; while ( iter.hasMoreElements() ) { auto s = iter.getNext(); if ( c == index ) { return s->getAnimationName().c_str(); } c++; } return ""; }
void Player::create(Ogre::Degree p, Ogre::Degree r, Ogre::Degree y) { Ogre::MeshManager::getSingleton().create("cube.mesh", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Entity* entity = sceneMgr->createEntity(Ogre::MeshManager::getSingleton().getByName( "cube.mesh", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)); Ogre::Vector3 newPos(position.x, position.y, position.z); endPos = newPos; rootNode = sceneMgr->getRootSceneNode()->createChildSceneNode(name, newPos); rootNode->setScale(length()/100.0, length()/100.0, length()/100.0); rootNode->attachObject(entity); // rootNode->setScale(.6, .6, .6); entity->setMaterialName("Cube/Blend"); rootNode->pitch(Ogre::Degree(p)); rootNode->roll(Ogre::Degree(r)); startPosition = position; }
bool MyFrameListener::deleteBoard() { for (int i=0; i<_XMAX; i++) { for (int j=0; j<_YMAX; j++) { myBoard[i][j]=0; } } for (int i=0; i<_XMAX; i++) { for (int j=0; j<_YMAX; j++) { myBoardPlayer[i][j]=0; } } _maxFires=0; _sceneManager->getRootSceneNode()->removeAndDestroyAllChildren(); _sceneManager->clearScene(); // Añadir el plano a la escena // Creacion del plano Ogre::Plane pl1(Ogre::Vector3::UNIT_Y,-5); Ogre::MeshManager::getSingleton().createPlane("pl1", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, pl1,200,200,1,1,true,1,20,20,Ogre::Vector3::UNIT_Z); // Añadir el plano a la escena Ogre::SceneNode* nodeG = _sceneManager->createSceneNode("nodeG"); Ogre::Entity* grEnt = _sceneManager->createEntity("pEnt", "pl1"); grEnt->setMaterialName("Ground"); nodeG->attachObject(grEnt); // Sombras _sceneManager->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE); Ogre::Light* light = _sceneManager->createLight("light1"); light->setType(Ogre::Light::LT_DIRECTIONAL); light->setDirection(Ogre::Vector3(1,-1,0)); nodeG->attachObject(light); _sceneManager->getRootSceneNode()->addChild(nodeG); return true; }
void ClientCourt::makePlane(std::string name, const Ogre::Vector3& planeNormal, const Ogre::Vector3& textureUp, const Ogre::String& texture, const int distance, const int length, const int height, Ogre::SceneNode* parent) { Ogre::Real tile = 5; if(texture == "Examples/TennisCourt") tile = 1; Ogre::Plane plane(planeNormal, -distance); Ogre::MeshManager::getSingleton().createPlane( name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, length, height, 1, 1, true, 1, tile, tile, textureUp ); Ogre::Entity* entSide = graphicsEngine->createEntity(name); if (parent == NULL) parentNode->attachObject(entSide); else parent->attachObject(entSide); entSide->setMaterialName(texture); entSide->setCastShadows(false); }
// 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(); }
void ParticleEffect::Initialize(Ogre::SceneManager *sceneManager, Ogre::SceneNode* parentNode, Ogre::String object_name, Ogre::String material_name, PhysicsEngine &physicsEngine, unsigned int parentID) { PhysicsEntity::Initialize(sceneManager, parentNode, physicsEngine, parentID); bodyType = ENTITY_BODY_METAPHYSICAL; Ogre::Entity* entity = sceneManager->createEntity(object_name); /* Apply a material to the entity */ materialName = material_name + std::to_string(objectID); Ogre::MaterialPtr origMat = Ogre::MaterialManager::getSingleton().getByName(material_name); Ogre::Material* mat = origMat.get(); mat->clone(materialName); entity->setMaterialName(materialName); sceneNode->attachObject(entity); sceneNode->translate(0,0,0); }
Ogre::Entity* EC_OgreAnimationController::GetEntity() { if (!mesh_entity_) return 0; OgreRenderer::EC_OgreMesh &mesh = *checked_static_cast<OgreRenderer::EC_OgreMesh*>(mesh_entity_.get()); Ogre::Entity* entity = mesh.GetEntity(); if (!entity) return 0; if (entity->getMesh()->getName() != mesh_name_) { mesh_name_ = entity->getMesh()->getName(); ResetState(); } return entity; }
Bomb::Bomb(Map *curMap, Ogre::Vector3 mapPos) : m_map(curMap), m_mapPosition(mapPos), m_animAmount(0.0f) { m_sceneMgr = Ogre::Root::getSingleton().getSceneManager("MapSceneManager"); m_sceneNode = m_sceneMgr->getSceneNode("MapNode")->createChildSceneNode(m_mapPosition * 100); m_sceneNode->scale(0.3f, 0.3f, 0.3f); //Ogre::SceneNode *entNode = m_sceneNode->createChildSceneNode(Ogre::Vector3(0.0f, 7.5f, 0.0f)); Ogre::SceneNode *entNode = m_sceneNode->createChildSceneNode(Ogre::Vector3(0.0f, 7.5f, 0.0f)); Ogre::Entity *ent = m_sceneMgr->createEntity(Ogre::SceneManager::PrefabType::PT_SPHERE); entNode->attachObject(ent); ent->setMaterialName("Color/Maroon"); // Set spline points for animation. m_spline.addPoint(m_mapPosition * 100); m_spline.addPoint(m_mapPosition * 100 + Ogre::Vector3(0.0f, 50.0f - std::fmod(m_mapPosition.y, 50.0f), 0.0f)); }
SnapToMovement::SnapToMovement(Eris::Entity& entity, Ogre::Node& node, float snapThreshold, Ogre::SceneManager& sceneManager, bool showDebugOverlay) : mEntity(entity), mNode(node), mSnapThreshold(snapThreshold), mSceneManager(sceneManager) { if (showDebugOverlay) { for (int i = 0; i < 30; ++i) { Ogre::SceneNode* node = mSceneManager.getRootSceneNode()->createChildSceneNode(); Ogre::Entity* sphereEntity = mSceneManager.createEntity(node->getName() + "_entity", "3d_objects/primitives/models/sphere.mesh"); //start out with a normal material sphereEntity->setMaterialName("/global/authoring/point"); sphereEntity->setRenderingDistance(300); // entity.setQueryFlags(MousePicker::CM_UNDEFINED); node->setScale(0.25, 0.25, 0.25); node->attachObject(sphereEntity); node->setVisible(false); mDebugNodes.push_back(node); } } }
void SceneLoader::createFloor( Ogre::Real width, Ogre::Real height ) { Ogre::Plane plane(Ogre::Vector3::UNIT_Z, 0); Ogre::MeshManager::getSingleton().createPlane("FloorPlane", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, width, height, 20, 20, true, 1, 1, 1, Ogre::Vector3::UNIT_Y); Ogre::Entity* entFloor = mSceneMgr->createEntity("FloorEntity", "FloorPlane"); entFloor->setMaterialName("Examples/GrassFloor"); entFloor->setCastShadows(false); mSceneRootNode->attachObject(entFloor); // Ogre::Entity* ent = mSceneMgr->createEntity("atd_cube.mesh"); // Ogre::SceneNode* node = mSceneRootNode->createChildSceneNode("Floor"); // node->setScale(Ogre::Vector3::UNIT_SCALE*mWallCubeScale*Ogre::Vector3(mRows,mCols,1)); // node->attachObject(ent); }
CollisionModel3D *EditorFrameHandler::GetCollisionModel(const char *modelname) { CollisionModel3D *hashres=NULL, *CollisionModel = NULL; bool bres = CollisionModels.Find(modelname, &hashres); if (!bres) { CollisionModel = newCollisionModel3D(false); size_t vertex_count,index_count; Ogre::Vector3* vertices; unsigned long* indices; Ogre::SceneManager *SceneMgr = CommonDeclarations::GetSceneManager(); Ogre::Entity *entity = SceneMgr->createEntity("tmpcollis", modelname); Collidable::getMeshInformation(entity->getMesh().getPointer(),vertex_count,vertices,index_count,indices,Ogre::Vector3(0,0,0),Ogre::Quaternion::IDENTITY,Ogre::Vector3(1,1,1)); SceneMgr->destroyEntity(entity); size_t index; int numTris = (int)index_count / 3; CollisionModel->setTriangleNumber(numTris); for (unsigned i=0;i<index_count;i+=3) { index = indices[i]; CollisionModel->addTriangle(vertices[indices[i+0]].x,vertices[indices[i+0]].y,vertices[indices[i+0]].z, vertices[indices[i+1]].x,vertices[indices[i+1]].y,vertices[indices[i+1]].z, vertices[indices[i+2]].x,vertices[indices[i+2]].y,vertices[indices[i+2]].z); } CollisionModel->finalize(); delete[] vertices; delete[] indices; CollisionModels.Insert(modelname,CollisionModel); } else { CollisionModel = hashres; } return CollisionModel; }
bool buildGroundShape(Ogre::SceneManager* sceneMgr, btDynamicsWorld* dynamicsWorld, btAlignedObjectArray<btCollisionShape*>& collisionShapes) { btBoxShape* groundShape = new btBoxShape(btVector3(btScalar(150.0f),btScalar(1.0f),btScalar(150.0f))); //btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0), 1); //groundShape->setLocalScaling(btVector3(1,1,1)); btDefaultMotionState* groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1),btVector3(0,-1,0))); btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0,groundMotionState,groundShape,btVector3(0,0,0)); btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI); groundRigidBody->setCcdMotionThreshold(1.0f); groundRigidBody->setRestitution(0.0f); groundRigidBody->setFriction(1.0f); const btTransform& transform = groundRigidBody->getWorldTransform(); btVector3 trans = transform.getOrigin(); btQuaternion rot = transform.getRotation(); dynamicsWorld->addRigidBody(groundRigidBody); collisionShapes.push_back(groundShape); // build plane if scene manager exist if (sceneMgr) { Ogre::Plane* plane = new Ogre::MovablePlane("Plane"); plane->d = 0; plane->normal = Ogre::Vector3::UNIT_Y; Ogre::MeshManager::getSingleton().createPlane("PlaneMesh", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, *plane, 256, 256, 1, 1, true, 1, 1, 1, Ogre::Vector3::UNIT_Z); Ogre::Entity* ent = sceneMgr->createEntity("PlaneEntity", "PlaneMesh"); assert(ent); ent->setCastShadows(false); ent->setMaterialName("DefaultPlane"); Ogre::SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode("PlaneNode"); node->attachObject(ent); node->setPosition(Ogre::Vector3::ZERO); } // End if return true; }
void OgreColladaContentImporter::sceneNodeCreated(Ogre::SceneNode* pNode, FCDSceneNode* pFColladaSceneNode) { NxOgre::ActorParams actorParams; NxOgre::ShapeParams shapeParams; Ogre::Vector3 boxSize; Ogre::Vector3 scale; Ogre::Entity *pEntity; std::list<Ogre::Entity*> entityList; std::list<Ogre::Entity*>::iterator entityListIter; NxVec3 row; pEntity = NULL; Ogre::SceneNode::ObjectIterator iter = pNode->getAttachedObjectIterator(); while (iter.hasMoreElements()) { pEntity = dynamic_cast<Ogre::Entity*>(iter.getNext()); if (pEntity != NULL) { entityList.push_back(pEntity); } } shapeParams.setToDefault(); //scale = pNode->_getDerivedScale(); //shapeParams.mMeshScale = NxVec3(scale.x, scale.y, scale.z); for (entityListIter = entityList.begin(); entityListIter != entityList.end(); ++entityListIter) { pEntity = *entityListIter; boxSize = pEntity->getBoundingBox().getSize(); pNode->detachObject(pEntity); actorParams.setToDefault(); actorParams.mMass = 0.0f; actorParams.mBodyFlags |= NX_BF_KINEMATIC; GameObjectFactory::getSingleton().makeBody(pEntity->getName(), pNode, pEntity, scene ,new NxOgre::CubeShape(boxSize.x, boxSize.y, boxSize.z, shapeParams), actorParams); } sceneNodes.push_back(pNode); }