int Hundir::start() { _root = new Ogre::Root(); if(!_root->restoreConfig()) { _root->showConfigDialog(); _root->saveConfig(); } Ogre::RenderWindow* window = _root->initialise(true,"Hundir Example"); _sceneManager = _root->createSceneManager(Ogre::ST_GENERIC); Ogre::Camera* cam = _sceneManager->createCamera("MainCamera"); cam->setPosition(Ogre::Vector3(-10,30,35)); cam->lookAt(Ogre::Vector3(0,0,0)); cam->setNearClipDistance(5); cam->setFarClipDistance(10000); Ogre::Viewport* viewport = window->addViewport(cam); viewport->setBackgroundColour(Ogre::ColourValue(0.0,0.0,0.0)); double width = viewport->getActualWidth(); double height = viewport->getActualHeight(); cam->setAspectRatio(width / height); loadResources(); createScene(); _framelistener = new MyFrameListener(window, cam, _sceneManager); _root->addFrameListener(_framelistener); _root->startRendering(); return 0; }
int startup(){ _root = new Ogre::Root("plugins_d.cfg"); if(!_root->showConfigDialog()){ return -1; } Ogre::RenderWindow* window = _root->initialise(true, "Ventana Ogre"); _sceneManager = _root->createSceneManager(Ogre::ST_GENERIC); Ogre::Camera* camera = _sceneManager->createCamera("Camera"); camera->setPosition(Ogre::Vector3(500,100,500)); camera->lookAt(Ogre::Vector3(0,0,0)); camera->setNearClipDistance(5); Ogre::Viewport* viewport = window->addViewport(camera); viewport->setBackgroundColour(Ogre::ColourValue(0.0,0.0,0.0)); camera->setAspectRatio(Ogre::Real(viewport->getActualWidth()/viewport->getActualHeight())); _listener = new FrameListenerProyectos(window,camera); _root->addFrameListener(_listener); loadResources(); createScene(); _root->startRendering(); return 0; }
//------------------------------------------------------------------------------------------- void MagickWidget::loadMesh(Ogre::MeshPtr pMesh) { QString directory(OgitorsRoot::getSingletonPtr()->GetProjectOptions()->ProjectDir.c_str()); if(directory.isEmpty()) directory = "./"; QDir(directory).mkpath("entitycache"); Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "MeshMagickTex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_R8G8B8A8 , Ogre::TU_RENDERTARGET ); Ogre::RenderTexture *rttTex = texture->getBuffer()->getRenderTarget(); Ogre::SceneManager *mSceneMgr = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "MeshMagickTexMgr"); Ogre::Light *dirl = mSceneMgr->createLight("DisplayLight"); dirl->setDirection(-1,-1,-1); dirl->setDiffuseColour(1,1,1); dirl->setType(Ogre::Light::LT_DIRECTIONAL); Ogre::Camera* RTTCam = mSceneMgr->createCamera("MeshMagickCam"); RTTCam->setNearClipDistance(0.01F); RTTCam->setFarClipDistance(0); RTTCam->setAspectRatio(1); RTTCam->setFOVy(Ogre::Degree(90)); RTTCam->setPosition(0,0,1); RTTCam->lookAt(0,0,0); Ogre::Viewport *v = rttTex->addViewport( RTTCam ); v->setClearEveryFrame( true ); v->setBackgroundColour(Ogre::ColourValue(0,0,0)); Ogre::Entity *mEntity; mEntity = mSceneMgr->createEntity("scbDisplay", pMesh->getName()); mSceneMgr->getRootSceneNode()->attachObject(mEntity); Ogre::Vector3 vSize = mEntity->getBoundingBox().getHalfSize(); Ogre::Vector3 vCenter = mEntity->getBoundingBox().getCenter(); vSize += Ogre::Vector3(vSize.z, vSize.z, vSize.z); float maxsize = std::max(std::max(vSize.x,vSize.y),vSize.z); vSize = Ogre::Vector3(0, 0, maxsize * 1.15f) + vCenter; RTTCam->setPosition(vSize.x,vSize.y,vSize.z); RTTCam->lookAt(vCenter.x,vCenter.y,vCenter.z); rttTex->update(); Ogre::String imagefile = OgitorsUtils::QualifyPath(directory.toStdString() + "/entitycache/meshmagick.png"); rttTex->writeContentsToFile(imagefile); mEntity->detachFromParent(); mSceneMgr->destroyEntity(mEntity); rttTex->removeAllViewports(); Ogre::Root::getSingletonPtr()->destroySceneManager(mSceneMgr); mDisplayWidget->setImage(QString(imagefile.c_str())); }
int main(int argc, char* argv[]){ cout << "Test Ogre Program blaha" << endl; //Relative to where its executed from, not binary location Ogre::Root *mRoot = new Ogre::Root("configs/plugins.cfg","configs/config.cfg","logs/main.log"); if(!(mRoot->restoreConfig() || mRoot->showConfigDialog())){ delete mRoot; return -1; } // setup resources // Only add the minimally required resource locations to load up the Ogre head mesh Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/Users/jgrey/OgreSDK/Media/materials/programs", "FileSystem", "General"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/Users/jgrey/OgreSDK/Media/materials/programs/GLSL", "FileSystem", "General"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/Users/jgrey/OgreSDK/Media/materials/scripts", "FileSystem", "General"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/Users/jgrey/OgreSDK/Media/materials/textures", "FileSystem", "General"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/Users/jgrey/OgreSDK/Media/models", "FileSystem", "General"); //Create the window Ogre::RenderWindow *mWindow = mRoot->initialise(true, "initial Render Window"); Ogre::SceneManager *sceneManager = mRoot->createSceneManager(Ogre::ST_GENERIC); Ogre::Camera *camera = sceneManager->createCamera("PlayerCam"); camera->setPosition(Ogre::Vector3(0,0,80)); camera->lookAt(Ogre::Vector3(0,0,-300)); camera->setNearClipDistance(5); Ogre::Viewport* vp = mWindow->addViewport(camera); vp->setBackgroundColour(Ogre::ColourValue(0,0,0,0)); camera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight())); Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); Ogre::Entity* ogreHead = sceneManager->createEntity("Head","ogreHead.mesh"); Ogre::SceneNode* headNode = sceneManager->getRootSceneNode()->createChildSceneNode(); headNode->attachObject(ogreHead); sceneManager->setAmbientLight(Ogre::ColourValue(0.5,0.5,0.5)); //Run the system bool continueRunning = true; while(continueRunning){ mRoot->renderOneFrame(); headNode->rotate(Ogre::Vector3(0,1,0),Ogre::Radian(0.005)); if(mWindow->isClosed()){ continueRunning = false; } } delete mRoot; }
void application::create_camera() { cam = scene_mgr->createCamera("PlayerCam"); cam->setPosition(Ogre::Vector3 {0, 0, 80}); cam->lookAt(Ogre::Vector3 {0, 0, -300}); cam->setNearClipDistance(5); cameraman = new OgreBites::SdkCameraMan(cam); }
void GraphicsImpl::createCamera() { camera = sceneMgr->createCamera("MainCamera"); // Position it at 500 in Z direction camera->setPosition(Ogre::Vector3(0, 50, 100)); // Look back along -Z camera->lookAt(Ogre::Vector3(0, -10, 0)); camera->setNearClipDistance(5); camera->setFarClipDistance(0); }
// funcion que configura la camara void createCamera(Ogre::RenderWindow* window){ camera = _sceneManager->createCamera("Camera"); camera->setPosition(Ogre::Vector3(0,60,-100)); camera->lookAt(Ogre::Vector3(0,0,50)); camera->setNearClipDistance(5); Ogre::Viewport* viewport = window->addViewport(camera); viewport->setBackgroundColour(Ogre::ColourValue(0.0,0.0,0.0)); camera->setAspectRatio(Ogre::Real(viewport->getActualWidth())/Ogre::Real(viewport->getActualHeight())); }
void BaseApp::createCamera() { Ogre::Camera* cam = mSceneMgr->createCamera("PlayerCam"); cam->setPosition(0,0,0); cam->lookAt(0,0,0); //cam->setAutoAspectRatio(true); cam->setNearClipDistance(1); cam->setFarClipDistance(10000); mCameraMan = new OgreBites::SdkCameraMan(cam); mCameraMan->setTopSpeed(1000); }
void CameraManager::createOculusCamera(){ Ogre::Camera *cameraLeft = mSceneMgr->createCamera("PlayerCamLeft"); Ogre::Camera *cameraRight = mSceneMgr->createCamera("PlayerCamRight"); cameraLeft->setNearClipDistance(0.5); cameraRight->setNearClipDistance(0.5); if(mOculusCamera == 0) mOculusCamera = new OculusCamera(cameraLeft, cameraRight); else{ mOculusCamera->setLeftCamera(cameraLeft); mOculusCamera->setRightCamera(cameraRight); } mOculusCamera->setPosition(mNodePosition); mOculusCamera->yaw(mNodeYaw); mOculusCamera->pitch(mNodePitch); mOculusCamera->roll(mNodeRoll); }
void ReliefApp::GenerateRelief() { //Get depth data Ogre::TexturePtr depthTex = Ogre::TextureManager::getSingleton().createManual( "DepthTexture", // name Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, // type 512, // width 512, // height 0, // number of mipmaps //Ogre::PF_B8G8R8A8, // pixel format Ogre::PF_FLOAT32_R, Ogre::TU_RENDERTARGET ); Ogre::RenderTarget* pTarget = depthTex->getBuffer()->getRenderTarget(); Ogre::Camera* pOrthCam = MagicCore::RenderSystem::GetSingleton()->GetMainCamera(); pOrthCam->setProjectionType(Ogre::PT_ORTHOGRAPHIC); pOrthCam->setOrthoWindow(3, 3); pOrthCam->setPosition(0, 0, 3); pOrthCam->lookAt(0, 0, 0); pOrthCam->setAspectRatio(1.0); pOrthCam->setNearClipDistance(0.5); pOrthCam->setFarClipDistance(5); Ogre::Viewport* pViewport = pTarget->addViewport(pOrthCam); pViewport->setDimensions(0, 0, 1, 1); MagicCore::RenderSystem::GetSingleton()->RenderLightMesh3D("RenderMesh", "Depth", mpLightMesh); MagicCore::RenderSystem::GetSingleton()->Update(); Ogre::Image img; depthTex->convertToImage(img); std::vector<double> heightField(512 * 512); for(int x = 0; x < 512; x++) { for(int y = 0; y < 512; y++) { heightField.at(x * 512 + y) = (img.getColourAt(x, 511 - y, 0))[1]; } } Ogre::TextureManager::getSingleton().remove("DepthTexture"); // MagicDGP::LightMesh3D* pReliefMesh = MagicDGP::ReliefGeneration::PlaneReliefFromHeightField(heightField, 511, 511); //MagicDGP::LightMesh3D* pReliefMesh = MagicDGP::ReliefGeneration::CylinderReliefFromHeightField(heightField, 511, 511); if (pReliefMesh != NULL) { delete mpLightMesh; mpLightMesh = pReliefMesh; mpLightMesh->UnifyPosition(2); mpLightMesh->UpdateNormal(); } MagicCore::RenderSystem::GetSingleton()->SetupCameraDefaultParameter(); MagicCore::RenderSystem::GetSingleton()->RenderLightMesh3D("RenderMesh", "MyCookTorrance", mpLightMesh); }
void DotSceneLoader::processCamera(rapidxml::xml_node<>* XMLNode, Ogre::SceneNode *pParent) { // Process attributes Ogre::String name = getAttrib(XMLNode, "name"); Ogre::String id = getAttrib(XMLNode, "id"); // Ogre::Real fov = getAttribReal(XMLNode, "fov", 45); // Ogre::Real aspectRatio = getAttribReal(XMLNode, "aspectRatio", 1.3333); Ogre::String projectionType = getAttrib(XMLNode, "projectionType", "perspective"); // Create the camera Ogre::Camera *pCamera = mSceneMgr->createCamera(name); // Set the projection type if (projectionType == "perspective") pCamera->setProjectionType(Ogre::PT_PERSPECTIVE); else if (projectionType == "orthographic") pCamera->setProjectionType(Ogre::PT_ORTHOGRAPHIC); rapidxml::xml_node<>* pElement; // Process clipping (?) pElement = XMLNode->first_node("clipping"); if (pElement) { Ogre::Real nearDist = getAttribReal(pElement, "near"); if (nearDist > 0) pCamera->setNearClipDistance(nearDist); Ogre::Real farDist = getAttribReal(pElement, "far"); pCamera->setFarClipDistance(farDist); } // Process position (?) pElement = XMLNode->first_node("position"); if (pElement) pCamera->setPosition(parseVector3(pElement)); // Process rotation (?) pElement = XMLNode->first_node("rotation"); if (pElement) pCamera->setOrientation(parseQuaternion(pElement)); // construct a scenenode is no parent if (!pParent) { Ogre::SceneNode* pNode = mAttachNode->createChildSceneNode(name); pNode->setPosition(pCamera->getPosition()); pNode->setOrientation(pCamera->getOrientation()); pNode->scale(1, 1, 1); } }
Player* PlayerManager::createHumanPlayer(const Ogre::String& name, Ogre::RenderWindow *window, GUI* gui) { // TODO: Handle Human Multiplayer, also this code should be somewhere else Ogre::Camera *camera = mSceneMgr->createCamera("Player1"); camera->setNearClipDistance(NEAR_CLIP_DISTANCE); Ogre::Viewport *vp = window->addViewport(camera); vp->setBackgroundColour(Ogre::ColourValue(0,0,0)); camera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight())); HumanController* hc = new HumanController(gui); Player* player = createPlayer(name + "Human", hc, false); player->attachCamera(camera); return player; }
static void setupScene() { LOGI("------->setupScene()"); Ogre::ConfigFile cf; cf.load(openAPKFile("resources.cfg")); Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator(); while (seci.hasMoreElements()) { Ogre::String sec, type, arch; sec = seci.peekNextKey(); Ogre::ConfigFile::SettingsMultiMap* settings = seci.getNext(); Ogre::ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); i++) { type = i->first; arch = i->second; Ogre::ResourceGroupManager::getSingleton().addResourceLocation(arch, type, sec); } } Ogre::ResourceGroupManager::getSingletonPtr()->initialiseResourceGroup( Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); gSceneMgr = gRoot->createSceneManager(Ogre::ST_GENERIC); Ogre::Camera* camera = gSceneMgr->createCamera("MyCam"); Ogre::Entity* pEntity = gSceneMgr->createEntity("SinbadInstance", "Sinbad.mesh"); Ogre::SceneNode* pNode = gSceneMgr->getRootSceneNode()->createChildSceneNode(); pNode->attachObject(pEntity); Ogre::Light* pDirLight = gSceneMgr->createLight(); pDirLight->setDirection(Ogre::Vector3(0, -1, 0)); pDirLight->setType(Ogre::Light::LT_DIRECTIONAL); pNode->attachObject(pDirLight); camera->setNearClipDistance(1.0f); camera->setFarClipDistance(100000.0f); camera->setPosition(0, 0, 20.0f); camera->lookAt(0, 0, 0); camera->setAutoAspectRatio(true); Ogre::Viewport* vp = gRenderWnd->addViewport(camera); vp->setBackgroundColour(Ogre::ColourValue(1, 0, 0)); LOGI("<-------setupScene()"); }
//We're not sure whether return a reference to a vector is such a great idea. void CinematicManager::createPerspectiveCamera(Ogre::Real windowW, Ogre::Real windowH, const Ogre::Vector3 &initialPos, const Ogre::Quaternion &initialOrient, Control* control) { Ogre::Camera* cam = _scnMgr->createCamera(PERSP_CAM_NAME + Ogre::StringConverter::toString(_camCurId)); cam->setNearClipDistance(1.0f); cam->setFarClipDistance(400.0f); cam->setPosition(0.0f, 0.0f, 0.0f); cam->setAspectRatio(windowW / windowH); Ogre::SceneNode* defaultNode = _scnMgr->createSceneNode(); defaultNode->setPosition(initialPos); //It's in local space. defaultNode->setOrientation(initialOrient); defaultNode->attachObject(cam); _camsVec.push_back(new ZCameraInfo(_camsVec.size(), "PERSPECTIVE", cam->getName(), control, cam)); }
void CameraManager::createSimpleCamera(){ Ogre::Camera *camera = mSceneMgr->createCamera("PlayerCam"); camera->setNearClipDistance(0.5); if(mSimpleCamera == NULL) mSimpleCamera = new SimpleCamera(camera); else mSimpleCamera->setCamera(camera); mSimpleCamera->setPosition(mNodePosition); mSimpleCamera->yaw(mNodeYaw); mSimpleCamera->pitch(mNodePitch); mSimpleCamera->roll(mNodeRoll); }
void CinematicManager::createOrthoCamera(Ogre::Real windowW, Ogre::Real windowH, const Ogre::Vector3 &initialPos, const Ogre::Quaternion &initialOrient, Control* control) { Ogre::Camera* cam = _scnMgr->createCamera(ORTHO_CAM_NAME + Ogre::StringConverter::toString(_camCurId)); cam->setProjectionType(Ogre::PT_ORTHOGRAPHIC); cam->setOrthoWindow(100, 50); cam->setNearClipDistance(1); cam->setPosition(0.0f, 0.0f, 0.0f); //cam->setFarClipDistance(100.0f); cam->setFOVy(Ogre::Radian(Ogre::Math::PI / 2.0f)); Ogre::SceneNode* defaultNode = _scnMgr->createSceneNode(); defaultNode->setPosition(initialPos); defaultNode->setOrientation(initialOrient); defaultNode->attachObject(cam); _camsVec.push_back(new ZCameraInfo(_camsVec.size(), "ORTHOGRAPHIC", cam->getName(), control, cam)); }
void Geometry::setupView() { Ogre::Camera * mCamera = OgreTrip::getCamera(); // put camera at world center, so that it's difficult to reach the edge Vector3 worldCenter( (ENDLESS_PAGE_MAX_X + ENDLESS_PAGE_MIN_X) / 2 * TERRAIN_WORLD_SIZE, 0, -(ENDLESS_PAGE_MAX_Y + ENDLESS_PAGE_MIN_Y) / 2 * TERRAIN_WORLD_SIZE ); //mCamera->setPosition(mTerrainPos + worldCenter); //mCamera->lookAt(mTerrainPos); mCamera->setNearClipDistance(0.1); mCamera->setFarClipDistance(8000); /* if (OgreTrip::getRoot()->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE)) { mCamera->setFarClipDistance(0); // enable infinite far clip distance if we can }*/ }
int MyApp::start() { _root = new Ogre::Root(); if(!_root->restoreConfig()) { _root->showConfigDialog(); _root->saveConfig(); } _pTrackManager = new TrackManager; _pSoundFXManager = new SoundFXManager; Ogre::RenderWindow* window = _root->initialise(true,"MyApp Example"); _sceneManager = _root->createSceneManager(Ogre::ST_GENERIC); Ogre::Camera* cam = _sceneManager->createCamera("MainCamera"); cam->setPosition(Ogre::Vector3(7,10.5,8)); cam->lookAt(Ogre::Vector3(0,3.5,0)); cam->setNearClipDistance(5); cam->setFarClipDistance(10000); Ogre::Viewport* viewport = window->addViewport(cam); viewport->setBackgroundColour(Ogre::ColourValue(0.0,0.0,0.0)); double width = viewport->getActualWidth(); double height = viewport->getActualHeight(); cam->setAspectRatio(width / height); loadResources(); createScene(); createOverlay(); Ogre::SceneNode *node = _sceneManager->getSceneNode("Neptuno"); _framelistener = new MyFrameListener(this, window, cam, node, _overlayManager, _sceneManager); _root->addFrameListener(_framelistener); // Reproducción del track principal... this->_mainTrack->play(); _root->startRendering(); return 0; }
//---------------------------------------------------------------------------------------- ImageConverter::ImageConverter(const size_t& width/*=128*/, const size_t& height/*=128*/) { mWidth = width; mHeight = height; mResourceManager = Ogre::ResourceGroupManager::getSingletonPtr(); mResourceManager->createResourceGroup("QTImageConverter"); mResourceManager->initialiseResourceGroup("QTImageConverter"); mSceneMgrPtr = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "QTImageConverterSceneManager"); mSceneMgrPtr->setAmbientLight(Ogre::ColourValue(1, 1, 1)); Ogre::TexturePtr rendertexture = Ogre::TextureManager::getSingleton().createManual("RenderTex", "QTImageConverter", Ogre::TEX_TYPE_2D, mWidth, mHeight, 1, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET); mRttTex = rendertexture->getBuffer()->getRenderTarget(); // create our plane to set a texture to Ogre::Plane plane(Ogre::Vector3::UNIT_Z, 0); Ogre::MeshManager::getSingleton().createPlane("terrain", "QTImageConverter", plane, 100, 100, 1, 1, true, 1, 1, 1, Ogre::Vector3::UNIT_Y); // attach the plane to the scene manager and rotate it so the camera can see it mEntityTerrain = mSceneMgrPtr->createEntity("terrainEntity", "terrain"); Ogre::SceneNode* node = mSceneMgrPtr->getRootSceneNode()->createChildSceneNode(); node->attachObject(mEntityTerrain); mEntityTerrain->setCastShadows(false); Ogre::Camera* RTTCam = mSceneMgrPtr->createCamera("QTImageConverterCam"); RTTCam->setNearClipDistance(0.01F); RTTCam->setFarClipDistance(0); RTTCam->setAspectRatio(1); RTTCam->setFOVy(Ogre::Degree(90)); RTTCam->setPosition(0, 0, 50); RTTCam->lookAt(0, 0, 0); Ogre::Viewport *v = mRttTex->addViewport(RTTCam); v->setBackgroundColour(Ogre::ColourValue(1, 1, 1)); v->setClearEveryFrame(true); }
int startup(){ _root = new Ogre::Root("plugins_d.cfg"); /* if(!_root->showConfigDialog()){ return -1; } */ Ogre::RenderSystem* _rs = _root->getRenderSystemByName("Direct3D9 Rendering Subsystem"); // or use "OpenGL Rendering Subsystem" _root->setRenderSystem(_rs); _rs->setConfigOption("Full Screen", "No"); _rs->setConfigOption("Video Mode", "800 x 600 @ 32-bit colour"); _rs->setConfigOption("FSAA", "0"); _rs->setConfigOption("Floating-point mode", "Fastest"); _rs->setConfigOption("Use Multihead", "Auto"); _rs->setConfigOption("VSync", "No"); _rs->setConfigOption("VSync Interval", "1"); Ogre::RenderWindow* window = _root->initialise(true, "Ventana Ogre"); _sceneManager = _root->createSceneManager(Ogre::ST_GENERIC); Ogre::Camera* camera = _sceneManager->createCamera("Camera"); camera->setPosition(Ogre::Vector3(0.0f,300.0f,-1000.0f)); camera->lookAt(Ogre::Vector3(0,0,0)); camera->setNearClipDistance(5); Ogre::Viewport* viewport = window->addViewport(camera); viewport->setBackgroundColour(Ogre::ColourValue(0.0,0.0,0.0)); camera->setAspectRatio(Ogre::Real(viewport->getActualWidth()/viewport->getActualHeight())); _listener = new FrameListenerProyectos(window,camera); _root->addFrameListener(_listener); loadResources(); createScene(); _root->startRendering(); return 0; }
//--------------------------------------------------------------------------------------------- void TEditorMapLogic::LoadSettingCamera() { Ogre::Vector3 pos( -4.225f, 44.0f, -6.4f ); Ogre::Quaternion dir( 0.279825151f, -0.0655403361f, -0.932625532f, -0.218426302f ); GetSettings()->BeginGroup( "SettingCamera" ); pos.x = GetSettings()->ReadEntry<float>( "pos_x", &pos.x ); pos.y = GetSettings()->ReadEntry<float>( "pos_y", &pos.y ); pos.z = GetSettings()->ReadEntry<float>( "pos_z", &pos.z ); dir.x = GetSettings()->ReadEntry<float>( "dir_x", &dir.x ); dir.y = GetSettings()->ReadEntry<float>( "dir_y", &dir.y ); dir.z = GetSettings()->ReadEntry<float>( "dir_z", &dir.z ); dir.w = GetSettings()->ReadEntry<float>( "dir_w", &dir.w ); Ogre::Camera* pCamera = TModuleLogic::Get()->GetC()->pGraphicEngine->GetGE()->GetCamera(); pCamera->setPosition( pos ); pCamera->setOrientation( dir ); pCamera->setNearClipDistance( 0.01f ); }
void OgreCameraSystem::update(int) { for (EntityId entityId : m_impl->m_entities.removedEntities()) { Ogre::Camera* camera = m_impl->m_cameras[entityId]; if (camera) { Ogre::SceneNode* sceneNode = camera->getParentSceneNode(); sceneNode->detachObject(camera); m_impl->m_sceneManager->destroyCamera(camera); } m_impl->m_cameras.erase(entityId); } for (auto& value : m_impl->m_entities.addedEntities()) { EntityId entityId = value.first; OgreSceneNodeComponent* sceneNodeComponent = std::get<0>(value.second); OgreCameraComponent* cameraComponent = std::get<1>(value.second); Ogre::Camera* camera = m_impl->m_sceneManager->createCamera( cameraComponent->name() ); camera->setAutoAspectRatio(true); cameraComponent->m_camera = camera; m_impl->m_cameras[entityId] = camera; sceneNodeComponent->m_sceneNode->attachObject(camera); } m_impl->m_entities.clearChanges(); for (auto& value : m_impl->m_entities) { OgreCameraComponent* cameraComponent = std::get<1>(value.second); auto& properties = cameraComponent->m_properties; if (properties.hasChanges()) { Ogre::Camera* camera = cameraComponent->m_camera; // Update camera camera->setPolygonMode(properties.polygonMode); camera->setFOVy(properties.fovY); camera->setNearClipDistance(properties.nearClipDistance); camera->setFarClipDistance(properties.farClipDistance); // Untouch properties.untouch(); } } }
GameCamera* CameraFactory::make(const rapidjson::Value& jsonobj){ // Create the sphere Ogre::Camera* camera = game_manager->GetSceneManager()->createCamera(jsonobj["name"].GetString()); SpaceObject*spaceobj=game_manager->getSpaceObject(jsonobj["attached_object"].GetString()); // Set the node's position Eigen::Vector3f positionVec=spaceobj->position.cast<float>(); camera->setPosition(Ogre::Vector3( static_cast<Ogre::Real*>(positionVec.data()) )); // Set the node's orientation Eigen::Quaterniond attitude=spaceobj->attitude; camera->setOrientation(Ogre::Quaternion(attitude.w(),attitude.x(),attitude.y(),attitude.z() )); camera->setNearClipDistance(jsonobj["near_clip"].GetDouble()); camera->setFarClipDistance(jsonobj["far_clip"].GetDouble()); GameCamera* gamecamera=new GameCamera(camera,spaceobj); return gamecamera; }
void Channel::frameDraw(const eq::uint128_t &frame_id) { // Setup OpenGL state (view frustum etc.) eq::Channel::frameDraw(frame_id); // Get data const Config *config = static_cast<Config *>(getConfig()); const Node *node = static_cast<Node *>(getNode()); const InitData &init_data = node->getInitData(); const Pipe *pipe = static_cast<Pipe *>(getPipe()); const FrameData &frame_data = pipe->getFrameData(); Window *window = static_cast<Window *>(getWindow()); Ogre::Camera *cam = pipe->_ogre->getCamera(); // Set the projection matrix const eq::Frustumf & frustum = getFrustum(); cam->setCustomProjectionMatrix(true, toOgreMatrix(frustum.compute_matrix())); const eq::Matrix4f eqViewMatrix = getHeadTransform(); // Adjust the view matrix according to equalizer's view matrix Ogre::Matrix4 ogreViewMatrix = toOgreMatrix(eqViewMatrix); cam->setCustomViewMatrix(true, ogreViewMatrix); cam->setNearClipDistance(frustum.near_plane()); cam->setFarClipDistance(frustum.far_plane()); // Set the viewport eq::PixelViewport winPvp = window->getPixelViewport(); eq::PixelViewport pvp = getPixelViewport(); window->setViewport((float)pvp.x/(float)winPvp.w, 1.0f - (float)(pvp.h + pvp.y)/(float)winPvp.h, (float)pvp.w/(float)winPvp.w, (float)pvp.h/(float)winPvp.h); // Render window->render(); }
/** * This is the most basic "triangle" example, done as a Scene in Ogre. */ Ogre::SceneManager* createTriangleScene() { Ogre::SceneManager* scene = mRoot->createSceneManager(Ogre::ST_GENERIC); // Configure camera (~ view & projection transforms, i.e. gluLookAt + glOrtho) Ogre::Camera* camera = scene->createCamera("MainCamera"); // We can use an arbitrary name here camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC); camera->setOrthoWindow(2, 2); // ~ glOrtho(-1, 1, -1, 1) camera->setAspectRatio((float) mWindow->getWidth() / mWindow->getHeight()); camera->setNearClipDistance(0.5); camera->setPosition(Ogre::Vector3(0,0,1)); // Move camera away from (0, 0, 0), otherwise the triangle at z=0 will be clipped // Now add some geometry to the scene Ogre::ManualObject* triangle = scene->createManualObject("Triangle"); // ~ glBegin, glVertex, glEnd // "BaseWhiteNoLighting" is a built-in name for a basic non-lit material triangle->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST); triangle->position(0, 0.5, 0); // ~ glVertex. // Contrary to OpenGL we *first* must create the vertex triangle->colour(Ogre::ColourValue::Red); // .. and then provide its attributes such as color (~ glColor) triangle->position(-0.5, -0.5, 0); triangle->colour(Ogre::ColourValue::Green); triangle->position(0.5, -0.5, 0); triangle->colour(Ogre::ColourValue::Blue); triangle->end(); // Add the created triangle object to the scene graph // For this we create a SceneNode object, which will combine information about // the object's geometry with its modeling transform // (see frameRenderingQueued to understand how to rotate the triangle by changing this transform) scene->getRootSceneNode()->createChildSceneNode("Triangle")->attachObject(triangle); // Exercise 1: Create new object, add vertices, attach the object to a new SceneNode // ... return scene; }
void OgreApplication::InitViewport(void){ try { /* Retrieve scene manager and root scene node */ Ogre::SceneManager* scene_manager = ogre_root_->createSceneManager(Ogre::ST_GENERIC, "MySceneManager"); Ogre::SceneNode* root_scene_node = scene_manager->getRootSceneNode(); /* Create camera object */ Ogre::Camera* camera = scene_manager->createCamera("MyCamera"); Ogre::SceneNode* camera_scene_node = root_scene_node->createChildSceneNode("MyCameraNode"); camera_scene_node->attachObject(camera); camera->setNearClipDistance(camera_near_clip_distance_g); camera->setFarClipDistance(camera_far_clip_distance_g); camera->setPosition(camera_position_g); camera->lookAt(camera_look_at_g); camera->setFixedYawAxis(true, camera_up_g); /* Create viewport */ Ogre::Viewport *viewport = ogre_window_->addViewport(camera, viewport_z_order_g, viewport_left_g, viewport_top_g, viewport_width_g, viewport_height_g); viewport->setAutoUpdated(true); viewport->setBackgroundColour(viewport_background_color_g); /* Set aspect ratio */ float ratio = float(viewport->getActualWidth()) / float(viewport->getActualHeight()); camera->setAspectRatio(ratio); } catch (Ogre::Exception &e){ throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what()))); } catch(std::exception &e){ throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what()))); } }
void TestApp::setCurrentScene(SceneBase* scene) { mInputHandler->setScene(scene); // Setup the renderer window (i.e. add a camera/viewport to it) Ogre::Camera* camera = scene->getCamera(); if (!mViewport) { mViewport = mRenderWindow->addViewport(camera); } mViewport->setCamera(camera); camera->setAspectRatio(((Ogre::Real)mViewport->getActualWidth()) / ((Ogre::Real)mViewport->getActualHeight())); camera->setAutoAspectRatio(true); camera->setNearClipDistance(5.0f); // AB: default is 100 camera->moveRelative(Ogre::Vector3(0.0f, 0.0f, 200.0f)); mInputHandler->setCamera(camera); Ogre::SceneManager* manager = scene->getSceneManager(); mGui->setSceneManager(manager); mGui->setSceneId(SceneHandler::getSceneHandler()->getSceneId(scene)); mGui->setSceneDescription(scene->getSceneDescription()); mScene = scene; mInputHandler->forceToggleCallbackActivation(); }
KBOOL Kylin::ClGame::Initialize() { ////////////////////////////////////////////////////////////////////////// Ogre::Camera* pCam = OgreRoot::GetSingletonPtr()->CreateCamera("$MainCamera"); if (pCam) { pCam->setNearClipDistance(1.0f); OgreRoot::GetSingletonPtr()->CreateCameraControl(pCam); } //----------------------------------------------------- // 初始化UI Kylin::OgreRoot::GetSingletonPtr()->GetGuiManager()->InitShell(this); // 设置控制台命令接口 DebugConsole* pConsole = GET_GUI_PTR(DebugConsole); pConsole->SetHandler(KNEW UserCommandHandler()); //----------------------------------------------------- if (!GSGame::Initialize()) return false; return true; }
void DotSceneLoader::processCamera(rapidxml::xml_node<>* XMLNode, Ogre::SceneNode *pParent) { // Process attributes Ogre::String name = getAttrib(XMLNode, "name"); Ogre::String id = getAttrib(XMLNode, "id"); Ogre::Real fov = getAttribReal(XMLNode, "fov", 45); Ogre::Real aspectRatio = getAttribReal(XMLNode, "aspectRatio", 1.3333); Ogre::String projectionType = getAttrib(XMLNode, "projectionType", "perspective"); // Create the camera Ogre::Camera *pCamera = mSceneMgr->createCamera(name); //TODO: make a flag or attribute indicating whether or not the camera should be attached to any parent node. //if(pParent) // pParent->attachObject(pCamera); // Set the field-of-view //! @todo Is this always in degrees? //pCamera->setFOVy(Ogre::Degree(fov)); // Set the aspect ratio //pCamera->setAspectRatio(aspectRatio); // Set the projection type if (projectionType == "perspective") pCamera->setProjectionType(Ogre::PT_PERSPECTIVE); else if (projectionType == "orthographic") pCamera->setProjectionType(Ogre::PT_ORTHOGRAPHIC); rapidxml::xml_node<>* pElement; // Process clipping (?) pElement = XMLNode->first_node("clipping"); if (pElement) { Ogre::Real nearDist = getAttribReal(pElement, "near"); pCamera->setNearClipDistance(nearDist); Ogre::Real farDist = getAttribReal(pElement, "far"); pCamera->setFarClipDistance(farDist); } // Process position (?) pElement = XMLNode->first_node("position"); if (pElement) pCamera->setPosition(parseVector3(pElement)); // Process rotation (?) pElement = XMLNode->first_node("rotation"); if (pElement) pCamera->setOrientation(parseQuaternion(pElement)); // Process normal (?) pElement = XMLNode->first_node("normal"); if (pElement) ;//!< @todo What to do with this element? // Process lookTarget (?) pElement = XMLNode->first_node("lookTarget"); if (pElement) ;//!< @todo Implement the camera look target // Process trackTarget (?) pElement = XMLNode->first_node("trackTarget"); if (pElement) ;//!< @todo Implement the camera track target // Process userDataReference (?) pElement = XMLNode->first_node("userDataReference"); if (pElement) ;//!< @todo Implement the camera user data reference // construct a scenenode is no parent if (!pParent) { Ogre::SceneNode* pNode = mAttachNode->createChildSceneNode(name); pNode->setPosition(pCamera->getPosition()); pNode->setOrientation(pCamera->getOrientation()); pNode->scale(1, 1, 1); } }
int main( int argc, char** argv ) { // initialize the entire render system RenderSystem* render_system = RenderSystem::get(); QApplication app( argc, argv ); // make the render window RenderWidget* window = new RenderWidget( render_system ); window->setWindowTitle( "I hope this is not all black." ); QVBoxLayout* layout = new QVBoxLayout; layout->addWidget( window ); QPushButton* hide_button = new QPushButton( "hide" ); layout->addWidget( hide_button ); QPushButton* show_button = new QPushButton( "show" ); layout->addWidget( show_button ); QWidget container; container.setLayout( layout ); container.resize( 900, 600 ); container.show(); // Make a scene and show it in the window. Ogre::SceneManager* scene_manager = render_system->root()->createSceneManager( Ogre::ST_GENERIC ); Ogre::Entity* thing = scene_manager->createEntity( "thing", "rviz_cone.mesh" ); Ogre::SceneNode* node = scene_manager->getRootSceneNode()->createChildSceneNode(); node->attachObject( thing ); scene_manager->setAmbientLight( Ogre::ColourValue( .5, .5, .5 )); Ogre::Light* light = scene_manager->createLight( "light" ); light->setPosition( 20, 80, 50 ); Ogre::Camera* camera = scene_manager->createCamera( "SampleCam" ); camera->setPosition( Ogre::Vector3( 0, 0, 10 )); camera->lookAt( Ogre::Vector3( 0, 0, -300 )); camera->setNearClipDistance( 5 ); Ogre::Viewport* viewport = window->getRenderWindow()->addViewport( camera ); viewport->setBackgroundColour( Ogre::ColourValue( 0, 0, 1.0 )); camera->setAspectRatio( Ogre::Real( viewport->getActualWidth() ) / Ogre::Real( viewport->getActualHeight() )); // redraw every 33ms. QTimer timer; QObject::connect( &timer, SIGNAL(timeout()), window, SLOT(update()) ); timer.start( 33 ); RenderWidget window2( render_system ); window2.resize( 400, 400 ); window2.setWindowTitle( "I hope this is also not all black." ); window2.show(); hide_button->connect( hide_button, SIGNAL( clicked() ), &window2, SLOT( hide() )); show_button->connect( show_button, SIGNAL( clicked() ), &window2, SLOT( show() )); Ogre::Camera* camera2 = scene_manager->createCamera( "SampleCam2" ); camera2->setPosition( Ogre::Vector3( 0, 10, 0 )); camera2->setFixedYawAxis( false ); camera2->lookAt( Ogre::Vector3( 0, 0, 0 )); camera2->setNearClipDistance( 5 ); Ogre::Viewport* viewport2 = window2.getRenderWindow()->addViewport( camera2 ); viewport2->setBackgroundColour( Ogre::ColourValue( 0, 1.0, 0 )); camera2->setAspectRatio( Ogre::Real( viewport2->getActualWidth() ) / Ogre::Real( viewport2->getActualHeight() )); // redraw every 33ms. QTimer timer2; QObject::connect( &timer2, SIGNAL(timeout()), &window2, SLOT(update()) ); timer2.start( 33 ); // main loop return app.exec(); }