ogre研究之第一个程序（一）

最新推荐文章于 2011-09-12 01:47:59 发布

yarin

最新推荐文章于 2011-09-12 01:47:59 发布

阅读量1.1k

点赞数

分类专栏：图形图像文章标签： string vector keyboard destructor apple cam

本文链接：https://blog.csdn.net/dev_yarin/article/details/6768361

版权

图形图像专栏收录该内容

6 篇文章 0 订阅

订阅专栏

第一次发送超过字数了，被迫剪成两篇！

上一篇我们介绍了如何搭建开发环境，并创建了一个空白的窗口程序。
这里我们主要是实现在程序中装载一个简单的模型并显示出来。
首先看一下效果吧，（模型就是ogre例子中的robot.mesh）,如下：

例子很简单，代码页不多，就4行。我们还是一步一步来分析吧。
首先我们上一个项目中的OgreDemo1类继承自ExampleApplication类，我们之所以什么都没

有做就能创建一个窗口，就是因为ExampleApplication为我们实现了。
首先我们打开ExampleApplication类，可以看到包含了如下几个成员变量（加入了少许注释）

//ogre的程序"根"任何ogre程序都会有改对象     
Root *mRoot;     
//摄像机镜头     
Camera* mCamera;     
//场景管理器     
SceneManager* mSceneMgr;     
//对于每一帧进行处理的类     
ExampleFrameListener* mFrameListener;     
//渲染窗口     
RenderWindow* mWindow;     
//资源文件的路径字符串     
Ogre::String mResourcePath;

这里的ExampleFrameListener类，如果你暂时还不清楚是做什么的，不要紧，后面我们慢慢介绍。
知道了这些成员变量，我们在返回OgreDemo1.c文件中看看入口函数WinMain中是如何书写的呢？很简单就一句话：

app.go();

先将源代码贴出来，加了详细注意：
ExampleApplication.h

#ifndef __ExampleApplication_H__     
#define __ExampleApplication_H__     
    
#include "Ogre.h"     
#include "OgreConfigFile.h"     
#include "ExampleFrameListener.h"     
    
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE     
#include <CoreFoundation/CoreFoundation.h>     
    
std::string macBundlePath()     
{     
    char path[1024];     
    CFBundleRef mainBundle = CFBundleGetMainBundle();     
    assert(mainBundle);     
    
    CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);     
    assert(mainBundleURL);     
    
    CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);     
    assert(cfStringRef);     
    
    CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);     
    
    CFRelease(mainBundleURL);     
    CFRelease(cfStringRef);     
    
    return std::string(path);     
}     
#endif     
    
using namespace Ogre;     
    
/** Base class which manages the standard startup of an Ogre application.    
    Designed to be subclassed for specific examples if required.    
*/    
class ExampleApplication     
{     
public:     
    ExampleApplication()     
    {     
        mFrameListener = 0;     
        mRoot = 0;     
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE     
        mResourcePath = macBundlePath() + "/Contents/Resources/";     
#else     
        mResourcePath = "";     
#endif     
    }     
    /// Standard destructor     
    virtual ~ExampleApplication()     
    {     
        if (mFrameListener)     
            delete mFrameListener;     
        if (mRoot)     
            OGRE_DELETE mRoot;     
    }     
    
    /// 程序的入口     
    virtual void go(void)     
    {     
        //进行初始化工作     
        if (!setup())     
            return;     
        //开始渲染     
        mRoot->startRendering();     
        // 清理屏幕     
        destroyScene();     
    }     
    
protected:     
    //ogre的程序"根"任何ogre程序都会有改对象     
    Root *mRoot;     
    //摄像机镜头     
    Camera* mCamera;     
    //场景管理器     
    SceneManager* mSceneMgr;     
    //对于每一帧进行处理的类     
    ExampleFrameListener* mFrameListener;     
    //渲染窗口     
    RenderWindow* mWindow;     
    //资源文件的路径字符串     
    Ogre::String mResourcePath;     
    //初始化应用程序     
    virtual bool setup(void)     
    {     
        String pluginsPath;     
#ifndef OGRE_STATIC_LIB     
        pluginsPath = mResourcePath + "plugins.cfg";     
#endif     
        //构建Root对象     
        mRoot = OGRE_NEW Root(pluginsPath,      
            mResourcePath + "ogre.cfg", mResourcePath + "Ogre.log");     
        //配置资源文件相关     
        setupResources();     
        //配置，主要用于初始化渲染窗口     
        bool carryOn = configure();     
        if (!carryOn) return false;     
        //创建场景管理器     
        chooseSceneManager();     
        //创建摄像机     
        createCamera();     
        //创建视口     
        createViewports();     
             
        TextureManager::getSingleton().setDefaultNumMipmaps(5);     
        //创建资源监听     
        createResourceListener();     
        //床在资源     
        loadResources();     
        //创建屏幕，必须重写，也就是我们OgreDemo1类中（我们现实模型需要实现的）     
        createScene();     
        //创建帧监听     
        createFrameListener();     
        return true;     
    }     
    /** 是否配置完成，完成则初始化系统 */    
    virtual bool configure(void)     
    {     
        //判断是否进入（即运行过了配置窗口，进入demo窗口）     
        if(mRoot->showConfigDialog())     
        {     
            //初始化系统,得到一个渲染窗口对象     
            mWindow = mRoot->initialise(true);     
            return true;     
        }     
        else    
        {     
            return false;     
        }     
    }     
    
    virtual void chooseSceneManager(void)     
    {     
        // 创建一个场景管理器(场景类型,窗口标题)     
        mSceneMgr = mRoot->createSceneManager(ST_GENERIC, "ExampleSMInstance");     
    }     
    virtual void createCamera(void)     
    {     
        // 创建一个摄像机     
        mCamera = mSceneMgr->createCamera("PlayerCam");     
    
        // 设置摄像机的位置     
        mCamera->setPosition(Vector3(0,0,500));     
        // 设置观察点     
        mCamera->lookAt(Vector3(0,0,-300));     
        // 设置最近裁剪距离，如果超出则不显示     
        mCamera->setNearClipDistance(5);     
        //同样还有设置最远裁剪距离     
        //mCamera->setFarClipDistance(1000);     
    }     
    //创建帧监听     
    virtual void createFrameListener(void)     
    {     
        //实例化帧监听，(渲染窗口，摄像机)     
        mFrameListener= new ExampleFrameListener(mWindow, mCamera);     
        //设置是否显示调试信息(比如：fps...)     
        mFrameListener->showDebugOverlay(true);     
        //添加帧监听到root中     
        mRoot->addFrameListener(mFrameListener);     
    }     
    //创建屏幕     
    virtual void createScene(void) = 0;      
    //清屏     
    virtual void destroyScene(void){}     
    /* 创建视口并初始化 */    
    virtual void createViewports(void)     
    {     
        // 创建一个“视口”     
        Viewport* vp = mWindow->addViewport(mCamera);     
        //设置背景颜色     
        vp->setBackgroundColour(ColourValue(0,0,0));     
    
        //设置屏幕的长宽比（视口的宽度和高度比，目前的宽屏电脑）     
        mCamera->setAspectRatio(Real(vp->getActualWidth()) / Real(vp->getActualHeight()));     
    }     
    
    /// 初始化资源，比如：模型、贴图等资源     
    virtual void setupResources(void)     
    {     
        ConfigFile cf;     
        //读取配置文件     
        cf.load(mResourcePath + "resources.cfg");     
        ConfigFile::SectionIterator seci = cf.getSectionIterator();     
        String secName, typeName, archName;     
        while (seci.hasMoreElements())     
        {     
            secName = seci.peekNextKey();     
            ConfigFile::SettingsMultiMap *settings = seci.getNext();     
            ConfigFile::SettingsMultiMap::iterator i;     
            for (i = settings->begin(); i != settings->end(); ++i)     
            {     
                //取得并添加资源文件     
                typeName = i->first;     
                archName = i->second;     
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE     
                ResourceGroupManager::getSingleton().addResourceLocation(     
                    String(macBundlePath() + "/" + archName), typeName, secName);     
#else     
                ResourceGroupManager::getSingleton().addResourceLocation(     
                    archName, typeName, secName);     
#endif     
            }     
        }     
    }     
    
    //创建资源监听，比如（正在装载资源，请稍等界面）     
    virtual void createResourceListener(void)     
    {     
    }     
    
    //装载资源     
    virtual void loadResources(void)     
    {     
        ResourceGroupManager::getSingleton().initialiseAllResourceGroups();     
    }     
};     
    
    
#endif

ExampleFrameListener.h

#ifndef __ExampleFrameListener_H__     
#define __ExampleFrameListener_H__     
    
#include "Ogre.h"     
#include "OgreStringConverter.h"     
#include "OgreException.h"     
#define OIS_DYNAMIC_LIB     
#include <OIS/OIS.h>     
    
using namespace Ogre;     
    
class ExampleFrameListener: public FrameListener, public WindowEventListener     
{     
protected:     
    virtual void updateStats(void)     
    {     
        static String currFps = "Current FPS: ";     
        static String avgFps = "Average FPS: ";     
        static String bestFps = "Best FPS: ";     
        static String worstFps = "Worst FPS: ";     
        static String tris = "Triangle Count: ";     
        static String batches = "Batch Count: ";     
    
        // 需要更新debug信息时更新     
        try {     
            OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");     
            OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");     
            OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");     
            OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");     
    
            const RenderTarget::FrameStats& stats = mWindow->getStatistics();     
            guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));     
            guiCurr->setCaption(currFps + StringConverter::toString(stats.lastFPS));     
            guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)     
                +" "+StringConverter::toString(stats.bestFrameTime)+" ms");     
            guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)     
                +" "+StringConverter::toString(stats.worstFrameTime)+" ms");     
    
            OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");     
            guiTris->setCaption(tris + StringConverter::toString(stats.triangleCount));     
    
            OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");     
            guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));     
    
            OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");     
            guiDbg->setCaption(mDebugText);     
        }     
        catch(...) { /* ignore */ }     
    }     
    
public:     
    // 构造函数,初始化成员变量     
    ExampleFrameListener(RenderWindow* win, Camera* cam, bool bufferedKeys = false, bool bufferedMouse = false,     
                 bool bufferedJoy = false ) :     
        mCamera(cam), mTranslateVector(Vector3::ZERO), mCurrentSpeed(0), mWindow(win), mStatsOn(true), mNumScreenShots(0),     
        mMoveScale(0.0f), mRotScale(0.0f), mTimeUntilNextToggle(0), mFiltering(TFO_BILINEAR),     
        mAniso(1), mSceneDetailIndex(0), mMoveSpeed(100), mRotateSpeed(36), mDebugOverlay(0),     
        mInputManager(0), mMouse(0), mKeyboard(0), mJoy(0)     
    {     
        //得到debug视图     
        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");     
        //日志管理器     
        LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");     
        OIS::ParamList pl;     
        size_t windowHnd = 0;     
        std::ostringstream windowHndStr;     
        //取得自定义的属性     
        win->getCustomAttribute("WINDOW", &windowHnd);     
        windowHndStr << windowHnd;     
        pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));     
        //创建输入管理器     
        mInputManager = OIS::InputManager::createInputSystem( pl );     
    
        //创建输入设备、鼠标、键盘、摇杆     
        mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, bufferedKeys ));     
        mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, bufferedMouse ));     
        try {     
            mJoy = static_cast<OIS::JoyStick*>(mInputManager->createInputObject( OIS::OISJoyStick, bufferedJoy ));     
        }     
        catch(...) {     
            mJoy = 0;     
        }     
    
        //根据窗口的大小来设置鼠标的初始裁剪区域     
        windowResized(mWindow);     
        //显示debug信息     
        showDebugOverlay(true);     
    
        //注册一个windows窗口事件监听     
        WindowEventUtilities::addWindowEventListener(mWindow, this);     
    }     
    
    //调整鼠标裁剪区域     
    virtual void windowResized(RenderWindow* rw)     
    {     
        unsigned int width, height, depth;     
        int left, top;     
        //取得窗口矩阵     
        rw->getMetrics(width, height, depth, left, top);     
        //得到鼠标     
        const OIS::MouseState &ms = mMouse->getMouseState();     
        ms.width = width;     
        ms.height = height;     
    }     
    
    //关闭窗口之前进行的处理     
    virtual void windowClosed(RenderWindow* rw)     
    {     
        //检测是否关闭了我们的渲染窗口     
        if( rw == mWindow )     
        {     
            if( mInputManager )     
            {     
                //清除输入设备     
                mInputManager->destroyInputObject( mMouse );     
                mInputManager->destroyInputObject( mKeyboard );     
                mInputManager->destroyInputObject( mJoy );     
                //销毁输入管理器     
                OIS::InputManager::destroyInputSystem(mInputManager);     
                mInputManager = 0;     
            }     
        }     
    }     
    
    virtual ~ExampleFrameListener()     
    {     
        //移除所有的窗口事件监听     
        WindowEventUtilities::removeWindowEventListener(mWindow, this);     
        //关闭窗口     
        windowClosed(mWindow);     
    }     
    //按键事件处理     
    virtual bool processUnbufferedKeyInput(const FrameEvent& evt)     
    {     
    
        if(mKeyboard->isKeyDown(OIS::KC_A))     
            mTranslateVector.x = -mMoveScale;   // 向左移动摄像头矩阵     
    
        if(mKeyboard->isKeyDown(OIS::KC_D))     
            mTranslateVector.x = mMoveScale;    // Move camera RIGHT     
    
        if(mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W) )     
            mTranslateVector.z = -mMoveScale;   // Move camera forward     
    
        if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S) )     
            mTranslateVector.z = mMoveScale;    // Move camera backward     
    
        if(mKeyboard->isKeyDown(OIS::KC_PGUP))     
            mTranslateVector.y = mMoveScale;    // Move camera up     
    
        if(mKeyboard->isKeyDown(OIS::KC_PGDOWN))     
            mTranslateVector.y = -mMoveScale;   // Move camera down     
    
        if(mKeyboard->isKeyDown(OIS::KC_RIGHT))     
            mCamera->yaw(-mRotScale);     
    
        if(mKeyboard->isKeyDown(OIS::KC_LEFT))     
            mCamera->yaw(mRotScale);     
    
        if( mKeyboard->isKeyDown(OIS::KC_ESCAPE) || mKeyboard->isKeyDown(OIS::KC_Q) )     
            return false;     
    
        if( mKeyboard->isKeyDown(OIS::KC_F) && mTimeUntilNextToggle <= 0 )     
        {     
            mStatsOn = !mStatsOn;     
            showDebugOverlay(mStatsOn);     
            mTimeUntilNextToggle = 1;     
        }     
    
        if( mKeyboard->isKeyDown(OIS::KC_T) && mTimeUntilNextToggle <= 0 )     
        {     
            switch(mFiltering)     
            {     
            case TFO_BILINEAR:     
                mFiltering = TFO_TRILINEAR;     
                mAniso = 1;     
                break;     
            case TFO_TRILINEAR:     
                mFiltering = TFO_ANISOTROPIC;     
                mAniso = 8;     
                break;     
            case TFO_ANISOTROPIC:     
                mFiltering = TFO_BILINEAR;     
                mAniso = 1;     
                break;     
            default: break;     
            }     
            MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);     
            MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);     
    
            showDebugOverlay(mStatsOn);     
            mTimeUntilNextToggle = 1;     
        }     
    
        if(mKeyboard->isKeyDown(OIS::KC_SYSRQ) && mTimeUntilNextToggle <= 0)     
        {     
            std::ostringstream ss;     
            ss << "screenshot_" << ++mNumScreenShots << ".png";     
            mWindow->writeContentsToFile(ss.str());     
            mTimeUntilNextToggle = 0.5;     
            mDebugText = "Saved: " + ss.str();     
        }     
    
        if(mKeyboard->isKeyDown(OIS::KC_R) && mTimeUntilNextToggle <=0)     
        {     
            mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;     
            switch(mSceneDetailIndex) {     
                case 0 : mCamera->setPolygonMode(PM_SOLID); break;//设置多边形的模式     
                case 1 : mCamera->setPolygonMode(PM_WIREFRAME); break;     
                case 2 : mCamera->setPolygonMode(PM_POINTS); break;     
            }     
            mTimeUntilNextToggle = 0.5;     
        }     
    
        static bool displayCameraDetails = false;     
        if(mKeyboard->isKeyDown(OIS::KC_P) && mTimeUntilNextToggle <= 0)     
        {     
            displayCameraDetails = !displayCameraDetails;     
            mTimeUntilNextToggle = 0.5;     
            if (!displayCameraDetails)     
                mDebugText = "";     
        }     
    
        if(displayCameraDetails)     
            mDebugText = "P: " + StringConverter::toString(mCamera->getDerivedPosition()) +     
                         " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation());     
        return true;     
    }     
    //鼠标事件处理     
    virtual bool processUnbufferedMouseInput(const FrameEvent& evt)     
    {     
    
        // Rotation factors, may not be used if the second mouse button is pressed     
        // 2nd mouse button - slide, otherwise rotate     
        const OIS::MouseState &ms = mMouse->getMouseState();     
        if( ms.buttonDown( OIS::MB_Right ) )     
        {     
            mTranslateVector.x += ms.X.rel * 0.13;     
            mTranslateVector.y -= ms.Y.rel * 0.13;     
        }     
        else    
        {     
            mRotX = Degree(-ms.X.rel * 0.13);     
            mRotY = Degree(-ms.Y.rel * 0.13);     
        }     
    
        return true;     
    }     
    
    //移动摄像头     
    virtual void moveCamera()     
    {     
        //偏移     
        mCamera->yaw(mRotX);     
        //倾斜     
        mCamera->pitch(mRotY);     
        //移动摄像机到指定位置     
        mCamera->moveRelative(mTranslateVector);     
    }     
    //显示debug信息     
    virtual void showDebugOverlay(bool show)     
    {     
        if (mDebugOverlay)     
        {     
            if (show)     
                mDebugOverlay->show();     
            else    
                mDebugOverlay->hide();     
        }     
    }     
    
    // 渲染队列     
    bool frameRenderingQueued(const FrameEvent& evt)     
    {     
    
        if(mWindow->isClosed())  return false;     
    
        mSpeedLimit = mMoveScale * evt.timeSinceLastFrame;     
    
        //捕获、更新设备     
        mKeyboard->capture();     
        mMouse->capture();     
        if( mJoy ) mJoy->capture();     
    
        bool buffJ = (mJoy) ? mJoy->buffered() : true;     
    
        Ogre::Vector3 lastMotion = mTranslateVector;     
        if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )     
        {     
            // one of the input modes is immediate, so setup what is needed for immediate movement     
            if (mTimeUntilNextToggle >= 0)     
                mTimeUntilNextToggle -= evt.timeSinceLastFrame;     
    
            // Move about 100 units per second     
            mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;     
            // Take about 10 seconds for full rotation     
            mRotScale = mRotateSpeed * evt.timeSinceLastFrame;     
    
            mRotX = 0;     
            mRotY = 0;     
            mTranslateVector = Ogre::Vector3::ZERO;     
    
        }     
    
        //Check to see which device is not buffered, and handle it     
        if( !mKeyboard->buffered() )     
            if( processUnbufferedKeyInput(evt) == false )     
                return false;     
        if( !mMouse->buffered() )     
            if( processUnbufferedMouseInput(evt) == false )     
                return false;     
    
        // ramp up / ramp down speed     
        if (mTranslateVector == Ogre::Vector3::ZERO)     
        {     
            // decay (one third speed)     
            mCurrentSpeed -= evt.timeSinceLastFrame * 0.3;     
            mTranslateVector = lastMotion;     
        }     
        else    
        {     
            // ramp up     
            mCurrentSpeed += evt.timeSinceLastFrame;     
    
        }     
        // Limit motion speed     
        if (mCurrentSpeed > 1.0)     
            mCurrentSpeed = 1.0;     
        if (mCurrentSpeed < 0.0)     
            mCurrentSpeed = 0.0;     
    
        mTranslateVector *= mCurrentSpeed;     
    
    
        if( !mMouse->buffered() || !mKeyboard->buffered() || !buffJ )     
            moveCamera();     
    
        return true;     
    }     
    
    //帧结束,更新状态     
    bool frameEnded(const FrameEvent& evt)     
    {     
        updateStats();     
        return true;     
    }     
    
protected:     
    //指向摄像机的指针     
    Camera* mCamera;     
    //一个3维向量，用于摄像机的位置变换     
    Vector3 mTranslateVector;     
    Real mCurrentSpeed;     
    //指向渲染窗口的指针     
    RenderWindow* mWindow;     
    //是否显示调试信息     
    bool mStatsOn;     
    //debug信息     
    std::string mDebugText;     
    //主要用于截图     
    unsigned int mNumScreenShots;     
    //该demo中，摄像机会旋转     
    float mMoveScale;     
    //速度限制     
    float mSpeedLimit;     
    //同样用于摄像机变换     
    Degree mRotScale;     
    //延时     
    Real mTimeUntilNextToggle ;     
    //鼠标旋转的角度，用于摄像机的更新     
    Radian mRotX, mRotY;     
    //纹理差值的类型，枚举类型     
    TextureFilterOptions mFiltering;     
    int mAniso;     
    int mSceneDetailIndex ;     
    //移动速度     
    Real mMoveSpeed;     
    //旋转速度     
    Degree mRotateSpeed;     
    //debug视图     
    Overlay* mDebugOverlay;     
    
    //一些输入设备（输入设备管理器）     
    OIS::InputManager* mInputManager;     
    //鼠标     
    OIS::Mouse*    mMouse;     
    //键盘     
    OIS::Keyboard* mKeyboard;     
    //摇杆     
    OIS::JoyStick* mJoy;     
};     
    
#endif

接续（二）