hogrewidget.h

#ifndef HOGREWIDGET_H
#define HOGREWIDGET_H

#include <QResizeEvent>
#include <QCloseEvent>

#include <OGRE/Ogre.h>
#include <QX11Info>
//#include <QWidget>
#include <QGLWidget>
#include <aruco/aruco.h>

//#include <OISEvents.h>
//#include <OISInputManager.h>
//#include <OISKeyboard.h>
//#include <OISMouse.h>

using namespace Ogre;
//using namespace cv;
using namespace std;
using namespace aruco;

//class HOgreWidget : public QGLWidget
class HOgreWidget : public QGLWidget, public Ogre::WindowEventListener, public Ogre::FrameListener
{
    Q_OBJECT
public:
//    explicit HOgreWidget(QWidget * = 0);
    explicit HOgreWidget (QWidget * = 0, bool = true);
    ~HOgreWidget ();

    int init (void);
    int initLoop (void);
    void startLoop (void);

    Root *getOgreRoot (void) { return mOgreRoot; }

    virtual Ogre::RenderSystem* chooseRenderer (RenderSystemList *);

signals:
    void sgnSuccessInitalizeGL ();
    void sgnResized (int, int);
    void sgnClosed ();

public slots:

protected:
    // Ogre::WindowEventListener
    virtual void windowResized (Ogre::RenderWindow *);
    virtual void windowClosed (Ogre::RenderWindow *);

    // Ogre::FrameListener
    virtual bool frameRenderingQueued (const Ogre::FrameEvent &);
    virtual bool frameStarted (const FrameEvent &);
    virtual bool frameEnded (const FrameEvent &);

    virtual void resizeEvent (QResizeEvent *evt) {
//        QSize sz = ;
        cout << "HOgreWidget::resizeEvent=oldSize (" << evt->oldSize ().width () << ";" << evt->oldSize ().height () << "), " <<
                "newSize= (" << evt->size ().width () << ";" << evt->size ().height () << ")" << endl;
        cout << "HOgreWidget::width ()=" << width () << ", height ()=" << height () << endl;
    }

    virtual void closeEvent (QCloseEvent *evt) {
        cout << "HOgreWidget::closeEvent" << endl;
    }

    virtual void initializeGL () {
        int iRes = init ();
        initLoop ();

        cout << "HOgreWidget::initializeGL: " << iRes << endl;

        sgnSuccessInitalizeGL ();
    }

    virtual void resizeGL (int, int ) {
        cout << "HOgreWidget::resizeGL" << endl;
    }

//    virtual void paintGL() {
//        cout << "HOgreWidget::paintGL" << endl;
//    }

private:
    Root *mOgreRoot;
    RenderWindow *mOgreRenderWindow;
    Camera *mOgreCamera;
    Viewport *mOgreViewport;
    SceneManager *mOgreSceneMngr;
    SceneNode* mOgreCameraNode;
    Ogre::Entity* marOgreEntity [64];
    SceneNode* marOgreObjectNode [64];
    Ogre::AnimationState *marBaseAnim [64], *marTopAnim [64];
    float mOgreScale;

    Ogre::String mOgrePluginsCfg;
    Ogre::String mRenderSystemCfg;
    Ogre::String mOgreResourcesCfg;

    /// For augmented Reality
    int mWidth, mHeight;
    unsigned char* mBuffer;
    TexturePtr mTexture;
    PixelBox mPixelBox;

    // ArUco variables
    string TheInputVideo, TheInputCameraFile;
    cv::VideoCapture TheVideoCapturer;
    cv::Mat TheInputImage, TheInputImageUnd;
    CameraParameters CameraParams, CameraParamsUnd;
    MarkerDetector MDetector;
    cv::vector <Marker> TheMarkers;
    float TheMarkerSize;

    // OIS Input devices
//    OIS::InputManager* mOISInputManager;
//    OIS::Mouse*    mOISMouse;
//    OIS::Keyboard* mOISKeyboard;

    bool mbAutoCreated;

    int initRenderSystem (void);
    int createOgreRenderWindow (void);

    int loadResources (void);
    int setupResource (void);

    int createOgreSceneManager (void);
    int createOgreViewport (void);
    int createOgreCamera (void);
    int createOgreScene (void);

    int initAR (void);

    int createCameraBackground (void);
};

#endif // HOGREWIDGET_H