Added gui/ and ogre/ from OpenMW

gui/layout.hpp

@@ -0,0 +1,118 @@
+#ifndef OENGINE_MYGUI_LAYOUT_H
+#define OENGINE_MYGUI_LAYOUT_H
+
+#include <assert.h>
+#include <MyGUI.h>
+
+namespace GUI
+{
+  /** The Layout class is an utility class used to load MyGUI layouts
+      from xml files, and to manipulate member widgets.
+   */
+  class Layout
+  {
+  public:
+    Layout(const std::string & _layout, MyGUI::WidgetPtr _parent = nullptr)
+      : mMainWidget(nullptr)
+    { initialise(_layout, _parent); }
+    virtual ~Layout() { shutdown();  }
+
+    template <typename T>
+    void getWidget(T * & _widget, const std::string & _name, bool _throw = true)
+    {
+      _widget = nullptr;
+      for (MyGUI::VectorWidgetPtr::iterator iter=mListWindowRoot.begin();
+           iter!=mListWindowRoot.end(); ++iter)
+        {
+          MyGUI::WidgetPtr find = (*iter)->findWidget(mPrefix + _name);
+          if (nullptr != find)
+            {
+              T * cast = find->castType<T>(false);
+              if (nullptr != cast)
+                _widget = cast;
+              else if (_throw)
+                {
+                  MYGUI_EXCEPT("Error cast : dest type = '" << T::getClassTypeName()
+                               << "' source name = '" << find->getName()
+                               << "' source type = '" << find->getTypeName() << "' in layout '" << mLayoutName << "'");
+                }
+              return;
+            }
+        }
+      MYGUI_ASSERT( ! _throw, "widget name '" << _name << "' in layout '" << mLayoutName << "' not found.");
+    }
+
+    void initialise(const std::string & _layout,
+                    MyGUI::WidgetPtr _parent = nullptr)
+    {
+      const std::string MAIN_WINDOW = "_Main";
+      mLayoutName = _layout;
+
+      if (mLayoutName.empty())
+        mMainWidget = _parent;
+      else
+        {
+          mPrefix = MyGUI::utility::toString(this, "_");
+          mListWindowRoot = MyGUI::LayoutManager::getInstance().loadLayout(mLayoutName, mPrefix, _parent);
+
+          const std::string main_name = mPrefix + MAIN_WINDOW;
+          for (MyGUI::VectorWidgetPtr::iterator iter=mListWindowRoot.begin(); iter!=mListWindowRoot.end(); ++iter)
+            {
+              if ((*iter)->getName() == main_name)
+                {
+                  mMainWidget = (*iter);
+                  break;
+                }
+            }
+          MYGUI_ASSERT(mMainWidget, "root widget name '" << MAIN_WINDOW << "' in layout '" << mLayoutName << "' not found.");
+        }
+    }
+
+    void shutdown()
+    {
+      MyGUI::LayoutManager::getInstance().unloadLayout(mListWindowRoot);
+      mListWindowRoot.clear();
+    }
+
+    void setCoord(int x, int y, int w, int h)
+    {
+      mMainWidget->setCoord(x,y,w,h);
+    }
+
+    void setVisible(bool b)
+    {
+      mMainWidget->setVisible(b);
+    }
+
+    void setText(const std::string& name, const std::string& caption)
+    {
+      MyGUI::WidgetPtr pt;
+      getWidget(pt, name);
+      pt->setCaption(caption);
+    }
+
+    void setTextColor(const std::string& name, float r, float g, float b)
+    {
+      MyGUI::WidgetPtr pt;
+      getWidget(pt, name);
+      MyGUI::StaticText *st = dynamic_cast<MyGUI::StaticText*>(pt);
+      if(st != NULL)
+        st->setTextColour(MyGUI::Colour(b,g,r));
+    }
+
+    void setImage(const std::string& name, const std::string& imgName)
+    {
+      MyGUI::StaticImagePtr pt;
+      getWidget(pt, name);
+      pt->setImageTexture(imgName);
+    }
+
+  protected:
+
+    MyGUI::WidgetPtr mMainWidget;
+    std::string mPrefix;
+    std::string mLayoutName;
+    MyGUI::VectorWidgetPtr mListWindowRoot;
+  };
+}
+#endif

gui/manager.cpp

@@ -0,0 +1,43 @@
+#include <MyGUI.h>
+#include <MyGUI_OgrePlatform.h>
+#include <assert.h>
+
+#include "manager.hpp"
+
+using namespace GUI;
+
+void MyGUIManager::setup(Ogre::RenderWindow *wnd, Ogre::SceneManager *mgr, bool logging)
+{
+  assert(wnd);
+  assert(mgr);
+
+  using namespace MyGUI;
+
+  // Enable/disable MyGUI logging to stdout. (Logging to MyGUI.log is
+  // still enabled.) In order to do this we have to initialize the log
+  // manager before the main gui system itself, otherwise the main
+  // object will get the chance to spit out a few messages before we
+  // can able to disable it.
+  LogManager::initialise();
+  LogManager::setSTDOutputEnabled(logging);
+
+  // Set up OGRE platform. We might make this more generic later.
+  mPlatform = new OgrePlatform();
+  mPlatform->initialise(wnd, mgr);
+
+  // Create GUI
+  mGui = new Gui();
+  mGui->initialise();
+}
+
+void MyGUIManager::shutdown()
+{
+  if(mGui) delete mGui;
+  if(mPlatform)
+    {
+      mPlatform->shutdown();
+      delete mPlatform;
+    }
+  mGui = NULL;
+  mPlatform = NULL;
+}

gui/manager.hpp

@@ -0,0 +1,33 @@
+#ifndef OENGINE_MYGUI_MANAGER_H
+#define OENGINE_MYGUI_MANAGER_H
+
+namespace MyGUI
+{
+  class OgrePlatform;
+  class Gui;
+}
+
+namespace Ogre
+{
+  class RenderWindow;
+  class SceneManager;
+}
+
+namespace GUI
+{
+  class MyGUIManager
+  {
+    MyGUI::OgrePlatform *mPlatform;
+    MyGUI::Gui *mGui;
+
+  public:
+    MyGUIManager() : mPlatform(NULL), mGui(NULL) {}
+    MyGUIManager(Ogre::RenderWindow *wnd, Ogre::SceneManager *mgr, bool logging=false)
+    { setup(wnd,mgr,logging); }
+    ~MyGUIManager() { shutdown(); }
+
+    void setup(Ogre::RenderWindow *wnd, Ogre::SceneManager *mgr, bool logging=false);
+    void shutdown();
+  };
+}
+#endif

input/dispatch_map.hpp

@@ -1,5 +1,5 @@
-#ifndef _INPUT_DISPATCHMAP_H
-#define _INPUT_DISPATCHMAP_H
+#ifndef OENGINE_INPUT_DISPATCHMAP_H
+#define OENGINE_INPUT_DISPATCHMAP_H
 
 #include <set>
 #include <map>

input/dispatcher.hpp

@@ -1,5 +1,5 @@
-#ifndef _INPUT_DISPATCHER_H
-#define _INPUT_DISPATCHER_H
+#ifndef OENGINE_INPUT_DISPATCHER_H
+#define OENGINE_INPUT_DISPATCHER_H
 
 #include "dispatch_map.hpp"
 #include "func_binder.hpp"

input/func_binder.hpp

@@ -1,5 +1,5 @@
-#ifndef _INPUT_FUNCBINDER_H
-#define _INPUT_FUNCBINDER_H
+#ifndef OENGINE_INPUT_FUNCBINDER_H
+#define OENGINE_INPUT_FUNCBINDER_H
 
 #include <string>
 #include <vector>

input/poller.hpp

@@ -1,5 +1,5 @@
-#ifndef _INPUT_POLLER_H
-#define _INPUT_POLLER_H
+#ifndef OENGINE_INPUT_POLLER_H
+#define OENGINE_INPUT_POLLER_H
 
 #include "dispatch_map.hpp"
 #include <mangle/input/driver.hpp>

ogre/.gitignore

@@ -0,0 +1 @@
+old

ogre/renderer.cpp

@@ -0,0 +1,80 @@
+#include "renderer.hpp"
+
+#include "OgreRoot.h"
+#include "OgreRenderWindow.h"
+#include "OgreLogManager.h"
+#include "OgreLog.h"
+
+#include <assert.h>
+
+using namespace Ogre;
+using namespace Render;
+
+void OgreRenderer::cleanup()
+{
+  if(mRoot)
+    delete mRoot;
+  mRoot = NULL;
+}
+
+void OgreRenderer::screenshot(const std::string &file)
+{
+  mWindow->writeContentsToFile(file);
+}
+
+bool OgreRenderer::configure(bool showConfig,
+                             const std::string &pluginCfg,
+                             bool _logging)
+{
+  // Set up logging first
+  new LogManager;
+  Log *log = LogManager::getSingleton().createLog("Ogre.log");
+  logging = _logging;
+
+  if(logging)
+    // Full log detail
+    log->setLogDetail(LL_BOREME);
+  else
+    // Disable logging
+    log->setDebugOutputEnabled(false);
+
+  mRoot = new Root(pluginCfg, "ogre.cfg", "");
+
+  // Show the configuration dialog and initialise the system, if the
+  // showConfig parameter is specified. The settings are stored in
+  // ogre.cfg. If showConfig is false, the settings are assumed to
+  // already exist in ogre.cfg.
+  int result;
+  if(showConfig)
+    result = mRoot->showConfigDialog();
+  else
+    result = mRoot->restoreConfig();
+
+  return !result;
+}
+
+void OgreRenderer::createWindow(const std::string &title)
+{
+  assert(mRoot);
+  // Initialize OGRE window
+  mWindow = mRoot->initialise(true, title, "");
+}
+
+void OgreRenderer::createScene(const std::string camName, float fov, float nearClip)
+{
+  assert(mRoot);
+  assert(mWindow);
+  // Get the SceneManager, in this case a generic one
+  mScene = mRoot->createSceneManager(ST_GENERIC);
+
+  // Create the camera
+  mCamera = mScene->createCamera(camName);
+  mCamera->setNearClipDistance(nearClip);
+  mCamera->setFOVy(Degree(fov));
+  
+  // Create one viewport, entire window
+  mView = mWindow->addViewport(mCamera);
+
+  // Alter the camera aspect ratio to match the viewport
+  mCamera->setAspectRatio(Real(mView->getActualWidth()) / Real(mView->getActualHeight()));
+}

ogre/renderer.hpp

@@ -0,0 +1,77 @@
+#ifndef OENGINE_OGRE_RENDERER_H
+#define OENGINE_OGRE_RENDERER_H
+
+/*
+  Ogre renderer class
+ */
+
+#include <OgreRoot.h>
+#include <string>
+
+namespace Ogre
+{
+    class Root;
+    class RenderWindow;
+    class SceneManager;
+    class Camera;
+    class Viewport;
+}
+
+namespace Render
+{
+  class OgreRenderer
+  {
+    Ogre::Root *mRoot;
+    Ogre::RenderWindow *mWindow;
+    Ogre::SceneManager *mScene;
+    Ogre::Camera *mCamera;
+    Ogre::Viewport *mView;
+    bool logging;
+
+  public:
+    OgreRenderer()
+      : mRoot(NULL), mWindow(NULL), mScene(NULL) {}
+    ~OgreRenderer() { cleanup(); }
+
+    /** Configure the renderer. This will load configuration files and
+        set up the Root and logging classes. */
+    bool configure(bool showConfig,     // Show config dialog box?
+                   const std::string &pluginCfg, // plugin.cfg file
+                   bool _logging);      // Enable or disable logging
+
+    /// Create a window with the given title
+    void createWindow(const std::string &title);
+
+    /// Set up the scene manager, camera and viewport
+    void createScene(const std::string camName="Camera",// Camera name
+                     float fov=55,                      // Field of view angle
+                     float nearClip=5                   // Near clip distance
+                     );
+
+    /// Kill the renderer.
+    void cleanup();
+
+    /// Start the main rendering loop
+    void start() { mRoot->startRendering(); }
+
+    /// Write a screenshot to file
+    void screenshot(const std::string &file);
+
+    /// Get the Root
+    Ogre::Root *getRoot() { return mRoot; }
+
+    /// Get the rendering window
+    Ogre::RenderWindow *getWindow() { return mWindow; }
+
+    /// Get the scene manager
+    Ogre::SceneManager *getScene() { return mScene; }
+
+    /// Camera
+    Ogre::Camera *getCamera() { return mCamera; }
+
+    /// Viewport
+    Ogre::Viewport *getViewport() { return mView; }
+  };
+}
+
+#endif