コード例 #1
0
ファイル: Engine.cpp プロジェクト: kdjoon42/ProjectJ
		//-----------------------------------------------------------------------------
		void Engine::OnRenderViewSize()
		{
				if(m_pRenderWnd)
						m_pRenderWnd->windowMovedOrResized();

				if(m_pCamera)
						m_pCamera->setAspectRatio(
						Ogre::Real(m_pViewport->getActualWidth()) / Ogre::Real(m_pViewport->getActualHeight()));
		}
コード例 #2
0
//---------------------------------------------------------------------------
void TutorialApplication::createViewports()
{
    Ogre::Viewport* vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

    mCamera->setAspectRatio(
        Ogre::Real(vp->getActualWidth()) /
        Ogre::Real(vp->getActualHeight()));
}
コード例 #3
0
ファイル: BaseApplication.cpp プロジェクト: chjk122/finalGame
//---------------------------------------------------------------------------
void BaseApplication::createViewports(void)
{
    // Create one viewport, entire window
    Ogre::Viewport* vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

    // Alter the camera aspect ratio to match the viewport
    mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
コード例 #4
0
//---------------------------------------------------------------------------
Ogre::CompositorInstance::Listener* HDRLogic::createListener(Ogre::CompositorInstance* instance)
{
    LOG_FUNCTION
	HDRListener* listener = new HDRListener;
	Ogre::Viewport* vp = instance->getChain()->getViewport();
	listener->notifyViewportSize(vp->getActualWidth(), vp->getActualHeight());
	listener->notifyCompositor(instance);
	return listener;
}
コード例 #5
0
int main(int argc, char* argv[]){
    cout << "Test Ogre Program" << 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");
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation("/Users/jgrey/github/Ogre_test/data","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::Entity* ogreHead = sceneManager->createEntity("Head","myTest.obj");
    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;
}
コード例 #6
0
GameState*          StateManager::changeState     ( const std::string& state_name, Ogre::RenderWindow* window ){
    _prev_state = _current_state;
    _current_state = _states[state_name];
    window->removeAllViewports();
    Ogre::Camera* camera = _current_state->getScene()->getCamera(MainCameraName);
    Ogre::Viewport* vp = window->addViewport(camera);
    vp->setBackgroundColour(Ogre::ColourValue(0.5,0.5,0.5));
    camera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
    return _current_state;
}
コード例 #7
0
void MultiMgrSample::setupViewport(Ogre::SceneManager *curr)
{
	mWindow->removeAllViewports();

	Ogre::Camera *cam = curr->getCamera(CAMERA_NAME);
	Ogre::Viewport *vp = mWindow->addViewport(cam);

	vp->setBackgroundColour(Ogre::ColourValue(0,0,0));
	cam->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
コード例 #8
0
void GUIManager::ShowMainMenu(bool isVisible)
{
	if (isVisible == true)
	{
		if (m_gui_GameMainMenu.get() == nullptr)
			m_gui_GameMainMenu = std::unique_ptr<GUI::GameMainMenu>(new GUI::GameMainMenu());

		/* Adjust menu position */
		Ogre::Viewport* viewport = RoR::Application::GetOgreSubsystem()->GetRenderWindow()->getViewport(0);
		int margin = (viewport->getActualHeight() / 15);
		m_gui_GameMainMenu->SetPosition(
			margin, // left
			viewport->getActualHeight() - m_gui_GameMainMenu->GetHeight() - margin // top
			);

		m_gui_GameMainMenu->Show();
	} else 
		m_gui_GameMainMenu->Hide();
}
コード例 #9
0
ファイル: CardEditor.cpp プロジェクト: Mizux/arcomage
// -----------------------------------------------------------------------------
CardEditor::CardEditor(EditorProject* project, DeckEditor* parentEditor, QWidget *parent, Qt::WFlags flags)
	: QWidget(parent, flags), 
		EditorWidget(project, parentEditor), 
		widget(0), 
		cards(project->getCards()), 
		current(0), 
		hasChanged(false),
		notified(false),
		currentItem(0),
		cardCount(cards.size()),
		rsError(false) {

		ui.setupUi(this);

		// We're trying to create a 3D Render Preview. If this fails, the user
		// will still be able to edit stuff, but can't preview changes.
		try {
			// Create Editor RenderView
			widget = new OgreWidget(Util::toQString(EditorSystem::getInstance().getRenderView()), ui.ogreWidget);

			widget->setBaseSize(QSize(288,384));
			widget->setFixedWidth(288);
			widget->setFixedHeight(384);
			widget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
			widget->setFocusPolicy(Qt::NoFocus);

			ui.ogreWidget->setAttribute(Qt::WA_PaintOnScreen);
			ui.ogreWidget->setAttribute(Qt::WA_NoSystemBackground);
			ui.ogreWidget->setAttribute(Qt::WA_NoBackground);
			ui.innerLayout->addWidget(widget, 1, 1);

			// We need a camera and Viewport in order to display anything
			Ogre::Camera* camera = Ogre::Root::getSingletonPtr()->getSceneManager("root")->createCamera("PlayerCam");
			Ogre::Viewport* viewport = static_cast<OgreWidget*>(widget)->getRenderWindow()->addViewport(camera);
			camera->setAspectRatio(
				Ogre::Real(viewport->getActualWidth()) / Ogre::Real(viewport->getActualHeight()));

			// Initialize UI & associated Managers
			Arcomage::UI::UIManager::getInstance().bootstrap();
		
			// Preload required Editor Fonts
			Arcomage::ResourceManager::getInstance().preloadResources(
				Arcomage::ConfigurationManager::getInstance().getPath("Fonts")+"/fonts.xml",
				/* unused, Music */ "", 
				/* unused, Sound effects */ "");
			
		} catch (Ogre::Exception& e) {
			rsError = true; 
			widget = new OgreWidget("errorwidget", ui.ogreWidget, true);
			ToolkitUtil::getInstance().notifyError(e.what());
		}

		populateTree();
		this->connectUI();
}
コード例 #10
0
MiniMapManager::MiniMapManager(Ogre::Root *root, Ogre::RenderWindow *window): mRoot(root), mWindow(window)
{
	mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "MiniMapSceneMgr");
	mCamera = mSceneMgr->createCamera("miniMapCamera");

	Ogre::Viewport *vp = mWindow->addViewport(mCamera, 1, 0, 0.8, 0.2, 0.2);
	vp->setBackgroundColour(Ogre::ColourValue(0, 0, 0));
	mCamera->setAutoAspectRatio((Ogre::Real(vp->getActualWidth())) / (Ogre::Real(vp->getActualHeight())));
	
	mSceneMgr->setAmbientLight(Ogre::ColourValue(0.8, 0.8, 0.8));
}
コード例 #11
0
ファイル: main.cpp プロジェクト: Isaj7/finalOgre
			// 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()));

			}
コード例 #12
0
ファイル: scene_manager.cpp プロジェクト: jmecosta/Navlaser3
//-------------------------------------------------------------------------------------
void THIS::createViewports(void)
{
    cout << "<TRACE><LOG><SceneManager><createViewports>  " << endl;
    // Create one viewport, entire window
    Ogre::Viewport* vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

    // Alter the camera aspect ratio to match the viewport
    mCamera->setAspectRatio(
                Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
コード例 #13
0
void GUIManager::windowResized(Ogre::RenderWindow* rw)
{
	int width = (int)rw->getWidth();
	int height = (int)rw->getHeight();
	setInputViewSize(width, height);

	BeamFactory *bf = BeamFactory::getSingletonPtr();
	if (bf) bf->windowResized();

	if (m_gui_GameMainMenu.get() != nullptr)
	{
		/* Adjust menu position */
		Ogre::Viewport* viewport = RoR::Application::GetOgreSubsystem()->GetRenderWindow()->getViewport(0);
		int margin = (viewport->getActualHeight() / 15);
		m_gui_GameMainMenu->SetPosition(
			margin, // left
			viewport->getActualHeight() - m_gui_GameMainMenu->GetHeight() - margin // top
			);
	}
}
//-------------------------------------------------------------------------------------
void DigitalForensicsVisualisation::createViewports(void)
{
	    // Create one viewport, entire window
    Ogre::Viewport* vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(.35,.35,.35));
    // Alter the camera aspect ratio to match the viewport
	//mCamera->setFarClipDistance(2000);
	
	mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));  
	mCamera->pitch(static_cast <Ogre::Radian>(-0.45));

}
コード例 #15
0
ファイル: MyGUI_Gui.cpp プロジェクト: twktheainur/vortex-ee
	// дл¤ оповещений об изменении окна рендера
	void Gui::windowResized(Ogre::RenderWindow* rw)
	{
		FloatSize oldViewSize = mViewSize;

		Ogre::Viewport * port = rw->getViewport(mActiveViewport);
		mViewSize.set(port->getActualWidth(), port->getActualHeight());
		mLayerManager->_windowResized(mViewSize);

		// выравниваем рутовые окна
		for (VectorWidgetPtr::iterator iter = mWidgetChild.begin(); iter!=mWidgetChild.end(); ++iter) {
			_alignWidget((*iter), oldViewSize, mViewSize);
		}
	}
コード例 #16
0
ファイル: AsteroidGame.cpp プロジェクト: Untamedhawk/Comp3501
void AsteroidGame::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 */
        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 second camera object */
        camera_2 = scene_manager->createCamera("MyCamera_2");
        Ogre::SceneNode* camera_scene_node_2 = root_scene_node->createChildSceneNode("MyCameraNode_2");
        camera_scene_node_2->attachObject(camera_2);

        camera_2->setNearClipDistance(camera_near_clip_distance_g);
        camera_2->setFarClipDistance(camera_far_clip_distance_g); 

		camera_2->setPosition(camera_position_g);
		camera_2->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);
		camera_2->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())));
    }
}
コード例 #17
0
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;
}
コード例 #18
0
ファイル: manager.cpp プロジェクト: jhooks1/openmw
    // для оповещений об изменении окна рендера
    void windowResized(Ogre::RenderWindow* _window)
    {
        if (_window->getNumViewports() > mActiveViewport)
        {
            Ogre::Viewport* port = _window->getViewport(mActiveViewport);
#if OGRE_VERSION >= MYGUI_DEFINE_VERSION(1, 7, 0) && OGRE_NO_VIEWPORT_ORIENTATIONMODE == 0
            Ogre::OrientationMode orient = port->getOrientationMode();
            if (orient == Ogre::OR_DEGREE_90 || orient == Ogre::OR_DEGREE_270)
                mViewSize.set(port->getActualHeight(), port->getActualWidth());
            else
                mViewSize.set(port->getActualWidth(), port->getActualHeight());
#else
            mViewSize.set(port->getActualWidth(), port->getActualHeight());
#endif

            // обновить всех
            mUpdate = true;

            updateRenderInfo();

            onResizeView(mViewSize);
        }
    }
コード例 #19
0
ファイル: OgreTank.cpp プロジェクト: WofloW/OgreTank_plus
// We will have a single viewport.  If you wanted splitscreen, or a rear-view mirror, then
// you may want multiple viewports.
void
OgreTank::createViewports(void)
{
    // Create one viewport, entire window
    Ogre::Viewport* vp = mWindow->addViewport(mCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0,0,0));
    // Alter the camera aspect ratio to match the viewport
    mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));

    Ogre::Viewport* vp2 = mWindow->addViewport(mCamera2, 1, 0.03, 0.03, 0.3, 0.3);
    vp2->setBackgroundColour(Ogre::ColourValue(0,0,0));
    vp2->setOverlaysEnabled(false);
    mCamera->setAspectRatio(Ogre::Real(vp2->getActualWidth()) / Ogre::Real(vp2->getActualHeight()));

}
コード例 #20
0
void StateManager::setupViewport( OgreManager & _ogreManager, Ogre::Camera * camera )
{
	if (camera != NULL && (camera != _ogreManager.getActiveCamera()))
	{
		_ogreManager.getWindowHandle()->removeAllViewports();
		// Create one viewport, entire window
		Ogre::Viewport* vp = _ogreManager.getWindowHandle()->addViewport(camera);
		//Set Background color
		vp->setBackgroundColour(Ogre::ColourValue(0,0,0));
		// Alter the camera aspect ratio to match the viewport
		camera->setAspectRatio(
			Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
		_ogreManager.setActiveCamera(camera);
	}
}
コード例 #21
0
ファイル: Atlas.cpp プロジェクト: ChWick/Zelda
CAtlas::CAtlas(CEntity *pParent, Ogre::SceneNode *pRootSceneNode)
  : CWorldEntity("atlas", pParent, nullptr),
    mFirstFrame(false),
    mFirstFrameUpdated(false),
    m_pCurrentMap(nullptr),
    m_pNextMap(nullptr),
    m_pPlayer(nullptr),
    m_pCameraPerspective(nullptr),
    m_bSwitchingMaps(false),
    m_bPlayerTargetReached(false),
    mEllipticFader(CFader::ELLIPTIC_FADER, this),
    mAlphaFader(CFader::ALPHA_FADER, this) {

  LOGV("Creating the Atlas");
  m_pSceneNode = pRootSceneNode->createChildSceneNode("Atlas");

  // create the world camera
  m_pWorldCamera = pRootSceneNode->getCreator()->createCamera("WorldCamera");
  m_pWorldCamera->setNearClipDistance(0.001f);
  m_pWorldCamera->setFarClipDistance(1000.0f);
  // default position
  m_pWorldCamera->setPosition(Ogre::Vector3(0,1,1));
  m_pWorldCamera->lookAt(Ogre::Vector3(0,0,0));
  //m_pWorldCamera->setProjectionType(Ogre::PT_ORTHOGRAPHIC);

  Ogre::Viewport *vp = CGame::getSingleton().getMainViewPort();
  m_pWorldCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
  vp->setCamera(m_pWorldCamera);
  m_pWorldCamera->setOrthoWindowWidth(1.6);

  LOGV(" - Creating Player");
  m_pPlayer = new CPlayer(this, m_pWorldCamera, CGame::getSingleton().getSceneManager());

  //m_pCameraPerspective = new CAerialCameraPerspective(m_pWorldCamera, (Ogre::SceneNode*)m_pAtlas->getChildren().front()->getSceneNode()->getChild(0));
  m_pCameraPerspective = new CAerialCameraPerspective(m_pWorldCamera, m_pPlayer);

  LOGV(" - Creating initial map");
  m_pCurrentMap = new CMap(this, CMapPackPtr(new CMapPack(CFileManager::getResourcePath("maps/Atlases/LightWorld/"), "inner_house_link")), m_pSceneNode, m_pPlayer);
  mFirstFrame = true;
  //m_pCurrentMap = new CMap(this, CMapPackPtr(new CMapPack(CFileManager::getResourcePath("maps/Atlases/LightWorld/"), "link_house_left")), m_pSceneNode, m_pPlayer);
  m_pPlayer->enterMap(m_pCurrentMap, Ogre::Vector3(0, 2, 0));
  m_pCurrentMap->start();

  CMessageHandler::getSingleton().addMessage(new CMessageSwitchMap(m_pCurrentMap->getMapPack()->getName(), CMessageSwitchMap::FINISHED, m_eSwitchMapType, m_pCurrentMap, nullptr));

  mEllipticFader.startFadeIn(1);
}
コード例 #22
0
ファイル: RenderSystem.cpp プロジェクト: jinghuaguo/magic3d
    void RenderSystem::Init()
    {
        InfoLog << "RenderSystem init...." << std::endl;
        mpRoot = new Ogre::Root();
        bool hasConfig = false;
        if (mpRoot->restoreConfig())
        {
            hasConfig = true;
        }
        else if (mpRoot->showConfigDialog())
        {
            hasConfig = true;
        }

        if (hasConfig)
        {
            // initialise system according to user options.
            mpRenderWin = mpRoot->initialise(true, "Magic3D");
            // Create the scene manager
            mpSceneMgr = mpRoot->createSceneManager(Ogre::ST_GENERIC, "MainSceneManager");
            // Create and initialise the camera
            mpMainCam = mpSceneMgr->createCamera("MainCamera");
            SetupCameraDefaultParameter();
            // Create a viewport covering whole window
            Ogre::Viewport* vp = mpRenderWin->addViewport(mpMainCam);
            //vp->setBackgroundColour(Ogre::ColourValue(0, 0, 0));
            vp->setBackgroundColour(Ogre::ColourValue(0.8627450980392157, 0.8627450980392157, 0.8627450980392157));
            // Update the camera aspect ratio to that of the viewport
            mpMainCam->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));

            mpRoot->addFrameListener(MagicListener::GetSingleton());
            Ogre::WindowEventUtilities::addWindowEventListener(mpRenderWin, MagicListener::GetSingleton());

            //get supported syntax information
            const Ogre::GpuProgramManager::SyntaxCodes &syntaxCodes = Ogre::GpuProgramManager::getSingleton().getSupportedSyntax();
            for (Ogre::GpuProgramManager::SyntaxCodes::const_iterator iter = syntaxCodes.begin();iter != syntaxCodes.end();++iter)
            {
                InfoLog << "supported syntax : " << (*iter) << std::endl;
            }
        }
        else
        {
            //Exist
        }

    }
コード例 #23
0
ファイル: PFCamera.cpp プロジェクト: hundben/simeng-g4
PFCamera::PFCamera(Ogre::SceneManager* mSceneMgr, Ogre::RenderWindow* mWindow) { 
	// Create the camera
	mCamera = mSceneMgr->createCamera("PlayerCam");
	
	// Position it at 500 in Z direction
	mCamera->setPosition(Ogre::Vector3(0,0,200));
	// Look back along -Z
	mCamera->lookAt(Ogre::Vector3(0,0,0));
	mCamera->setNearClipDistance(5);

	// Create one viewport, entire window
	Ogre::Viewport* vp = mWindow->addViewport(mCamera);
	vp->setBackgroundColour(Ogre::ColourValue(0,0,0));
	
	// Alter the camera aspect ratio to match the viewport
	mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
コード例 #24
0
ファイル: EC_OgreCamera.cpp プロジェクト: Chiru/naali
 EC_OgreCamera::EC_OgreCamera(Foundation::ModuleInterface* module) :
     Foundation::ComponentInterface(module->GetFramework()),
     renderer_(checked_static_cast<OgreRenderingModule*>(module)->GetRenderer()),
     attached_(false),
     camera_(0)
 {
     RendererPtr renderer = renderer_.lock();
     Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
     Ogre::Viewport* viewport = renderer->GetViewport();
     camera_ = scene_mgr->createCamera(renderer->GetUniqueObjectName());
     
     // Set default values for the camera
     camera_->setNearClipDistance(0.1f);
     camera_->setFarClipDistance(2000.f);
     
     camera_->setAspectRatio(Ogre::Real(viewport->getActualWidth() / Ogre::Real(viewport->getActualHeight())));
     camera_->setAutoAspectRatio(true);
 }
コード例 #25
0
ファイル: DemoApplication.cpp プロジェクト: Stuggy/ogrenewton
void DemoApplication::InitCamera()
{
	// Create the camera
	mCamera = mSceneMgr->createCamera("PlayerCam");

	// Position it at 500 in Z direction
	mCamera->setPosition(Ogre::Vector3(0,0,80));
	// Look back along -Z
	mCamera->lookAt(Ogre::Vector3(0,0,-200));
	mCamera->setNearClipDistance(0.1f);

	// create view ports
	// Create one viewport, entire window
	Ogre::Viewport* vp = mWindow->addViewport(mCamera);
	vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

	// Alter the camera aspect ratio to match the viewport
	mCamera->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
コード例 #26
0
ファイル: MyApp.cpp プロジェクト: bvigueras/sdl-ogre-sonido
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;
}
コード例 #27
0
ファイル: BaseManager.cpp プロジェクト: JohnCrash/iRobot
	void BaseManager::createSceneManager(){
		mSceneManager = mRoot->createSceneManager(Ogre::ST_GENERIC, "BaseSceneManager");

		mCamera = mSceneManager->createCamera("BaseCamera");
		mCamera->setNearClipDistance(5);
		mCamera->setPosition(100, 100, 100);
		mCamera->lookAt(0, 0, 0);

		// Create one viewport, entire window
		Ogre::Viewport* vp = mWindow->addViewport(mCamera);
		// Alter the camera aspect ratio to match the viewport
		mCamera->setAspectRatio((float)vp->getActualWidth() / (float)vp->getActualHeight());

		mSceneManager->setAmbientLight(Ogre::ColourValue::White);
		Ogre::Light* light = mSceneManager->createLight("MainLight");
		light->setType(Ogre::Light::LT_DIRECTIONAL);
		Ogre::Vector3 vec(-0.3f, -0.3f, -0.3f);
		vec.normalise();
		light->setDirection(vec);
	}
コード例 #28
0
	 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;
	 }
コード例 #29
0
//-------------------------------------------------------------------------------------
void SpaceLogin::createScene(void)
{
	g_accountName = kbe_getLastAccountName();
	if(g_accountName.size() == 0)
		g_accountName = KBEngine::StringConv::val2str(KBEngine::genUUID64());

	mTrayMgr->createButton(OgreBites::TL_CENTER, "login", "fast login", 120);

	Ogre::StringVector values;
	values.push_back(g_accountName);
	mTrayMgr->createParamsPanel(OgreBites::TL_CENTER, "accountName", 300, values);

	mTrayMgr->showCursor();
	
	mTrayMgr->hideFrameStats();
	mTrayMgr->hideLogo();
	mTrayMgr->hideBackdrop();

	mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);

    // Create the camera
    mActiveCamera = mSceneMgr->createCamera("PlayerCam");

    // Position it at 500 in Z direction
    mActiveCamera->setPosition(Ogre::Vector3(0,0,80));
    // Look back along -Z
    mActiveCamera->lookAt(Ogre::Vector3(0,0,-300));
    mActiveCamera->setNearClipDistance(5);

    mCameraMan = new OgreBites::SdkCameraMan(mActiveCamera);   // create a default camera controller
    mCameraMan->setTopSpeed(7.0f);
	OgreApplication::getSingleton().setCurrCameraMan(mCameraMan);

    // Create one viewport, entire window
    Ogre::Viewport* vp = mWindow->addViewport(mActiveCamera);
    vp->setBackgroundColour(Ogre::ColourValue(0,0,0));

    // Alter the camera aspect ratio to match the viewport
    mActiveCamera->setAspectRatio(
        Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
コード例 #30
0
ファイル: Game.cpp プロジェクト: adasm/frail-htn
void Game::initRendering()
{
#ifdef _DEBUG
    const char* plugin_file = "plugins_d.cfg";
#else
    const char* plugin_file = "plugins.cfg";
#endif

    m_ogreRoot = new Ogre::Root(plugin_file);
    m_ogreRoot->showConfigDialog();
    m_ogreRoot->initialise(true);

    m_renderWindow = m_ogreRoot->getAutoCreatedWindow(); //createRenderWindow("mkdemo", 800, 600, false);

    m_ogreSceneMgr = m_ogreRoot->createSceneManager(Ogre::ST_GENERIC);
    m_ogreCamera = m_ogreSceneMgr->createCamera("main_cam");
    Ogre::Viewport* viewport = m_renderWindow->addViewport(m_ogreCamera);
    m_ogreCamera->setAspectRatio(viewport->getActualWidth() / (float)viewport->getActualHeight());

    // DebugDrawer singleton
    new DebugDrawer(m_ogreSceneMgr, .75f);

    loadOgreResources();

    // overlay
    Ogre::Overlay* hud = Ogre::OverlayManager::getSingleton().getByName("Game/HUD");
    hud->show();

    if (m_disableShadows)
        m_ogreSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_NONE);
    else
        m_ogreSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
    m_ogreCamera->setNearClipDistance(0.1f);

    if (!m_startWithFreelook)
        m_playerCam = new CameraTPP(m_ogreCamera, NULL);
    else
        m_playerCam = new CameraFPP(m_ogreCamera, NULL);

    m_ogreSceneMgr->setAmbientLight(Ogre::ColourValue(0.3f, 0.3f, 0.3f)); // please note it's usually changed on level deserialization with RenderSettingsSetter
}