ogre的初始化与启动以及显示对象设置

最新推荐文章于 2019-05-22 17:11:00 发布

linuxheik

最新推荐文章于 2019-05-22 17:11:00 发布

阅读量523

点赞数

分类专栏： ogre

ogre 专栏收录该内容

41 篇文章

订阅专栏

ogre的使用方法1---自动设置

1、ogre初始化：
首先实例化一个Root对象

 Root * root = new Root();
 Root * root = new Root("plugins.cfg"); 
 Root * root = new Root("plugins.cfg", "ogre.cfg");
 Root * root = new Root("plugins.cfg", "ogre.cfg", "ogre.log");//系统默认这样，当你没有填写参数的时候，系统就认为采用了默认的这些值
 Root * root = new Root("", "");

2、plugins.cfg文件
Ogre中所谓的插件就是符合Ogre插件接口的代码模块（在 Windows下面是DLL文件，在Linux下是.so文件），比如场景管理（SceneManager）插件和渲染系统（RenderSystem）插件等。在启动的Ogre时候，他会载入plugins.cfg配置文件来查看有哪些插件可以被使用。
配置文件的内容如下：

 
          # Defines plugins to load 
         
          # Define plugin folder 
         
          　PluginFolder=. 
         
          # Define plugins 
         
          Plugin=RenderSystem_Direct3D9 
         
          Plugin=RenderSystem_GL 
         
          Plugin=Plugin_ParticleFX 
         
          Plugin=Plugin_BSPSceneManager 
         
          Plugin=Plugin_OctreeSceneManager 
         
          Plugin=Plugin_CgProgramManager

警告：可能你也注意到了在“=”的两边并没有写入空位符号（比如空格或者Tab），因为在这里如果填入空位的话就会被系统认为是语法错误，导致无法载入插件。
3、Ogre.cfg文件

 
          // 如何配置ogre 
         
          Root * root =  
          new  
          Root(); 
         
          bool rtn = root->showConfigDialog(); 
          //确认是否已经按下OK按钮 
         
          // Ogre也提供了直接载入Ogre.cfg文件来配置程序的方法： 
         
          if 
          (!root->restoreConfig()) 
         
          root->showConfigDialog(); 
         
          //通过使用Root对象的通过使用saveConfig()方法，你也可以在任何时候保存当前状态到Ogre.cfg文件（或者是其他在你构建Root实例时候提供给系统的文件）。 
         
          root->saveConfig();

4、Ogre.log文件
Ogre提供了日志管理对象作为记录系统诊断和异常信息的日志工具。
使用手动方法来建立一个日志管理器实例

  //首先通过LogManager::getSingleton()建立一个日志管理器实例。
  LogManager * logMgr = new LogManager;//
  Log * log = LogManager::getSingletonn().createLog(“mylog.log”, true, true, false);//
 //在我们已经建立了日志管理器之后，我们就不需要设置第三个参数了。
  Root * root = new Root(“”,””);//

　　在createLog方法中，第一个参数指定了Ogre的日志输出到“mylog.log”文件；
　　第二个参数告诉了Ogre是否把当前日志作为系统默认的日志来处理；
　　第三个参数表明是否把记录到日志中的信息是否同样的输出到std::cerr（标准错误流）中去；
　　第四个参数用来告诉系统是否真的要把信息输出到文件中（也就是说当为true的时候，并没有真的向日志文件输出信息）。
5、渲染窗口
　　root->initialise(true, ”My Render Window”);
　　RenderWindow * window =root->getAutoCreatedWindow ();///用来得到自动创建的渲染窗口实例的指针。
　　initialise方法的第一个参数告知Ogre系统是否自动建立一个渲染窗口来给用户使用。
　　　　　　　　第二个参数并且把“My Render Window”作为程序窗口的标题。
　　//sceneMgr是一个指向已存在SceneManager（场景管理器）实例的指针

 Camera * cam = sceneMgr ->createCamera(“MainCamera”);//创建一个摄像机
 cam->setNearClipDistance(5);     //摄像机的近截面
 cam->setFarClipDistance(1000)    ;    //摄像机的远截面，必须要保证近截面和远截面之间距离等于或者小于1000就可以
 cam->setAspectRatio(Real(1.333333));//setAspectRatio方法把屏幕的纵宽比设置成为4:3

　　在渲染窗口中创建一个视口“Viewport”

 Viewport * vp = window->addViewport(camera);//通过指向它的window指针创建了一个视口对象的实例
 vp->setBackgroundColour(ColourValue(0, 0, 0));//设置了视口（viewport）的背景颜色。

6、渲染循环
　　调用Root对象的srartRendering()方法是最简单的手段。
　　root->startRendering();

　　帧监听（Frame listener）

　如果决定使用startRender()来开始你的渲染过程，你就只能通过使用帧监听对象来在渲染循环中插入你自己的代码了。所谓帧监听对象就是一个符合FrameListener接口的类的实例。当Ogre渲染每一帧的开始和结束的时候会回调FrameListener接口的方法。

　　建立并挂载一个帧监听对象到Ogre的Root中：

 
         class  
         MyFrameListener :  
         public  
         FrameListener{ 
        
         public 
         : 
        
         bool frameStarted ( 
         const  
         FrameEvent &evt); 
         // 
        
         bool frameEnded ( 
         const  
         FrameEvent &evt ); 
         // 
        
         }; 
        
         bool MyFrameListener::frameStarted ( 
         const  
         FrameEvent &evt){ 
        
         //在每一帧画面渲染前，调用这里你写好的代码 
        
         return  
         true 
         ; 
        
         } 
        
         bool myFrameListener::frameEnded ( 
         const  
         FrameEvent &evt ){ 
        
         //在每一帧画面渲染后，调用这里你写好的代码 
        
         return  
         true 
         ; 
        
         } 
        
         Root * root =  
         new  
         Root(); 
         // 
        
         MyFrameListener myListener; 
         // 
        
         //在这里你需要在调用startRendering()方法前，注册你的帧监听对象！！！ 
        
         root->addFrameListener(myListener); 
         // 
        
         root->startRendering(); 
         //

ogre的使用方法2---手动设置

1、载入插件 -- 两种方法

　　void loadPlugin(const String& pluginName);//加载

　　void unloadPlugin(const String& pluginName);//卸载

Ogre程序带来了以下的插件：
　　Plugin_OctreeSceneManager：以八叉树空间管理为基础的OctreeSceneManager(八叉树场景管理器——OSM)。同时包含了从其中派生出来的　　　　　　TerrainSceneManager(地形场景管理器)，用来处理从高度图（heightMapped）派生出来的地形场景。
　　Plugin_BSPSceneManager：提供一个对BSP场景的管理系统，用来读取和处理来自雷神之锤III中的地图文件。不过在今天看来这已经是一个古老的地图格式，并且已经没有人再维护和支持它了（提供这个插件的唯一原因是为了某个演示程序的执行）。
　　Plugin_CgProgramManager：这个插件负责载入、分析、编译并且管理Cg语言所写的GPU渲染程序。在今天看来，似乎Cg逐渐被当今技术所抛离（它只能支持3.0版本以前的profiles），因此其价值也越来越小；幸好Ogre在其内部同时支持HLSL和GLSL程序的GPU开发。
　　Plugin_ParticleFX：粒子系统管理插件；提供了很多粒子的效果器（Affector）和发射器（Emitter），用来实现一些基本的粒子特效。
　　RenderSystem_Direct3D9：Windows上面对Direct3D 9的抽象层实现。
　　RenderSystem_GL：针对所有平台上OpenGL的抽象层实现。

2、渲染系统（Render Systems）

　　使用插件管理的loadPlugin()方法来载入所需的API：

 //建立一个没有配置文件的Root实例
 Root *root = new Root(“”, “”);//
 root->loadPlugin(“RenderSystem_Direct3D9”);//
 root->loadPlugin(“RenderSystem_GL”);//

　　RenderSystemList* getAvailableRenderers();//获得系统支持那种渲染系统

　　设置Ogre应用程序使用的渲染系统，一下代码设置如何从可用渲染系统列表中找出OpenGL渲染系统，并将其设置导入系统中去。

 
         //RenderSystemList是std::vector类型 
        
         RenderSystemList *rList = root->getAvailableRenderers(); 
        
         RenderSystemList::iterator it = rList->begin(); 
        
         while 
         (it != rList->end()){ 
        
         //Ogre的字符串类型String是std::string的扩展 
        
         　　　　　RenderSystem *rSys = *(it++); 
        
         if 
         (rSys->getName().find(“OpenGL”)){ 
        
         //把OpenGL渲染系统设置为我们使用的渲染系统 
        
         root->setRenderSystem(rSys); 
         // 
        
         break 
         ; 
        
         　　　} 
        
         } 
        
         //注意，如果系统没有支持OpenGL的话，我们就没有设置任何渲染系统！这将会 
        
         //引起一个Ogre设置期间的异常产生。

3、渲染窗口（Render Windows）

　　手动启动Ogre应用程序

 
         #include “Ogre.h” 
        
         //建立一个没有配置文件的Root实例 
        
         Root *root =  
         new  
         Root(“”, ””);  
        
         //载入渲染系统插件 
        
         root->loadPlugin(“RenderSystem_Direct3D9”); 
        
         root->loadPlugin(“RenderSystem_GL”); 
        
         //在这里我们伪装成用户已经选择了OpenGL渲染器 
        
         String rName(“OpenGL Render Subsystem”); 
        
         RenderSystemList * rList = root->getAvailableRenderers(); 
        
         RenderSystemList::iterator it = rList->begin(); 
        
         RenderSystem *rSys =  
         0 
         ; 
        
         while 
         (ii != rList->end()){ 
        
         rSys = * (it++); 
        
         if 
         (rSys->getName() == rName){     
        
         //设置渲染器，并结束循环 
        
         root->setRenderSystem(rSys); 
        
         break 
         ; 
        
         } 
        
         } 
        
         //如果没有找到一个可用的OpenGL渲染器，就在这里结束程序。 
        
         if 
         (root->getRenderSystem() == NULL){          
        
         delete root; 
        
         return  
         - 
         1 
         ; 
        
         } 
        
         //root初始化的时候，我们可以传入一个false值来告知Root不用给我们创建渲染窗口。 
        
         root->initialise( 
         false 
         );  
        
         //在这里我们仍然使用默认的参数来创建渲染窗口 
        
         RenderWindow *window = rSys->createRenderWindow(  
        
         “Manual Ogre Window”, 　　　    
         //窗口的名字 
        
         800 
         ,                           
         //窗口的宽度（像素） 
        
         600 
         ,                           
         //窗口的高度（像素） 
        
         false 
         ,                         
         //是否全屏显示 
        
         0 
         );                                     
         //其他参数，使用默认值 
        
         //在这之后你就可以向之前所说的一样创摄像机和视口了。

4、摄像机和场景管理（Camera and SceneManager）

　　场景管理器　　

　　SceneManager* sceneMgr = root->createSceneManager(ST_GENERIC, “MySceneManager”);　

　　摄像机（Camera）

 
         //sceneManager是一个已经存在的场景管理器实例的指针。 
        
         //我们在这里构建名称为“MainCam”的摄像机。 
        
         Camera *camera = sceneMgr->createCamera(“MainCam”); 
         // 
        
         //并不需要计算什么，可以直接从视口中得到这个尺寸 
        
         camera->setAspectRatio( 
         1 
         .333333f); 
         //3:4的纵宽比 
        
         //30度角可以让我们看到一个长而远的视野 
        
         camera->setFOVy( 
         30 
         .0f); 
         //视线方向和视截体的下平面（以及上平面）拥有30度夹角 
        
         camera->setNearClipDistance( 
         5 
         .0f); 
         //近截面距离摄像机5单位 
        
         camera->setFarClipDistance( 
         1000 
         .0f); 
         //远截面距离1000单位

　　渲染模式

　　摄像机支持3种不同的渲染模式：边框，实体，“点”（只渲染顶点）。

 camera->setPolygonMode(PM_WIREFRAME);//边框
 camera->setPolygonMode(PM_POINTS);//点
 camera->setPolygonMode(PM_SOLOD);//实体，系统默认的参数是PM_SOLOD。
 PolygonMode mode = camera->getPolygonMode();//

　　位置和变换（Position and Translation）

　　摄像机是一个MovableObject（活动对象）接口的实现，因此也具有这对象的所有方法和特性。

　　绝对坐标：

 //确认我们已经有一个指向“Camera”类型实例的指针camera。
 camera->setPosition(200, 10, 200);//
 //也可以用一个三维向量来设置摄像机坐标，在我们得到场景坐标时候这么做会方便一些
 //camera->setPosition(Vector3(200, 10, 200));//把摄像机设置到世界坐标系的绝对点（200,10,200）

　　相对坐标：

 //假设摄像机还在我们之前设置的200, 10, 200空间位置上。
 camera->move(10, 0, 0); //摄像机移动到210, 10, 200
 camera->moveRelative(0, 0, 10); //摄像机移动到210, 10, 210

　　指向，方向，和“着眼点”（Direction，Orientation，and“Look-At”）

 
         void  
         setDirection(Real x, Real y, Real z); 
        
         void  
         setDirection( 
         const  
         Vector3& vec); 
        
         Vector3 getDirection( 
         void 
         )  
         const 
         ; 
        
         Vector3 getUp( 
         void 
         )  
         const 
         ; 
        
         Vector3 getRight( 
         void 
         )  
         const 
         ; 
        
         void  
         lookAt(  
         const  
         Vector3& angle); 
        
         void  
         lookAt(Real x, Real y, Real z); 
        
         void  
         roll( 
         const  
         Radian& angle); 
        
         void  
         roll (Real degrees){roll (Angle ( degrees ) );} 
        
         void  
         yaw( 
         const  
         Radian& angle); 
        
         void  
         yaw(Real degrees){yaw (Angle ( degrees ) );} 
        
         void  
         pitch( 
         const  
         Radian& angle); 
        
         void  
         pitch(Real degrees){yaw (Angle ( degrees ) );} 
        
         void  
         rotate( 
         const  
         Vector3& axis,  
         const  
         Radian& angle); 
        
         void  
         rotate( 
         const  
         Vector3& axis, Real degrees){ 
        
         rotate(axis, Angle(degrees));} 
        
         void   
         setFixedYawAxis (bool useFixed,  
         const  
         Vector3 &fixedAxis=Vector3::UNIT_Y)  
        
         const  
         Quaternion & getOrientation ( 
         void 
         )  
         const 
        
         void  
         setOrientation( 
         const  
         Quaternion& q); 
        
         void  
         setAutoTracking(bool enabled,SceneNode *target= 
         0 
         , 
         const  
         Vector3 &offset=Vector3::ZERO);

　　可以通过调用roll()，yaw()，以及pitch()来控制摄像机相对于自身的方向进行环绕Z轴（Roll：滚动）、Y轴（Yaw：偏移）或者X轴（Pitch：倾斜）的旋转；

　　setDirection()方法通过一个三维向量来在本地空间（Local space）设置方向；

　　rotate()方法被用来操作摄像机绕着给定的轴向旋转；

　　lookAt()作用是直接让摄像机方向对准世界空间内的目标点或者对象；

　 setFixedYawAxis()可以锁定某一个轴向的自由度。

　　setAutoTracking() 使摄像机总是盯着场景中的某一个节点。

　　从世界空间转换到屏幕空间（World Space to Screen Space）

　　//x和y都是单位坐标系（范围从0.0到1.0）屏幕上的坐标

　　Ray getCameraToViewportRay(Real x, Real y) const;

　　视口（Viewport） -- 可实现画中画功能

　　1 视口也拥有自己的z-order（z次序）用来决定哪个是视口在哪个视口前面。一个z-order对应一个视口。

　　2 视口拥有自己的背景颜色属性。

　　默认情况下，Ogre系统在每一帧更新深度缓存和颜色缓存；你可以通过视口的方法对其进行管理。

5、主渲染循环（Main Rendering Loop）

　　Ogre基础的应用程序典型的运行过程是：不间断的循环渲染每帧画面，直到你停止程序。

　　手动渲染可以使用renderOneFrame()方法。

手动渲染循环的框架例子：

 
        bool keepRendering =  
        true 
        ; 
       
        //在这里填入所有这个章节之前提到的设置过程： 
       
        //载入插件，创建渲染窗口和场景管理器以及摄像机和视口， 
       
        //然后再场景中填入你希望的内容。  
       
        while 
        (keepRendering) 
       
        { 
       
        //在这里处理引擎使用的网络消息。 
       
        //在这里处理引擎使用的输入消息。 
       
        //根据消息更新场景管理状态。 
       
        //根据新的场景管理状态，渲染下一帧。 
       
        root->renderOneFrame(); 
       
        //检查是否需要退出渲染循环 
       
        //注意：NextMessageInQueue()这个函数只是为了便于解释程序含义 
       
        //而虚构出来的函数——Ogre引擎中并没有实现它。 
       
        If(NextMessageInQueue() == QUIT) 
       
        { 
       
        keepRendering =  
        false 
        ; 
       
        } 
       
        } 
       
        //在这里进行你需要的清理工作 
       
        //然后，关闭Ogre 
       
        delete root;