Win32 或 MFC 下初始化OGRE 窗口

最新推荐文章于 2021-05-14 14:10:27 发布
最新推荐文章于 2021-05-14 14:10:27 发布
阅读量3.7k 收藏 2
点赞数
分类专栏： OGRE 文章标签： mfc string keyboard vector pair null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhucde/article/details/3550468
版权
这个问题经常有人要问, 网上其实能够搜索得到, 为什么还有这么多人要问:

一是,原来网上的版本有些旧, 会出一些错误

二是, 可能不太清楚,

今天我也写一个吧, 尽量详细,(可能也不太清楚^-^)
(注: 今天的例子为了便于理解, 我使用Win32窗口的框架, 不用MFC, 当然,Win32窗口跟MFC其实是一样的, 稍微转化一下即可)

新建一个Win32窗口的程序,本例子中名称为:Win32Ogre,

所有代码在Win32Ogre.cpp中, 代码如下, 解释全部看注释吧,:

  1. // Win32Ogre.cpp : Defines the entry point for the application.
  2. //
  4. #include "stdafx.h"
  5. #include "Win32Ogre.h"
  7. #include "ogre.h"
  8. #include "MyExampleFrameListener.h"
  10. #define MAX_LOADSTRING 100
  12. // Global Variables:
  13. HINSTANCE hInst;                                // current instance
  14. TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
  15. TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
  18. HWND hWnd;
  20. //OGRE -------------------//
  21. Root* mRoot;
  22. RenderWindow* mWindow;
  23. SceneManager* mSceneMgr;
  24. Camera* mCamera;
  26. Viewport* vp ;
  28.  
  29. void setupResources();
  32. void SetRoot()
  33. {
  34.     //----创建根实例
  36.     mRoot = new Root();//无参数即默认参数Root("plugin.cfg","ogre.cfg","ogre.log")
  38.     //----设置资源目录(声明资源:此时资源未初始化,不可使用)
  39.     setupResources();//目录设置根据"resource.cfg"
  41.     if(!mRoot->showConfigDialog())//你不想弹出那个配置对话框就注释掉此句, 下面的程序是手动来配置,手动配置自动使用D3D
  42.     {
  43.     //-----初始化渲染器
  44.         RenderSystemList* rl = Root::getSingleton().getAvailableRenderers();//获得所有可用渲染器
  45.         RenderSystem* rsys = NULL;
  46.         RenderSystemList::iterator it = rl->begin();//循环列表,得到GL渲染器
  47.         while( it != rl->end() )
  48.         { 
  49.             if( -1 != ( *it )->getName().find( "3D9" )  )
  50.             {
  51.                 rsys = (RenderSystem*)( *it );
  52.                 break;
  53.             }
  54.             it++;
  55.         }
  56.     
  57.         //设置渲染器属性
  58.      
  59.         rsys->setConfigOption( "Full Screen", "No" );
  61.         rsys->setConfigOption( "VSync", "No" );
  62.     
  63.         rsys->setConfigOption( "Video Mode", "800 x 600" );
  64.      
  65.         mRoot->setRenderSystem( rsys ); // 起用该渲染器
  66.     
  67.     
  68.         
  69.     }
  70.     mRoot->initialise(0);
  71.     
  75.     //-------初始化渲染窗口(自建)
  76.     NameValuePairList parms;
  77.     parms["externalWindowHandle"] = StringConverter::toString((long)hWnd);
  78.     RECT   rect;
  79.     ::GetWindowRect(hWnd,&rect);
  80.     mWindow = mRoot->createRenderWindow("MFC Window", rect.right-rect.left, rect.bottom-rect.top, false, &parms);
  82.     //渲染窗口事实上是由渲染器所创建RenderSystem::CreateRenderWindow
  83. }
  86. void CreateCamVP()
  87. { 
  88.     mCamera = mSceneMgr->createCamera("PlayerCam");
  90.     mCamera->setPosition(Vector3(0,0,500));
  91.     mCamera->lookAt(Vector3(0,0,-300));
  92.     mCamera->setNearClipDistance(1);
  93.     mCamera->setFarClipDistance(100000);
  94.     mCamera->setQueryFlags(8);//临时定一个掩码值,暂时与现在的所有掩码不冲突,保证检测不到相机
  96.     // -------创建视口
  97.     vp = mWindow->addViewport(mCamera);
  98.  
  99.     // 视口创建好后调整相机的比例
  100.     mCamera->setAspectRatio(
  101.         Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
  103. }
  105. //设置阴影
  106. void AddShadowEffect()
  107. {
  109.     mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
  110.     LiSPSMShadowCameraSetup* lispsm = new LiSPSMShadowCameraSetup();
  111.     lispsm->setOptimalAdjustFactor(0.5);
  112.     mSceneMgr->setShadowFarDistance(1000);
  113.     mSceneMgr->setShadowCameraSetup(ShadowCameraSetupPtr(lispsm));
  115.     mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5));
  117. }
  119. //设置场景相关的效果，如灯光，雾，天空，视口背景色等
  120. void SetAmbientRef()
  121. {
  122.     //--------创建灯光
  123.     Light* l = mSceneMgr->createLight("MainLight");
  124.     l->setPosition(20,2000,50);
  127.     //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 800, 2000);
  128.     mSceneMgr->setAmbientLight(ColourValue(0.5,0.5,0.5));
  129.     ColourValue fadeColour(0.93, 0.86, 0.76);
  130.     mWindow->getViewport(0)->setBackgroundColour(fadeColour);
  131.  
  133.     mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox");
  135. }
  138. void setupResources()
  139. {
  140.     ConfigFile cf;
  141.     cf.load("resources.cfg");
  143.     // Go through all sections & settings in the file
  144.     ConfigFile::SectionIterator seci = cf.getSectionIterator();
  146.     String secName, typeName, archName;
  147.     while (seci.hasMoreElements())
  148.     {
  149.         secName = seci.peekNextKey();
  150.         ConfigFile::SettingsMultiMap *settings = seci.getNext();
  151.         ConfigFile::SettingsMultiMap::iterator i;
  152.         for (i = settings->begin(); i != settings->end(); ++i)
  153.         {
  154.             typeName = i->first;
  155.             archName = i->second;
  156.             ResourceGroupManager::getSingleton().addResourceLocation(
  157.                 archName, typeName, secName);
  158.         }
  159.     }
  162. }
  164. void CreateScene()
  165. {
  168.     //----------初始化OGRE(自动加载插件)----------------//
  170.     SetRoot();
  171.  
  172.     Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
  173.  
  174.     //-------创建场景管理器-------------------------------//
  175.     mSceneMgr = mRoot->createSceneManager(ST_GENERIC);//在新版本中,getSceneManager全部更新为createSceneManager
  176.      
  177.     //-----------打开阴影-------------------------------//
  178.     AddShadowEffect();
  180.     //=======================================================//
  182.     //--------创建相机并设置,创建视口----//
  183.     CreateCamVP();
  184.     //===================================//
  185.   
  186.     //-------设置环境相关，如灯光，雾，天空等------------//
  187.     SetAmbientRef();
  188.     //===================================================//
  189.      
  191.     //-------设置FramListener---------------------------//
  192.     MyExampleFrameListener *m_FramListenler=new MyExampleFrameListener(mWindow,mCamera,hWnd);
  193.     mRoot->addFrameListener(m_FramListenler);
  194.     //==================================================//.
  195.  
  196.     mWindow->update();
  197.      
  199. }
  201. //========================//
  204. // Forward declarations of functions included in this code module:
  205. ATOM                MyRegisterClass(HINSTANCE hInstance);
  206. BOOL                InitInstance(HINSTANCE, int);
  207. LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
  208. INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
  210. int APIENTRY _tWinMain(HINSTANCE hInstance,
  211.                      HINSTANCE hPrevInstance,
  212.                      LPTSTR    lpCmdLine,
  213.                      int       nCmdShow)
  214. {
  215.     UNREFERENCED_PARAMETER(hPrevInstance);
  216.     UNREFERENCED_PARAMETER(lpCmdLine);
  218.     // TODO: Place code here.
  219.     MSG msg;
  220.     HACCEL hAccelTable;
  222.     // Initialize global strings
  223.     LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
  224.     LoadString(hInstance, IDC_WIN32OGRE, szWindowClass, MAX_LOADSTRING);
  225.     MyRegisterClass(hInstance);
  227.     // Perform application initialization:
  228.     if (!InitInstance (hInstance, nCmdShow))
  229.     {
  230.         return FALSE;
  231.     }
  233.     hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WIN32OGRE));
  235.     // Main message loop:
  236.     while (GetMessage(&msg, NULL, 0, 0))
  237.     {
  238.         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
  239.         {
  240.             TranslateMessage(&msg);
  241.             DispatchMessage(&msg);
  242.         }
  243.     }
  245.     return (int) msg.wParam;
  246. }
  248.  
  249. ATOM MyRegisterClass(HINSTANCE hInstance)
  250. {
  251.     WNDCLASSEX wcex;
  253.     wcex.cbSize = sizeof(WNDCLASSEX);
  255.     wcex.style          = CS_HREDRAW | CS_VREDRAW;
  256.     wcex.lpfnWndProc    = WndProc;
  257.     wcex.cbClsExtra     = 0;
  258.     wcex.cbWndExtra     = 0;
  259.     wcex.hInstance      = hInstance;
  260.     wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WIN32OGRE));
  261.     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
  262.     wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
  263.     wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_WIN32OGRE);
  264.     wcex.lpszClassName  = szWindowClass;
  265.     wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
  267.     return RegisterClassEx(&wcex);
  268. }
  269.  
  270. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  271. {
  272.    
  274.    hInst = hInstance; // Store instance handle in our global variable
  276.    hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
  277.       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
  279.    if (!hWnd)
  280.    {
  281.       return FALSE;
  282.    }
  284.    ShowWindow(hWnd, nCmdShow);
  285.    UpdateWindow(hWnd);
  286.    SetTimer(hWnd,1,1,0);
  288.    return TRUE;
  289. }
  291.  
  292. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  293. {
  294.     int wmId, wmEvent;
  295.     PAINTSTRUCT ps;
  296.     HDC hdc;
  298.     switch (message)
  299.     {
  300.     case WM_COMMAND:
  301.         wmId    = LOWORD(wParam);
  302.         wmEvent = HIWORD(wParam);
  303.         // Parse the menu selections:
  304.         switch (wmId)
  305.         {
  306.         case IDM_ABOUT:
  307.             DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
  308.             break;
  309.         case IDM_EXIT:
  310.             DestroyWindow(hWnd);
  311.             break;
  312.         default:
  313.             return DefWindowProc(hWnd, message, wParam, lParam);
  314.         }
  315.         break;
  317.     case WM_TIMER:  //这里的处理,如果在MFC中,即是响应OnTimer
  318.         {
  319.             static int once=1;
  320.             if(once==1)
  321.             {
  322.                 once=2;
  323.                 CreateScene();    //这里即全部的初始化操作, 放在这里是为了不影响窗口初始化,能够先弹出来
  324.                 
  325.             }
  326.             if(once==2)
  327.                 mRoot->renderOneFrame();   //每帧渲染, 当然前提是先初始化好OGRE
  329.         }
  330.         break;
  332.     case WM_PAINT:
  333.         hdc = BeginPaint(hWnd, &ps);
  334.         // TODO: Add any drawing code here...
  335.         EndPaint(hWnd, &ps);
  336.         break;
  337.     case WM_DESTROY:
  338.         PostQuitMessage(0);
  339.         break;
  340.     default:
  341.         return DefWindowProc(hWnd, message, wParam, lParam);
  342.     }
  343.     return 0;
  344. }
  346. // Message handler for about box.
  347. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  348. {
  349.     UNREFERENCED_PARAMETER(lParam);
  350.     switch (message)
  351.     {
  352.     case WM_INITDIALOG:
  353.         return (INT_PTR)TRUE;
  355.     case WM_COMMAND:
  356.         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  357.         {
  358.             EndDialog(hDlg, LOWORD(wParam));
  359.             return (INT_PTR)TRUE;
  360.         }
  361.         break;
  362.     }
  363.     return (INT_PTR)FALSE;
  364. }



最后添加我改写的文件: MyExampleFrameListener.h

当然, 你直接用Ogre的 例子中的ExampleFrameListener.h 也行, 近我这个修改就行了.

  1. #ifndef __MyExampleFrameListener_H__
  2. #define __MyExampleFrameListener_H__
  4. #include "Ogre.h"
  5. #include "OgreStringConverter.h"
  6. #include "OgreException.h"
  8. //Use this define to signify OIS will be used as a DLL
  9. //(so that dll import/export macros are in effect)
  10. #define OIS_DYNAMIC_LIB
  11. #include <OIS/OIS.h>  //使用OIS
  13.  

  15.  
  17. using namespace Ogre;
  18. using namespace std;
  19. using Ogre::uint;
  21. class MyExampleFrameListener: public FrameListener, public WindowEventListener
  22. {
  23.  
  24. protected:
  25.     void updateStats(void)
  26.     {
  27.         
  28.         static String currFps = "Current FPS: ";
  29.         static String avgFps = "Average FPS: ";
  30.         static String bestFps = "Best FPS: ";
  31.         static String worstFps = "Worst FPS: ";
  32.         static String tris = "Triangle Count: ";
  33.         static String batches = "Batch Count: ";
  35.         // update stats when necessary
  36.         try {
  37.             OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
  38.             OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
  39.             OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
  40.             OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
  41.  
  43.             const RenderTarget::FrameStats& stats = mWindow->getStatistics();
  44.             guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
  45.             guiCurr->setCaption(currFps + StringConverter::toString(stats.lastFPS));
  46.             guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
  47.                 +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
  48.             guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
  49.                 +" "+StringConverter::toString(stats.worstFrameTime)+" ms");
  51.             
  53.             OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
  54.             guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));
  56.             OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
  57.             guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));
  60.             OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
  61.             guiDbg->setCaption(mDebugText);
  62.             guiDbg->setColour(ColourValue(1,1,1));
  63.         }
  64.         catch(...) { /* ignore */ }
  65.     }
  67. public:
  68.     // Constructor takes a RenderWindow because it uses that to determine input context
  69.     MyExampleFrameListener(RenderWindow* win, Camera* cam, HWND h,bool bufferedKeys = false, bool bufferedMouse = false,
  70.                  bool bufferedJoy = false ) :
  71.         mCamera(cam), m_hwnd(h),mTranslateVector(Vector3::ZERO), mWindow(win), mStatsOn(true), mNumScreenShots(0),
  72.         mMoveScale(0.0f), mRotScale(0.0f), mTimeUntilNextToggle(0), mFiltering(TFO_BILINEAR),
  73.         mAniso(1), mSceneDetailIndex(0), mMoveSpeed(100), mRotateSpeed(36), mDebugOverlay(0),
  74.         mInputManager(0), mMouse(0), mKeyboard(0), mJoy(0)
  75.     {
  76.         using namespace OIS;
  78.         mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
  79.          
  80.  
  81.         LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
  82.         ParamList pl;
  83.         
  84.  
  85.          //下面这段是重点, 使用Win32的窗口
  86.         unsigned long h1 = (unsigned long)m_hwnd;
  87.         pl.insert(std::make_pair(std::string("WINDOW"), StringConverter::toString(h1)));
  89.         pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
  90.         pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
  91.         pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
  92.         pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
  93.         mInputManager = InputManager::createInputSystem( pl );
  96.          
  99.         //Create all devices (We only catch joystick exceptions here, as, most people have Key/Mouse)
  100.         mKeyboard = static_cast<Keyboard*>(mInputManager->createInputObject( OISKeyboard, bufferedKeys ));
  101.         mMouse = static_cast<Mouse*>(mInputManager->createInputObject( OISMouse, bufferedMouse ));
  102.         try {
  103.             mJoy = static_cast<JoyStick*>(mInputManager->createInputObject( OISJoyStick, bufferedJoy ));
  104.         }
  105.         catch(...) {
  106.             mJoy = 0;
  107.         }
  109.         //Set initial mouse clipping size
  110.         windowResized(mWindow);
  112.         showDebugOverlay(true);
  114.         //Register as a Window listener
  115.         WindowEventUtilities::addWindowEventListener(mWindow, this);
  116.     }
  118.     //Adjust mouse clipping area
  119.     virtual void windowResized(RenderWindow* rw)
  120.     {
  121.         unsigned int width, height, depth;
  122.         int left, top;
  123.         rw->getMetrics(width, height, depth, left, top);
  125.         const OIS::MouseState &ms = mMouse->getMouseState();
  126.         ms.width = width;
  127.         ms.height = height;
  128.     }
  130.     //Unattach OIS before window shutdown (very important under Linux)
  131.     virtual void windowClosed(RenderWindow* rw)
  132.     {
  133.         //Only close for window that created OIS (the main window in these demos)
  134.         if( rw == mWindow )
  135.         {
  136.             if( mInputManager )
  137.             {
  138.                 mInputManager->destroyInputObject( mMouse );
  139.                 mInputManager->destroyInputObject( mKeyboard );
  140.                 mInputManager->destroyInputObject( mJoy );
  142.                 OIS::InputManager::destroyInputSystem(mInputManager);
  143.                 mInputManager = 0;
  144.             }
  145.         }
  146.     }
  148.     virtual ~MyExampleFrameListener()
  149.     {
  150.         //Remove ourself as a Window listener
  151.         WindowEventUtilities::removeWindowEventListener(mWindow, this);
  152.         windowClosed(mWindow);
  153.     }
  155.     virtual bool processUnbufferedKeyInput(const FrameEvent& evt)
  156.     {
  157.         using namespace OIS;
  159.         int vel=1;//速度增加1倍
  161.         if(mKeyboard->isKeyDown(KC_A))
  162.             mTranslateVector.x = -mMoveScale*vel;   // Move camera left
  164.         if(mKeyboard->isKeyDown(KC_D))
  165.             mTranslateVector.x = mMoveScale*vel;    // Move camera RIGHT
  167.         if(mKeyboard->isKeyDown(KC_UP) || mKeyboard->isKeyDown(KC_W) )
  168.             mTranslateVector.z = -mMoveScale*vel;   // Move camera forward
  170.         if(mKeyboard->isKeyDown(KC_DOWN) || mKeyboard->isKeyDown(KC_S) )
  171.             mTranslateVector.z = mMoveScale*vel;    // Move camera backward
  173.         if(mKeyboard->isKeyDown(KC_PGUP))
  174.             mTranslateVector.y = mMoveScale;    // Move camera up
  176.         if(mKeyboard->isKeyDown(KC_PGDOWN))
  177.             mTranslateVector.y = -mMoveScale;   // Move camera down
  179.         if(mKeyboard->isKeyDown(KC_RIGHT))
  180.             mCamera->yaw(-mRotScale);
  182.         if(mKeyboard->isKeyDown(KC_LEFT))
  183.             mCamera->yaw(mRotScale);
  185.          
  186.         if( mKeyboard->isKeyDown(KC_ESCAPE) || mKeyboard->isKeyDown(KC_Q) )
  187.             return false;
  189.         if( mKeyboard->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0 )
  190.         {
  191.             mStatsOn = !mStatsOn;
  192.             showDebugOverlay(mStatsOn);
  193.             mTimeUntilNextToggle = 1;
  194.         }
  195.  
  197.         if( mKeyboard->isKeyDown(KC_T) && mTimeUntilNextToggle <= 0 )
  198.         {
  199.             switch(mFiltering)
  200.             {
  201.             case TFO_BILINEAR:
  202.                 mFiltering = TFO_TRILINEAR;
  203.                 mAniso = 1;
  204.                 break;
  205.             case TFO_TRILINEAR:
  206.                 mFiltering = TFO_ANISOTROPIC;
  207.                 mAniso = 8;
  208.                 break;
  209.             case TFO_ANISOTROPIC:
  210.                 mFiltering = TFO_BILINEAR;
  211.                 mAniso = 1;
  212.                 break;
  213.             default: break;
  214.             }
  215.             MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
  216.             MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
  218.             showDebugOverlay(mStatsOn);
  219.             mTimeUntilNextToggle = 1;
  220.         }
  222.         if(mKeyboard->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
  223.         {
  224.             std::ostringstream ss;
  225.             ss << "screenshot_" << ++mNumScreenShots << ".png";
  226.             mWindow->writeContentsToFile(ss.str());
  227.             mTimeUntilNextToggle = 0.5;
  228.             mDebugText = "Saved: " + ss.str();
  229.         }
  231.         if(mKeyboard->isKeyDown(KC_R) && mTimeUntilNextToggle <=0)
  232.         {
  233.             mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
  234.             switch(mSceneDetailIndex) {
  235.                 case 0 : mCamera->setPolygonMode(PM_SOLID); break;
  236.                 case 1 : mCamera->setPolygonMode(PM_WIREFRAME); break;
  237.                 case 2 : mCamera->setPolygonMode(PM_POINTS); break;
  238.             }
  239.             mTimeUntilNextToggle = 0.5;
  240.         }
  242.         static bool displayCameraDetails = false;
  243.         if(mKeyboard->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
  244.         {
  245.             displayCameraDetails = !displayCameraDetails;
  246.             mTimeUntilNextToggle = 0.5;
  247.             if (!displayCameraDetails)
  248.                 mDebugText = "";
  249.         }
  251.         // Print camera details
  252.         if(displayCameraDetails)
  253.             mDebugText = "P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
  254.                          " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation());
  256.         // Return true to continue rendering
  257.         return true;
  258.     }
  260.     bool processUnbufferedMouseInput(const FrameEvent& evt)
  261.     {
  262.         using namespace OIS;
  264.         // Rotation factors, may not be used if the second mouse button is pressed
  265.         // 2nd mouse button - slide, otherwise rotate
  266.         const MouseState &ms = mMouse->getMouseState();
  269.         if( ms.buttonDown( MB_Middle ) )
  270.         {
  271.             mTranslateVector.x -= ms.X.rel * 0.13;
  272.             mTranslateVector.y += ms.Y.rel * 0.13;
  273.         }
  274.         if(ms.buttonDown(MB_Left))//此处改为左键按下旋转镜头
  275.         {
  276.             mRotX = Degree(-ms.X.rel * 0.13);
  277.             mRotY = Degree(-ms.Y.rel * 0.13);
  278.         }
  279.         if(ms.Z.rel)
  280.             mTranslateVector.z = -ms.Z.rel;//使用滚轮来ZoomIn/ZoomOut
  282.         return true;
  283.     }
  285.     void moveCamera()
  286.     {
  287.         // Make all the changes to the camera
  288.         // Note that YAW direction is around a fixed axis (freelook style) rather than a natural YAW
  289.         //(e.g. airplane)
  290.         mCamera->yaw(mRotX);
  291.         mCamera->pitch(mRotY);
  292.         mCamera->moveRelative(mTranslateVector);
  293.          
  294.     }
  296.     void showDebugOverlay(bool show)
  297.     {
  298.         if (mDebugOverlay)
  299.         {
  300.             if (show)
  301.                 mDebugOverlay->show();
  302.             else
  303.                 mDebugOverlay->hide();
  304.          
  305.         }
  306.     }
  309.     // Override frameStarted event to process that (don't care about frameEnded)
  310.     bool frameStarted(const FrameEvent& evt)
  311.     {
  312.         using namespace OIS;
  314.         if(mWindow->isClosed()) return false;
  316.         //Need to capture/update each device
  317.         mKeyboard->capture();
  318.         mMouse->capture();
  319.         if( mJoy ) mJoy->capture();
  321.         bool buffJ = (mJoy) ? mJoy->buffered() : true;
  323.         //Check if one of the devices is not buffered
  324.         if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
  325.         {
  326.             // one of the input modes is immediate, so setup what is needed for immediate movement
  327.             if (mTimeUntilNextToggle >= 0)
  328.                 mTimeUntilNextToggle -= evt.timeSinceLastFrame;
  330.             // If this is the first frame, pick a speed
  331.             if (evt.timeSinceLastFrame == 0)
  332.             {
  333.                 mMoveScale = 1;
  334.                 mRotScale = 0.1;
  335.             }
  336.             // Otherwise scale movement units by time passed since last frame
  337.             else
  338.             {
  339.                 // Move about 100 units per second,
  340.                 mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
  341.                 // Take about 10 seconds for full rotation
  342.                 mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
  343.             }
  344.             mRotX = 0;
  345.             mRotY = 0;
  346.             mTranslateVector = Ogre::Vector3::ZERO;
  347.         }
  349.         //Check to see which device is not buffered, and handle it
  350.         if( !mKeyboard->buffered() )
  351.             if( processUnbufferedKeyInput(evt) == false )
  352.                 return false;
  353.         if( !mMouse->buffered() )
  354.             if( processUnbufferedMouseInput(evt) == false )
  355.                 return false;
  357.         if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )
  358.             moveCamera();
  360.         return true;
  361.     }
  363.     bool frameEnded(const FrameEvent& evt)
  364.     {
  365.         updateStats();
  366.         return true;
  367.     }
  369. protected:
  370.     Camera* mCamera;
  372.     HWND m_hwnd;
  374.     Vector3 mTranslateVector;
  375.     RenderWindow* mWindow;
  376.     bool mStatsOn;
  378.     std::string mDebugText;
  380.     unsigned int mNumScreenShots;
  381.     float mMoveScale;
  382.     Degree mRotScale;
  383.     // just to stop toggles flipping too fast
  384.     Real mTimeUntilNextToggle ;
  385.     Radian mRotX, mRotY;
  386.     TextureFilterOptions mFiltering;
  387.     int mAniso;
  389.     int mSceneDetailIndex ;
  390.     Real mMoveSpeed;
  391.     Degree mRotateSpeed;
  392.     Overlay* mDebugOverlay;
  394.     //OIS Input devices
  395.     OIS::InputManager* mInputManager;
  396.     OIS::Mouse*    mMouse;
  397.     OIS::Keyboard* mKeyboard;
  398.     OIS::JoyStick* mJoy;
  399. };
  403. #endif

zhucde
关注
专栏目录
OGRE启动顺序--以及官方示例程序分析
Wait的专栏
04-24 1513
下面内容第一部分可见sina博客： 一、不创建类，直接在main函数中实现的过程 首先添加头文件：#include "Ogre\Ogre.h" （使用Ogre命名空间） 第一步：建立一个空窗体要的对象 总结成：R-WMAV（WMV）共5个对象 R-root对象（外观模式），W-窗口window对象，M-场景管理器manager，A-camera对象，V-视口view对象 具体： Og
OGRE3D入门探索01:将渲染窗口嵌入到Win32主窗口
akzc42847的博客
03-23 268
从《OGRE3D引擎入门重拾》这篇文章开始，本系列关注OGRE3D渲染引擎及其周边应用。 本文以一个简单的示例来说明如何将Ogre的渲染窗口嵌入到另一个父窗口中， 为了增加趣味性（就是这么任性哈）我特意增加了FMOD的音乐播放支持。 首先将代码贴上来吧 /////////////////////////////////////////////////...
win32和MFC下如何使用控制台窗口
rabbit729的专栏
11-05 8899
   在win32和MFC程序中，有时需要输出一些调试信息，本文介绍在win32和MFC程序中使用控制台输出信息的方法。我们可以在应用程序里使用AllocConsole()函数自己开一个控制台(就像DOS窗口一样)，然后重定向输入输出，就可以用printf函数向控制台输出信息了，具体方法如下：   在CWinApp的重载函数InitInstance()中输入如下语句，开辟一个控制台并重定向输出
OGRE 渲染 到 MFC
痞子龙3D编程
02-21 2508
网上睇到一个OGRE——MFC的代码就是在mfc 单文挡架构下 cview 里面 onpait 这个消息函数加个settimer 刷新UI 然后 嗯 无了我在这个之上 将CView继成 用个MFC 多线程UI的东东 这样 旁边再加个停靠窗口 用CJ60LibCVIEW插入一个 ogreappliction 不过 这个监听器呢 用OIS OIS 一定要绑定主窗口句柄的 即CMainWND 而渲染那个
【Ogre-windows】实例配置
风翼冰舟的博客
11-30 3106
前言折腾了好久才搞定教程实例, 主要是因为上一篇博客安装的具体版本是Ogre1.10.9, 而官方的Ogre Wiki Tutorial Framework没有指定具体版本, 如果单纯下载Ogre Wiki Tutorial Framework 1.10 - (Windows line endings, updated 2015-10-15) 运行, 基本会血崩. 所以, 在经过仔细琢磨官网以后发
win32下初始化OGRE窗口
11-14
在探讨“win32下初始化OGRE窗口”的过程中，我们首先需要理解几个核心概念：Win32编程环境、OGRE图形引擎以及初始化过程中的关键步骤。以下是对标题和描述所涉及知识点的详细解读： ### Win32编程环境 Win32 API是...
Win32环境下配置OGRE图形引擎初学者教程
在Win32环境下初始化OGRE窗口，首先需要了解OGRE是一个强大的3D图形渲染引擎，广泛用于游戏开发和其他需要高质量3D图形的应用。为了在Win32下使用OGRE，我们需要完成以下几个关键步骤： 1. **创建Win32应用程序入口...
Ogre+MFC.rar_OGRE M_OGRE MFC_OGRE 机器人足球仿真系统_Ogre_ Ogre_ogre
09-19
在OnCreate()函数中，我们可以初始化Ogre的渲染系统，设置渲染窗口的大小和位置，使其与MFC窗口对应。同时，需要确保Ogre的消息泵能够正确处理来自Windows的消息，以便实现窗口的缩放、移动等操作。 接下来，为了将...
cegui.zip_Ogre_ Ogre_cegui ogre_cegui ogre mfc_ogre_ogre cegui
09-24
1. **初始化Ogre**：首先，我们需要配置Ogre的渲染系统，选择适当的渲染API，设置窗口大小和分辨率，加载必要的资源（如材质、纹理和模型）。 2. **集成CEGUI**：接着，我们需要初始化CEGUI系统，指定字体、图像集...
Ogre在MFC下的多窗口实现
12-13
在这个类中，我们需要初始化Ogre的上下文，包括资源管理器、渲染系统、窗口句柄等。 4. **使用DockablePane**：创建一个CWnd派生类，实例化为DockablePane，用于承载Ogre的渲染窗口。设置其布局和行为，如是否可以...
ogre在Linux下如何创建窗口,一步步搭建Ogre - 菜鸟学Ogre教程_Linux编程_Linux公社-Linux系统门户网站...
weixin_34917128的博客
05-14 497
这次的教程是完全脱离了wiki的框架，白手起家搭建Ogre。Ogre的最基本的生命周期如下：1.创建根对象；2.定义Ogre将要用到的资源；3.选择并设置渲染引擎(指的是DirectX，OpenGL等等)；4.创建渲染窗口；5.初始化资源；6.创建场景；7.设置第三方库和插件；8.创建帧监听；9.开始渲染循环。第一步：创建Root对象Root对象是Ogre库的核心，它必须被最先创建。在头文件中加入...
Ogre简单实例
qq_40239482的博客
07-16 626
#include"OgreRoot.h" #include"OgreRenderSystem.h" #include"OgreRenderWindow.h" #include"OgreConfigFile.h" #include"OgreResourceGroupManager.h" #include"OgreLogManager.h" #include"OgreViewport.h" #inc...
从基本的函数和WIN32API实现OGRE窗口
pubhobo的专栏
06-25 770
从基本的函数和WIN32API实现OGRE窗口 转载：http://lyme.blog.sohu.com/99908122.html#include "Ogre.h"#include "OgreConfigFile.h"#include "OgreStringConverter.h"#include "windows.h"// declare wndprocLRESUL
窗口(Window对象)基本操作应用示例(一)
国际海员
01-26 2880
第二章  窗口(Window对象)基本操作应用示例(一)Window对象代表一个窗口，约有48个属性和14个方法，能对窗口特性进行设置和操作。Window对象是Windows集合中的成员，对于Application对象来说，Windows集合包含该应用程序中的所有窗口；对于Workbook对象来说，Windows集合只包含指定工作簿中的窗口。下面介绍一些示例，以演示和说明Window对象及其属性和
Ogre核心类
xueying_的专栏
06-15 1095
一、Ogre核心类 Ogre是一个面向对象的图形引擎，其中的主体也就是一些对象，下面对Ogre的核心类做一个简单的列举和介绍。 1.1 Root类          Ogre的对象体系是一个树形结构，这个树形结构的根就是Root对象，它是Ogre中最基本的对象，并负责对Ogre的一切内容进行管理。          Root对象的构造函数如下所示：                   R
菜鸟也学Ogre-一步步搭建Ogre
mmdev
08-06 218
这次的教程是完全脱离了wiki的框架，白手起家搭建Ogre。 Ogre的最基本的生命周期如下： 1.创建根对象； 2.定义Ogre将要用到的资源； 3.选择并设置渲染引擎（指的是DirectX，OpenGL等等）； 4.创建渲染窗口； 5.初始化资源； 6.创建场景； 7.设置第三方库和插件； 8.创建帧监听； 9.开始渲染循环。 第一步：创建Root对象 Root对象是O...
Ogre-三维窗口上添加导航小窗口
热门推荐
春夜喜雨的专栏
03-30 1万+
要实现在Ogre-三维窗口上添加导航小窗口 有几种方法， 一种是使用Ogre多视口实现， 一种是使用Windows的透明窗口实现 一种是使用Ogre的Overlay实现 一种是使用Ogre的Rectangle2D实现
让Ogre使用外部渲染窗口
shaoxiaoning的专栏
09-14 2331
就是让Ogre不自己创建渲染窗口，而由第三方来创建。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值