Ogre Two Viewport

main.cpp

#include "Ogre\ExampleApplication.h"
class Example : public ExampleApplication
{
public:
      void createScene()
      {
          Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
          Ogre::Entity* ent = mSceneMgr->createEntity("Sinbad.mesh");
          node->attachObject(ent);
      }
      void createCamera()
      {
        mCamera = mSceneMgr->createCamera("MyCamera1");
        mCamera->setPosition(0,10,20);
        mCamera->lookAt(0,0,0);
        mCamera->setNearClipDistance(5);
        mCamera2 = mSceneMgr->createCamera("MyCamera2");
        mCamera2->setPosition(20,10,0);
        mCamera2->lookAt(0,0,0);
        mCamera2->setNearClipDistance(5);
      }
      void createViewports()
    {
        Ogre::Viewport* vp1 = mWindow->addViewport(mCamera,0,0.0,0.0,0.5,1.0);
        vp1->setBackgroundColour(ColourValue(0.0f,0.0f,0.1f));
        Ogre::Viewport* vp2 = mWindow->addViewport(mCamera2,1,0.5,0.0,0.5,1.0);
        vp2->setBackgroundColour(ColourValue(0.0f,0.1f,0.0f));
        mCamera->setAspectRatio(Real(vp1->getActualWidth()) / Real(vp1->getActualHeight()));
        mCamera2->setAspectRatio(Real(vp2->getActualWidth()) / Real(vp2->getActualHeight()));
    }
private:
       Ogre::Camera* mCamera1;
       Ogre::Camera* mCamera2;
};
int main (void)
{
    Example app;
    app.go();
    return 0;
}

Ogre Compositor

main.cpp

#include "Ogre\ExampleApplication.h"
class CompositorListener1 : public Ogre::CompositorInstance::Listener
{
    public:
    CompositorListener1()
    {
      number = 125.0f;
    }
    void notifyMaterialRender(uint32 pass_id, MaterialPtr &mat)
    {
      mat->getBestTechnique()->getPass(pass_id)->getFragmentProgramParameters()->setNamedConstant("numpixels",number);
    }
    void setNumber(float num)
    {
        number = num;
    }
    float getNumber()
    {
        return number;
    }
    private:
    float number;
};

class NeoLastener : public Ogre::FrameListener
{
public:
    NeoLastener(Ogre::RenderWindow* win, CompositorListener1* listener)
    {
       _comListener = listener;
       size_t windowHan = 0;
       std::stringstream windowHanStr;
       win->getCustomAttribute("WINDOW",&windowHan);
       windowHanStr << windowHan;
       OIS::ParamList pl;
       pl.insert(std::make_pair(std::string("WINDOW"), windowHanStr.str()));
       _man = OIS::InputManager::createInputSystem(pl);
       _key = static_cast(_man->createInputObject(OIS::OISKeyboard,false));
    }
    bool frameStarted(const Ogre::FrameEvent &ent)
    {
        _key->capture();
        if(_key->isKeyDown(OIS::KC_SPACE))
        {
            return false;
        }
        if(_key->isKeyDown(OIS::KC_EQUALS))
        {
            float num = _comListener->getNumber();
            num++;
            _comListener->setNumber(num);
            std::cout << num << std::endl;
        }
        if(_key->isKeyDown(OIS::KC_MINUS))
        {
            float num = _comListener->getNumber();
            num--;
            _comListener->setNumber(num);
            std::cout << num << std::endl;
        }
        return true;
    }
private:
    OIS::InputManager* _man;
    OIS::Keyboard* _key;
     CompositorListener1* _comListener;
};
class Example : public ExampleApplication
{
public:
      void createScene()
      {
        Ogre::Entity* ent = mSceneMgr->createEntity("E1","Sinbad.mesh");
        mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(ent);
        Ogre::CompositorManager::getSingleton().addCompositor(mCamera->getViewport(),"Compositor1");
        Ogre::CompositorManager::getSingleton().setCompositorEnabled(mCamera->getViewport(),"Compositor1",true);
        Ogre::CompositorInstance* comp = Ogre::CompositorManager::getSingleton().getCompositorChain(mCamera->getViewport())->getCompositor("Compositor1");
        CompositorListener1* compListener = new CompositorListener1();
        comp->addListener(compListener);
       Ogre::FrameListener* FrameListener = new NeoLastener(mWindow,compListener);
       mRoot->addFrameListener(FrameListener);
    }

};
int main (void)
{
    Example app;
    app.go();
    return 0;
}

\media\materials\scripts\neo.compositor

compositor Compositor1
{ 
      technique 
        { 
                texture scene target_width target_height PF_R8G8B8 
                target scene 
                { 
                        input previous 
                } 
     
                target_output 
                { 
                        input none 
                        pass render_quad 
                        { 
                                material neo/Comp1
                                input 0 scene 
                        } 
                } 
        } 
} 

\media\materials\scripts\neo.material

fragment_program MyFragmentShader1 cg
{ 
    source neo.cg         
    entry_point MyFragmentShader1       
    profiles ps_1_1    arbfp1 
 default_params                                         
    {                 
      param_named numpixels float 50  
    } 
}

material neo/Comp1
{ 
    technique 
        { 
                pass 
                { 
    fragment_program_ref MyFragmentShader1       
                     { 
                     } 
       texture_unit 
                        { 
                        } 
                } 
        } 
}

\media\materials\programs\neo.cg

void MyFragmentShader1(float2 uv : TEXCOORD0,out float4 color: COLOR,uniform sampler2D texture,  uniform float numpixels)
{  
float num = numpixels; 
float stepsize = 1.0/ num; 
float2 fragment = float2(stepsize * floor(uv.x * num),stepsize *    floor(uv.y * num)); 
color = tex2D(texture, fragment); 
}

meterial還能加vertex

vertex_program MyVertexShader1 cg 
{
    source neo.cg     
    entry_point MyVertexShader1       
    profiles vs_1_1 arbvp1                                           
    default_params                                         
    {                 
        param_named_auto worldViewMatrix worldviewproj_matrix   
 param_named_auto pulseTime time        
    }  
}
material neo/Comp1
{ 
    technique 
        { 
                pass 
                { 
                     fragment_program_ref MyFragmentShader1 
                     { 
                     } 
                    vertex_program_ref MyVertexShader1
                    { 
                    } 
                    texture_unit 
                        { 
                        } 
                } 
        } 
}

cg部分vertex加

void MyVertexShader1( uniform float pulseTime, float4 position : POSITION, out float4 oPosition : POSITION, float2 uv : TEXCOORD0,out float2 oUv : TEXCOORD0,uniform float4x4 worldViewMatrix) 
{ 
       oPosition = mul(worldViewMatrix, position); 
    oUv = uv;
    oPosition.x *= (2+sin(pulseTime)); 
}

灰階合成器neo.cg

void MyFragmentShader1(float2 uv : TEXCOORD0,out float4 color: COLOR,uniform sampler2D texture)
{  
 float4 temp_color = tex2D(texture,uv);  
 float greyvalue = temp_color.r * 0.3 + temp_color.g * 0.59 + temp_color.b * 0.11; 
 color = float4( greyvalue,  greyvalue,greyvalue,0); 
} 

Ogre OIS Keyboard Code Map

KC_UNASSIGNED    = 0x00   
KC_ESCAPE    = 0x01   
KC_1    = 0x02   
KC_2    = 0x03   
KC_3    = 0x04   
KC_4    = 0x05   
KC_5    = 0x06   
KC_6    = 0x07   
KC_7    = 0x08   
KC_8    = 0x09   
KC_9    = 0x0A   
KC_0    = 0x0B   
KC_MINUS    = 0x0C    // - on main keyboard
KC_EQUALS    = 0x0D   
KC_BACK    = 0x0E    // backspace
KC_TAB    = 0x0F   
KC_Q    = 0x10   
KC_W    = 0x11   
KC_E    = 0x12   
KC_R    = 0x13   
KC_T    = 0x14   
KC_Y    = 0x15   
KC_U    = 0x16   
KC_I    = 0x17   
KC_O    = 0x18   
KC_P    = 0x19   
KC_LBRACKET    = 0x1A   
KC_RBRACKET    = 0x1B   
KC_RETURN    = 0x1C    // Enter on main keyboard
KC_LCONTROL    = 0x1D   
KC_A    = 0x1E   
KC_S    = 0x1F   
KC_D    = 0x20   
KC_F    = 0x21   
KC_G    = 0x22   
KC_H    = 0x23   
KC_J    = 0x24   
KC_K    = 0x25   
KC_L    = 0x26   
KC_SEMICOLON    = 0x27   
KC_APOSTROPHE    = 0x28   
KC_GRAVE    = 0x29    // accent
KC_LSHIFT    = 0x2A   
KC_BACKSLASH    = 0x2B   
KC_Z    = 0x2C   
KC_X    = 0x2D   
KC_C    = 0x2E   
KC_V    = 0x2F   
KC_B    = 0x30   
KC_N    = 0x31   
KC_M    = 0x32   
KC_COMMA    = 0x33   
KC_PERIOD    = 0x34    //. on main keyboard
KC_SLASH    = 0x35    // / on main keyboard
KC_RSHIFT    = 0x36   
KC_MULTIPLY    = 0x37    // * on numeric keypad
KC_LMENU    = 0x38    // left Alt
KC_SPACE    = 0x39   
KC_CAPITAL    = 0x3A   
KC_F1    = 0x3B   
KC_F2    = 0x3C   
KC_F3    = 0x3D   
KC_F4    = 0x3E   
KC_F5    = 0x3F   
KC_F6    = 0x40   
KC_F7    = 0x41   
KC_F8    = 0x42   
KC_F9    = 0x43   
KC_F10    = 0x44   
KC_NUMLOCK    = 0x45   
KC_SCROLL    = 0x46    // Scroll Lock
KC_NUMPAD7    = 0x47   
KC_NUMPAD8    = 0x48   
KC_NUMPAD9    = 0x49   
KC_SUBTRACT    = 0x4A    // - on numeric keypad
KC_NUMPAD4    = 0x4B   
KC_NUMPAD5    = 0x4C   
KC_NUMPAD6    = 0x4D   
KC_ADD    = 0x4E    // + on numeric keypad
KC_NUMPAD1    = 0x4F   
KC_NUMPAD2    = 0x50   
KC_NUMPAD3    = 0x51   
KC_NUMPAD0    = 0x52   
KC_DECIMAL    = 0x53    //. on numeric keypad
KC_OEM_102    = 0x56    //<>|on UK/Germany // keyboards
KC_F11    = 0x57   
KC_F12    = 0x58   
KC_F13    = 0x64    // (NEC PC98)
KC_F14    = 0x65    // (NEC PC98)
KC_F15    = 0x66    // (NEC PC98)
KC_KANA    = 0x70    // (Japanese keyboard)
KC_ABNT_C1    = 0x73    // / ? on Portugese (Brazilian) // keyboards
KC_CONVERT    = 0x79    // (Japanese keyboard)
KC_NOCONVERT    = 0x7B    // (Japanese keyboard)
KC_YEN    = 0x7D    // (Japanese keyboard)
KC_ABNT_C2    = 0x7E    // Numpad. on Portugese // (Brazilian) keyboards
KC_NUMPADEQUALS    = 0x8D    // = on numeric keypad // (NEC PC98)
KC_PREVTRACK    = 0x90   
KC_AT    = 0x91    // (NEC PC98)
KC_COLON    = 0x92    // (NEC PC98)
KC_UNDERLINE    = 0x93    // (NEC PC98)
KC_KANJI    = 0x94    // (Japanese keyboard)
KC_STOP    = 0x95    // (NEC PC98)
KC_AX    = 0x96    // (Japan AX)
KC_UNLABELED    = 0x97    // (J3100)
KC_NEXTTRACK    = 0x99    // Next Track
KC_NUMPADENTER    = 0x9C    // Enter on numeric keypad
KC_RCONTROL    = 0x9D   
KC_MUTE    = 0xA0    // Mute
KC_CALCULATOR    = 0xA1    // Calculator
KC_PLAYPAUSE    = 0xA2    // Play/Pause
KC_MEDIASTOP    = 0xA4    // Media Stop
KC_VOLUMEDOWN    = 0xAE    // Volume ?
KC_VOLUMEUP    = 0xB0    // Volume +
KC_WEBHOME    = 0xB2    // Web home
KC_NUMPADCOMMA    = 0xB3    // on numeric keypad // (NEC PC98)
KC_DIVIDE    = 0xB5    // / on numeric keypad
KC_SYSRQ    = 0xB7   
KC_RMENU    = 0xB8    // right Alt
KC_PAUSE    = 0xC5    // Pause
KC_HOME    = 0xC7    // Home on arrow keypad
KC_UP    = 0xC8    // UpArrow on arrow keypad
KC_PGUP    = 0xC9    // PgUp on arrow keypad
KC_LEFT    = 0xCB    // LeftArrow on arrow keypad
KC_RIGHT    = 0xCD    // RightArrow on arrow // keypad
KC_END    = 0xCF    // End on arrow keypad
KC_DOWN    = 0xD0    // DownArrow on arrow // keypad
KC_PGDOWN    = 0xD1    // PgDn on arrow keypad
KC_INSERT    = 0xD2    // Insert on arrow keypad
KC_DELETE    = 0xD3    // Delete on arrow keypad
KC_LWIN    = 0xDB    // Left Windows key
KC_RWIN    = 0xDC    // Right Windows key
KC_APPS    = 0xDD    // AppMenu key
KC_POWER    = 0xDE    // System Power
KC_SLEEP    = 0xDF    // System Sleep
KC_WAKE    = 0xE3    // System Wake
KC_WEBSEARCH    = 0xE5    // Web Search
KC_WEBFAVORITES    = 0xE6    // Web Favorites
KC_WEBREFRESH    = 0xE7    // Web Refresh
KC_WEBSTOP    = 0xE8    // Web Stop
KC_WEBFORWARD    = 0xE9    // Web Forward
KC_WEBBACK    = 0xEA    // Web Back
KC_MYCOMPUTER    = 0xEB    // My Computer
KC_MAIL    = 0xEC    // Mail
KC_MEDIASELECT    = 0xED    // Media Select

Ogre Sinbad Moving

需要加入model資料夾和resource.cfg和plugins.cfg

#include "Ogre\ExampleApplication.h"
class Example25FrameListener : public Ogre::FrameListener
{
    public:
    Example25FrameListener(Ogre::SceneNode* node,Ogre::Entity* ent,RenderWindow* win,Ogre::Camera* cam)
    {
        _node = node;
        _Cam = cam;
        _ent = ent;
        _WalkingSpeed = 50.0f;
        _rotation = 0.0f;
        _isActionKeyPress = false;
        size_t windowHnd = 0;
        std::stringstream windowHndStr;
        win->getCustomAttribute("WINDOW", &windowHnd);
        windowHndStr << windowHnd;
        OIS::ParamList pl;
        pl.insert(std::make_pair(std::string("WINDOW"),windowHndStr.str()));
        _man = OIS::InputManager::createInputSystem( pl );
        _key = static_cast( _man->createInputObject(OIS::OISKeyboard, false ));
        _mouse = static_cast(_man->createInputObject( OIS::OISMouse, false ));
        translate = Ogre::Vector3(0,0,0);

        _aniState = _ent->getAnimationState("RunBase");
        _aniState->setLoop(false);
        _aniStateTop = _ent->getAnimationState("RunTop");
        _aniStateTop->setLoop(false);
     }

    bool frameStarted(const Ogre::FrameEvent    &evt)
    {
        bool walked = false;
        Ogre::Vector3 SinbadTranslate(0,0,0);
        _key->capture();
        if(_key->isKeyDown(OIS::KC_ESCAPE))
        {
            return false;
        }
        if(_key->isKeyDown(OIS::KC_SPACE))
        {
          _isActionKeyPress = true;
          _aniStateTop = _ent->getAnimationState("SliceHorizontal");
          _aniStateTop->setLoop(false);
          _aniStateTop->setTimePosition(0.0f);
        }
        if(_key->isKeyDown(OIS::KC_W))
        {
        }
        if(_key->isKeyDown(OIS::KC_S))
        {
        }
        if(_key->isKeyDown(OIS::KC_A))
        {
        }
        if(_key->isKeyDown(OIS::KC_D))
        {
        }
        if(_key->isKeyDown(OIS::KC_UP))
        {
            SinbadTranslate += Ogre::Vector3(0,0,-1);
            _rotation = 3.14f;
            walked = true;
        }
        if(_key->isKeyDown(OIS::KC_DOWN))
        {
            SinbadTranslate += Ogre::Vector3(0,0,1);
            _rotation = 0.0f;
            walked = true;
        }
        if(_key->isKeyDown(OIS::KC_LEFT))
        {
            SinbadTranslate += Ogre::Vector3(-1,0,0);
            _rotation = -1.57f;
            walked = true;
        }
        if(_key->isKeyDown(OIS::KC_RIGHT))
        {
            SinbadTranslate += Ogre::Vector3(1,0,0);
            _rotation = 1.57f;
            walked = true;
        }

        if(walked)
        {
            _aniState->setEnabled(true);
            _aniStateTop->setEnabled(true);
            if(_aniState->hasEnded())
            {
                _aniState->setTimePosition(0.0f);
            }
            if(_aniStateTop->hasEnded())
            {
                _aniStateTop->setTimePosition(0.0f);
            }
        }
        else
        {
            if(_isActionKeyPress)
            {
                _aniStateTop->setEnabled(true);
                if(_aniStateTop->hasEnded())
                {
                    _isActionKeyPress = false;
                    _aniStateTop = _ent->getAnimationState("RunTop");
                    _aniStateTop->setLoop(false);
                    _aniStateTop->setTimePosition(0.0f);
                    _aniStateTop->setEnabled(false);
                }
            }
            else
            {
                _aniState->setTimePosition(0.0f);
                _aniState->setEnabled(false);
                _aniStateTop->setTimePosition(0.0f);
                _aniStateTop->setEnabled(false);
            }
        }
        _mouse->capture();
        float rotX = _mouse->getMouseState().X.rel * evt.timeSinceLastFrame* -1;
        float rotY = _mouse->getMouseState().Y.rel * evt.timeSinceLastFrame * -1;
        _node->translate(SinbadTranslate * evt.timeSinceLastFrame * _WalkingSpeed);
        _node->resetOrientation();
        _node->yaw(Ogre::Radian(_rotation));

        _Cam->yaw(Ogre::Radian(rotX));
        _Cam->pitch(Ogre::Radian(rotY));
        _Cam->moveRelative(translate*evt.timeSinceLastFrame * 10);

        _aniState->addTime(evt.timeSinceLastFrame*1);
        _aniStateTop->addTime(evt.timeSinceLastFrame*0.4);
        return true;
    }

    Example25FrameListener()
    {
        FrameListener = NULL;
    }
    ~Example25FrameListener()
    {
        _man->destroyInputObject(_key);
        OIS::InputManager::destroyInputSystem(_man);
        _man->destroyInputObject(_mouse);
        if(FrameListener)
        {
            delete FrameListener;
        }
    }

    private:
    Ogre::FrameListener* FrameListener;
    Ogre::SceneNode* _node;
    OIS::InputManager* _man;
    OIS::Keyboard* _key;
    Ogre::Vector3 translate;
    Ogre::Degree rotate;
    Ogre::Camera* _Cam;
    OIS::Mouse* _mouse;
    Ogre::Entity* _ent;
    Ogre::AnimationState* _aniState;
    Ogre::AnimationState* _aniStateTop;
    float _WalkingSpeed;
    float _rotation;
    bool _isActionKeyPress;
 };

class Example1 : public ExampleApplication
{
    public:
    void createScene()
    {
        Ogre::Plane plane(Vector3::UNIT_Y,  -10);
        Ogre::MeshManager::getSingleton().createPlane("plane",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,plane,1500,1500,20,20,true,1,5,5,Vector3::UNIT_Z );
        Ogre::Entity* ent = mSceneMgr->createEntity("LightPlaneEntity", "plane");
        mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(ent);
        ent->setMaterialName("Examples/BeachStones");
        Ogre::Light* light = mSceneMgr->createLight("Light1");
        light->setType(Ogre::Light::LT_DIRECTIONAL);
        light->setDirection(Ogre::Vector3(1,-1,0));

        Ogre::SceneNode* node = mSceneMgr->createSceneNode("Node1");
        mSceneMgr->getRootSceneNode()->addChild(node);
        _SinbadEnt = mSceneMgr->createEntity("Sinbad", "Sinbad.mesh");
        Ogre::Entity* sword1 = mSceneMgr->createEntity("Sword1","Sword.mesh");
        Ogre::Entity* sword2 = mSceneMgr->createEntity("Sword2","Sword.mesh");
        _SinbadEnt->attachObjectToBone("Handle.L",sword1);
        _SinbadEnt->attachObjectToBone("Handle.R", sword2);
        _SinbadNode = node->createChildSceneNode("SinbadNode");
        _SinbadNode->setScale(3.0f,3.0f,3.0f);
        _SinbadNode->setPosition(Ogre::Vector3(0.0f,4.0f,0.0f));
        _SinbadNode->attachObject(_SinbadEnt);
    }
    void createCamera()
    {
        mCamera = mSceneMgr->createCamera("MyCamera1");
        mCamera->setPosition(0,100,200);
        mCamera->lookAt(0,0,0);
        mCamera->setNearClipDistance(5);
    }
    void createFrameListener()
    {
        Ogre::FrameListener* FrameListener = new Example25FrameListener(_SinbadNode,_SinbadEnt,mWindow,mCamera);
        mRoot->addFrameListener(FrameListener);
    }
    private:
    Ogre::SceneNode* _SinbadNode;
    Ogre::Entity* _SinbadEnt;
};
int main (void)
{
    Example1 app;
    app.go();
    return 0;
}

MinGW需要的檔案

以MinGW4.5為例

binutils-2.20.51-1-mingw32-bin
gcc-c++-4.5.0_20100311-2-mingw32-bin
gcc-core-4.5.0_20100311-2-mingw32-bin
gdb-7.1-2-mingw32-bin.tar 
libgmp-5.0.1-1-mingw32-dll-10
libmpc-0.8.1-1-mingw32-dll-2
libmpfr-2.4.1-1-mingw32-dll-1
libstdc++-4.5.0_20100311-2-mingw32-dll-6
mingw32-make-3.81-2
mingwrt-3.18-mingw32-dev
w32api-3.14-mingw32-dev

NeoOgreBase

NeoOgreBase.h

#ifndef _NEO_OGRE_BASE_H_
#define _NEO_OGRE_BASE_H_
#include <Ogre.h>
class NeoOgreBase
{
public:
     NeoOgreBase() : m_root(NULL), m_render_win(NULL), m_scene_mgr(NULL), m_camera(NULL){}
    ~NeoOgreBase(){if (m_root) delete m_root;}
    void Run(void)
    {
        if (!Initialize())
        {
            exit(-1);
        }
        CreateScene();
        m_root->startRendering();
    }
protected:
    bool Initialize(void)
    {
        m_root = new Ogre::Root("","");
        #ifdef _DEBUG
            m_root->loadPlugin( "RenderSystem_Direct3D9_d" );     // for a debug build
        #else
            m_root->loadPlugin( "RenderSystem_Direct3D9" );     // for a release build
        #endif
//------------------------------------------------------------------------------------
//   Ogre::RenderSystemList *render_sys_list = m_root->getAvailableRenderers();  //for 1.6
//   Ogre::RenderSystemList::iterator it_render_sys(render_sys_list->begin() );//for 1.6
//   while (it_render_sys != render_sys_list->end() )                          //for 1.6
//------------------------------------------------------------------------------------
    const Ogre::RenderSystemList &render_sys_list = m_root->getAvailableRenderers();//for 1.7
    Ogre::RenderSystemList::const_iterator it_render_sys( render_sys_list.begin() );//for 1.7
    while ( it_render_sys != render_sys_list.end() )                                //for 1.7
            {
                Ogre::RenderSystem* render_sys = *(it_render_sys++);
                if(render_sys->getName().find("Direct3D9") != Ogre::String::npos)
                {
                    m_root->setRenderSystem(render_sys);
                    break;
                }
            }
            if (m_root == NULL) 
            {
                delete m_root;
                return false;
            }
            m_root->initialise(false);//false表示不自動產生視窗,手動產生
            m_render_win = m_root->createRenderWindow("Neo Ogre", 320, 240, false); //false表非全螢幕模式
            m_scene_mgr = m_root->createSceneManager(Ogre::ST_GENERIC,"neo scene manager");
            m_camera = m_scene_mgr->createCamera("MainCamera");
            Ogre::Viewport* viewport = m_render_win->addViewport(m_camera);
            viewport->setBackgroundColour(Ogre::ColourValue::Black); //same as ColourValue( 0, 0, 0 )
          
            //設定camera
             m_camera->setAspectRatio( Ogre::Real( viewport->getActualWidth() ) /  Ogre::Real( viewport->getActualHeight() ) );
             m_camera->setNearClipDistance( 10 );
             m_camera->setFarClipDistance( 10000 );
             m_camera->setFOVy( Ogre::Degree( 45 ) );
             m_camera->setPosition( 0, 0, 1000 );

            //增加材質
            Ogre::MaterialPtr mtl;
            mtl = Ogre::MaterialManager::getSingleton().create("NeoMatrial_0", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
            mtl->setLightingEnabled(false);
            mtl = Ogre::MaterialManager::getSingleton().create("CheeseCube", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
            mtl->setLightingEnabled( true );
            mtl->setAmbient(Ogre::ColourValue( 0.87, 0.77, 0.46 ) );
            mtl->setDiffuse(Ogre::ColourValue( 0.87, 0.77, 0.46 ) );

            return true; 
    }
protected:
    virtual void CreateScene(void) = 0;
    Ogre::Root* m_root;
    Ogre::RenderWindow* m_render_win;
    Ogre::SceneManager* m_scene_mgr;
    Ogre::Camera* m_camera;
private:
};
#endif 

main.cpp

#include <Ogre.h>
#include <iostream>
#include "NeoOgreBase.h"
using namespace Ogre;

class myOgre : public NeoOgreBase
{
protected:
    void CreateScene(void)
    {
      Light *light = m_scene_mgr->createLight( "light0" );
      light->setType( Light::LT_DIRECTIONAL );
      light->setDirection( Vector3( 0, -1, -1 ) );
      m_scene_mgr->setAmbientLight( ColourValue( 0.5, 0.5, 0.5 ) );
      
      SceneNode *center_node = m_scene_mgr->getRootSceneNode()->createChildSceneNode();
            //--------------------------------     
            std::ostringstream entity_name;
            entity_name << "cube0";
            Entity *ent = m_scene_mgr->createEntity(entity_name.str(), SceneManager::PT_CUBE );
            ent->setMaterialName( "CheeseCube" );
            SceneNode *scene_node = center_node->createChildSceneNode();
            scene_node->rotate( Vector3::UNIT_Z, Degree( 0 ), SceneNode::TS_LOCAL );
            scene_node->translate( Vector3( 0, 0, 0 ), SceneNode::TS_LOCAL );
            scene_node->attachObject( ent );
            //---------------------------------
            entity_name << "cube1";
            Entity *ent2 = m_scene_mgr->createEntity(entity_name.str(), SceneManager::PT_CUBE );
            ent2->setMaterialName( "NeoMatrial_0" );
            SceneNode *scene_node2 = center_node->createChildSceneNode();
            scene_node2->rotate( Vector3::UNIT_Z, Degree( 0 ), SceneNode::TS_LOCAL );
            scene_node2->translate( Vector3( 300, 0, 0 ), SceneNode::TS_LOCAL );
            scene_node2->attachObject(ent2);
            //---------------------------------
    }
};

int main(int argc, char *argv[])
{
    myOgre a;
    a.Run();
    return true;
}

Orge 1.6 & 1.7 with vs2008

http://www.ogre3d.org/download/sdk下載Orge 1.6 for vc90

環境Path變數加入
;%OGRE_HOME%/bin/debug;%OGRE_HOME%/bin/release

在VS2008中的工具->選項中找到"專案和方案"->"VC++目錄"
在「Include 檔案」中，加入 $(OGRE_HOME)/include
在「程式庫檔」中，加入 $(OGRE_HOME)/lib

Orge 1.7 :
Include 檔案
OgreSDK_vc9_v1-7-4\include
OgreSDK_vc9_v1-7-4\boost_1_48

Lib檔案
OgreSDK_vc9_v1-7-4\lib\Debug      或    OgreSDK_vc9_v1-7-4\lib\Release
OgreSDK_vc9_v1-7-4\boost_1_48/lib



記得要加入
OgreMain.lib OIS.lib 或 OgreMain_d.lib OIS_d.lib

輸出目錄放
OgreMain.dll OIS.dll 或 OgreMain_d.dll OIS_d.dll
RenderSystem_Direct3D9.dll
d3dx9_43.dll
RenderSystem_GL.dll



main.cpp


目前ogre1.7用codeblock只能跑release mode
記得在Toolchain executable 中的Additional paths中加上$(CODEBLOCKS)\build\vs2008\Microsoft Visual Studio 9.0\Common7\IDE

#include <Ogre.h>
using namespace Ogre;

int main(int argc, char *argv[])
{
    // start the Ogre application
    Root *root = new Root( "", "" );

    // load a plugin(DLL) of the render system
#ifdef _DEBUG
    root->loadPlugin( "RenderSystem_Direct3D9_d" );     // for a debug build
   //  root->loadPlugin("RenderSystem_GL_d");
#else
    root->loadPlugin( "RenderSystem_Direct3D9" );       // for a release build
    // root->loadPlugin("RenderSystem_GL");
#endif

    // select the Direct3D renderer
//------------------------------------------------------------------------------------
//   RenderSystemList *render_sys_list = root->getAvailableRenderers(); //for 1.6
//   RenderSystemList::iterator it_rs( render_sys_list->begin() );      //for 1.6
//   while ( it_rs != render_sys_list->end() )                          //for 1.6
//------------------------------------------------------------------------------------
    const RenderSystemList &render_sys_list = root->getAvailableRenderers();//for 1.7
    RenderSystemList::const_iterator it_rs( render_sys_list.begin() );      //for 1.7
    while ( it_rs != render_sys_list.end() )                                //for 1.7
    {
        RenderSystem *render_sys = *(it_rs++);
      //if ( render_sys->getName().find( "OpenGL" ) != String::npos )
         if ( render_sys->getName().find( "Direct3D9" ) != String::npos )
        {
            root->setRenderSystem( render_sys );
            break;
        }
    }

    // end gracelessly if the preferred renderer is not available
    if ( root->getRenderSystem() == NULL )
    {
        delete root;
        return -1;
    }

    // initialize the root, and tell the root NOT to create a render window
    root->initialise( false );

    // manually create a render window
    RenderWindow* render_win = root->createRenderWindow( "Hello, Ogre!",   // window title
                              320,              // window (client area) width
                              240,              // window height
                              false );          // full screen mode
    // create the SceneManager, in this case a generic one
    SceneManager *scene_mgr = root->createSceneManager(ST_GENERIC, "my scene manager");
    // create the Camera
    Camera *camera = scene_mgr->createCamera( "MainCamera" );
    // create the Viewport
    Viewport *viewport = render_win->addViewport( camera );
     viewport->setBackgroundColour( ColourValue::Black ); // same as ColourValue( 0, 0, 0 )
     camera->setAspectRatio( Real( viewport->getActualWidth() ) / Real( viewport->getActualHeight() ) );
     camera->setNearClipDistance( 1 );
     camera->setFarClipDistance( 1000 );
     camera->setFOVy( Degree( 45 ) );
     camera->setPosition( 0, 0, 500 );
     // create a material with nothing and no lighting
     MaterialPtr mtl = MaterialManager::getSingleton().create( "Neo_MaterIal_NoLighting",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
     mtl->setLightingEnabled( false );
     // create the triangular face by using ManualObject
     ManualObject* manual = scene_mgr->createManualObject( "triangular_face" );
     manual->begin( "Neo_MaterIal_NoLighting", RenderOperation::OT_TRIANGLE_LIST );
     manual->position(-100.0,  100.0, 0.0);
     manual->colour( ColourValue::Red ); // ColourValue( 1, 0, 0 );
     manual->position(-100.0, -100.0, 0.0);
     manual->colour( ColourValue::Green ); // ColourValue( 0, 1, 0 );
     manual->position( 100.0, -100.0, 0.0);
     manual->colour( ColourValue::Blue ); // ColourValue( 0, 0, 1 );
     manual->end();
     // attach the object to the root node
     scene_mgr->getRootSceneNode()->attachObject( manual );

    // start the rendering loop
    root->startRendering();
    return 0;
}