hogrewidget.cpp

#include "hogrewidget.h"

HOgreWidget::HOgreWidget (QWidget *parent, bool bAutoCreated) : QGLWidget (parent) {
    mbAutoCreated = bAutoCreated;

    mOgrePluginsCfg = "plugins.cfg";
    mRenderSystemCfg = "ogre.cfg";
    mOgreResourcesCfg = "resources.cfg";

    TheInputCameraFile = "cameraParametrs.yml";

    mOgreRoot = 0x0;
    mOgreRenderWindow = 0x0;
    mOgreCamera = 0x0;
    mOgreViewport = 0x0;
    mOgreSceneMngr = 0x0;
    mOgreCameraNode = 0x0;

    unsigned int i = 0;
    for (i; i < 64; i ++) {
        marOgreEntity [i] = 0x0, marOgreObjectNode [i] = 0x0;
        marBaseAnim [i] = 0x0, marTopAnim [i] = 0;
    }

    mOgreScale = 0.00675f * pow (2.0, 0.0);
    TheMarkerSize = 0.21;
}

HOgreWidget::~HOgreWidget () {
    Ogre::WindowEventUtilities::removeWindowEventListener (mOgreRenderWindow, this);

//    mOgreRenderWindow->destroy ();
    delete mOgreRenderWindow;

    mOgreRoot->destroySceneManager (mOgreSceneMngr);

    delete mOgreRoot;
}

int HOgreWidget::init (void) {
    int iRes = -1;

    mOgreRoot = new Root();

    if (mOgreRoot)
        if (loadResources () == 0)
            if (initAR () == 0)
                if (initRenderSystem () == 0)
                    if (createOgreRenderWindow () == 0)
                        if (createOgreSceneManager () == 0)
                            if (setupResource () == 0)
                                if (createCameraBackground () == 0)
                                    if (createOgreCamera () == 0)
                                        if (createOgreViewport () == 0)
                                            if (createOgreScene () == 0)
                                                iRes = 0;

    cout << "HOgreWidget::init: " << iRes << endl;
    return iRes;
}

int HOgreWidget::initRenderSystem (void) {
    int iRes = 0; //Success

    if(! (mOgreRoot->restoreConfig () || mOgreRoot->showConfigDialog ()))
        return -1;

    // setup a renderer OF KTHUCHA's
    Ogre::RenderSystemList::const_iterator renderers = mOgreRoot->getAvailableRenderers ().begin ();
    while (renderers != mOgreRoot->getAvailableRenderers().end ()) {
        Ogre::String rName = (*renderers)->getName ();
        if (rName == "OpenGL Rendering Subsystem")
            break;

        renderers++;
    }

    if (*renderers != NULL) {
        mOgreRoot->setRenderSystem (*renderers);

        //QString dimensions = QString ("%1x%2").arg (this->width ()).arg (this->height ());

        //renderSystem->setConfigOption ("Video Mode", dimensions.toStdString ());
        mOgreRoot->getRenderSystem ()->setConfigOption ("Video Mode", "800 x 600 @ 32-bit colour");

        // initialize without creating window
        mOgreRoot->getRenderSystem ()->setConfigOption ("Full Screen", "No");
        mOgreRoot->saveConfig ();
    }
    else
        iRes = -1;

    cout << "HOgreWidget::initRenderSystem: " << iRes << endl;
    return iRes;
}

int HOgreWidget::createOgreRenderWindow (void) {
    int iRes = 0; //Success

//    mOgreRenderWindow = mOgreRoot->getAutoCreatedWindow ();

    if (mbAutoCreated)
        mOgreRenderWindow = mOgreRoot->initialise (true, "BasicTutorial6 Render Window"); //???
    else {
        mOgreRenderWindow = mOgreRoot->initialise (false); //???

        Ogre::NameValuePairList params;
        Ogre::String externalWindowHandleParams;

        QX11Info info = x11Info ();
        externalWindowHandleParams  = Ogre::StringConverter::toString ((unsigned long)(info.display ()));
        externalWindowHandleParams += ":";

        externalWindowHandleParams += Ogre::StringConverter::toString ((unsigned int)(info.screen ()));
        externalWindowHandleParams += ":";

        externalWindowHandleParams += Ogre::StringConverter::toString ((unsigned long) winId ());
        externalWindowHandleParams += Ogre::StringConverter::toString ((unsigned long) parentWidget ()->winId ());

//        externalWindowHandleParams += ":";
//        externalWindowHandleParams += Ogre::StringConverter::toString((unsigned long) (info.visual ()));

        cout << "externalWindowHandleParams=" << externalWindowHandleParams << endl;

//        params ["parentWindowHandle"] = externalWindowHandleParams;
        params ["externalWindowHandle"] = externalWindowHandleParams;

        params ["externalGLControl"] = "true";
        params ["currentGLContext"] = "0";

        //        params ["FSAA"] = "0";
        //        params ["displayFrequency"] = "60 MHz";
        //        params ["gamma"] = "Yes";
        //        params ["vsync"] = "No";

        cout << "HOgreWidget::width ()=" << width () << ", height ()=" << height () << endl;
        cout << "HOgreWidget::mWidth=" << mWidth << ", mHeight=" << mHeight << endl;

        //Finally create our window
        mOgreRenderWindow = mOgreRoot->createRenderWindow ("OgreRenderWindow", width (), height (), false, &params); //???
//        mOgreRenderWindow = mOgreRoot->createRenderWindow ("OgreRenderWindow", mWidth, mHeight, false, &params); //???

        mOgreRenderWindow->setActive (true);
//        WId ogreWinId = 0x0;
//        mOgreRenderWindow->getCustomAttribute ("WINDOW", &ogreWinId );

//        assert (ogreWinId);

//        // bug fix, extract geometry
//        QRect geo = this->frameGeometry ( );

//        // create new window
//        this->create (ogreWinId);

//        // set geometrie infos to new window
//        this->setGeometry (geo);
    }

    if (mOgreRenderWindow)
        mOgreRenderWindow->setVisible (true);
    else
        iRes = -1;

    cout << "HOgreWidget::createOgreRenderWindow: " << iRes << endl;
    return iRes;
}

int HOgreWidget::loadResources (void) {
    int iRes = 0; //Success

    // set up resources
    // Load resource paths from config file
    Ogre::ConfigFile cf;
    try { cf.load (mOgreResourcesCfg); }
    catch (Ogre::Exception &e) {
        iRes = -1;
        std::cerr << "An exception has occured: " << e.getFullDescription ().c_str () << std::endl;
    }

    if ((iRes == 0) && (! (Ogre::ResourceGroupManager::getSingletonPtr () == 0x0))) {
        // Go through all sections & settings in the file
        Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator ();

        Ogre::String secName, typeName, archName;
        while (seci.hasMoreElements ())
        {
            secName = seci.peekNextKey ();
            Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext ();
            Ogre::ConfigFile::SettingsMultiMap::iterator i;
            for (i = settings->begin (); i != settings->end (); ++i)
            {
                typeName = i->first;
                archName = i->second;
                Ogre::ResourceGroupManager::getSingleton ().addResourceLocation (archName, typeName, secName);
            }
        }
    }
    else
        iRes = -1;

    cout << "HOgreWidget::loadResources: " << iRes << endl;
    return iRes;
}

int HOgreWidget::setupResource (void) {
    int iRes = 0; //Success

    if (Ogre::TextureManager::getSingletonPtr ()) {
        // Set default mipmap level (note: some APIs ignore this)
        Ogre::TextureManager::getSingletonPtr ()->setDefaultNumMipmaps (5);
        // initialise all resource groups
        Ogre::ResourceGroupManager::getSingletonPtr ()->initialiseAllResourceGroups ();
    }
    else
        iRes = -1;

    cout << "HOgreWidget::setupResource: " << iRes << endl;
    return iRes;
}

int HOgreWidget::createOgreSceneManager (void) {
    int iRes = 0; //Success

    // Create the SceneManager, in this case a generic one
    mOgreSceneMngr = mOgreRoot->createSceneManager ("DefaultSceneManager");

    if (mOgreSceneMngr == NULL)
        iRes = -1;

    cout << "HOgreWidget::createOgreSceneManager: " << iRes << endl;
    return iRes;
}

int HOgreWidget::createOgreViewport (void) {
    int iRes = 0; //Success

    if (mOgreRenderWindow && mOgreCamera) {
        //mViewport->setCamera (mCamera);
        mOgreViewport = mOgreRenderWindow->addViewport (mOgreCamera);

        if (mOgreViewport == NULL)
            iRes = -1;
        else {
            setAttribute(Qt::WA_OpaquePaintEvent);
//            setAttribute(Qt::WA_PaintOnScreen);
//            setAttribute(Qt::WA_NoSystemBackground);

            mOgreViewport->setBackgroundColour (Ogre::ColourValue (0.5, 0.5, 0.5));
        }
    }
    else
        iRes = -1;

    cout << "HOgreWidget::createOgreViewport: " << iRes << endl;
    return iRes;
}

int HOgreWidget::createOgreCamera (void) {
    int iRes = 0; //Success

    mOgreCamera = mOgreSceneMngr->createCamera ("camera");

    if (mOgreCamera) {
        //FROM A 'aruco_test_ogre.cpp'
        // configure Ogre Camera
    mOgreCamera->setProjectionType (Ogre::PT_ORTHOGRAPHIC);
    mOgreCamera->setNearClipDistance (0.01f);
    mOgreCamera->setFarClipDistance (10.0f);

        double pMatrix [16];
        CameraParamsUnd.OgreGetProjectionMatrix (CameraParamsUnd.CamSize,
                                                 CameraParamsUnd.CamSize,
                                                 pMatrix,
                                                 0.05,
                                                 10,
                                                 false);

        Ogre::Matrix4 PM (pMatrix [0], pMatrix [1], pMatrix [2] , pMatrix [3],
                         pMatrix [4], pMatrix [5], pMatrix [6] , pMatrix [7],
                         pMatrix [8], pMatrix [9], pMatrix [10], pMatrix [11],
                         pMatrix [12], pMatrix [13], pMatrix [14], pMatrix [15]);

        mOgreCamera->setCustomProjectionMatrix (true, PM);
        mOgreCamera->setCustomViewMatrix (true, Ogre::Matrix4::IDENTITY);


        //FROM A 'OgreARAppLogic'
//        mOgreCamera->setNearClipDistance (0.5);
//        mOgreCamera->setFarClipDistance (50000);
//        mOgreCamera->setPosition (0, 0, 0);
//        mOgreCamera->lookAt (-11, 0, 0);
        //mOgreCamera->setFOVy (Degree(40)); //FOVy camera Ogre = 40
        //mOgreCamera->setAspectRatio ((float) mViewport->getActualWidth () / (float) mViewport->getActualHeight ());


        /*
        //FROM A TUTORIAL6
        // Position it at 80 in Z direction
        mOgreCamera->setPosition (Ogre::Vector3(0, 0, 80));
        // Look back along -Z
        mOgreCamera->lookAt (Ogre::Vector3 (0, 0, -300));
        mOgreCamera->setNearClipDistance (5);

        // Create one viewport, entire window
        Ogre::Viewport* vp = mOgreWindow->addViewport (mOgreCamera);
        vp->setBackgroundColour (Ogre::ColourValue (0, 0, 0));

        // Alter the camera aspect ratio to match the viewport
        mOgreCamera->setAspectRatio (Ogre::Real (vp->getActualWidth ()) / Ogre::Real (vp->getActualHeight ()));
        */

        mOgreCameraNode = mOgreSceneMngr->getRootSceneNode ()->createChildSceneNode ("cameraNode");

        if (mOgreCameraNode) {
            //mOgreCameraNode->setPosition (0, 1700, 0);//
            //mOgreCameraNode->lookAt (Vector3 (0, 1700, -1), Node::TS_WORLD);//
            mOgreCameraNode->attachObject (mOgreCamera);
            //mCameraNode->setFixedYawAxis (true, Vector3::UNIT_Y);//
        }
        else
            iRes = -1;
    }
    else
        iRes = -1;

    cout << "HOgreWidget::createOgreCamera: " << iRes << endl;
    return iRes;
}

int HOgreWidget::createOgreScene (void) {
    int iRes = 0; //Success

    unsigned int i = 0;

    for (i; i < 64; i ++) {
        std::stringstream entityName;
        entityName << "marker_" << i;
        cout << entityName.str () << endl;

        marOgreEntity [i] = mOgreSceneMngr->createEntity (entityName.str (), "Sinbad.mesh");

        if (marOgreEntity [i]) {
            marOgreObjectNode [i] = mOgreSceneMngr->getRootSceneNode ()->createChildSceneNode ();

            if (marOgreObjectNode [i]) {
                marOgreObjectNode [i]->attachObject (marOgreEntity [i]);

                marOgreObjectNode [i]->setScale (mOgreScale, mOgreScale, mOgreScale);
                marOgreObjectNode [i]->setVisible (false);

                // Init animation
                marOgreEntity [i]->getSkeleton ()->setBlendMode (Ogre::ANIMBLEND_CUMULATIVE);
                marBaseAnim [i] = marOgreEntity [i]->getAnimationState ("RunBase");
                marTopAnim [i] = marOgreEntity [i]->getAnimationState ("Dance");
                marBaseAnim [i]->setLoop (true);
                marTopAnim [i]->setLoop (true);
                marBaseAnim [i]->setEnabled (true);
                marTopAnim [i]->setEnabled (true);
            }
            else
                iRes = -1;
        }
        else
            iRes = -1;

        if (! (iRes == 0))
            break;
    }

    if (iRes == 0) {
        // Set ambient light
//        mOgreSceneMngr->setAmbientLight (Ogre::ColourValue (0.5, 0.5, 0.5));

        // Create a light
        Ogre::Light* l = mOgreSceneMngr->createLight ("MainLight");
//        l->setPosition (20, 80, 50);
        l->setPosition (0, 1, -10);

        mOgreSceneMngr->getRootSceneNode()->attachObject (l);
    }
    else
        iRes = -1;

    cout << "HOgreWidget::createOgreScene: " << iRes << endl;
    return iRes;
}

int HOgreWidget::initAR (void) {
    int iRes = 0; //Success

    // read input video
    TheVideoCapturer.open (0);

    if (! (TheVideoCapturer.isOpened ())) {
        std::cerr << "Could not open video" << endl;

        iRes = -1;
    }
    else {
        // read intrinsic file
        try { CameraParams.readFromXMLFile (TheInputCameraFile); }
        catch (std::exception &ex) {
            cout << ex.what() << endl;

            iRes = -1;
        }

        if (iRes == 0) {
            // capture first frame
            TheVideoCapturer.grab ();
            TheVideoCapturer.retrieve (TheInputImage);

            cv::undistort (TheInputImage, TheInputImageUnd, CameraParams.CameraMatrix, CameraParams.Distorsion);

            CameraParamsUnd = CameraParams;
            CameraParamsUnd.Distorsion = cv::Mat::zeros (4, 1, CV_32F);

            float fltCoeff = 1.25;
            sgnResized (TheInputImageUnd.cols * fltCoeff, TheInputImageUnd.rows * fltCoeff);

            // This two lines has to be defined in order to update background image
            mWidth = TheInputImageUnd.cols, mHeight = TheInputImageUnd.rows;
            mBuffer = TheInputImageUnd.ptr <unsigned char> (0); // TheInputImageUnd will be shown as background
        }
        else
            ;
    }

    cout << "HOgreWidget::initAR: " << iRes << endl;
    return iRes;
}

int HOgreWidget::createCameraBackground (void) {
    int iRes = 0; //Success

    if (mWidth == 0 || mHeight == 0 || mBuffer == 0) {
        std::cout << "Image size or buffer not defined in user-defined init function" << std::endl;

        iRes = -1;
    }
    else {
        // create background texture
        mPixelBox = Ogre::PixelBox(mWidth, mHeight, 1, Ogre::PF_R8G8B8, mBuffer);
        // Create Texture
        mTexture = Ogre::TextureManager::getSingleton().createManual (
                  "CameraTexture",
                  Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
                  Ogre::TEX_TYPE_2D,
                  mWidth,
                  mHeight,
                  0,
                  Ogre::PF_R8G8B8,
                  Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);

        //Create Camera Material
        MaterialPtr material = MaterialManager::getSingleton().create("CameraMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
        Ogre::Technique *technique = material->createTechnique();
        technique->createPass();
        material->getTechnique(0)->getPass(0)->setLightingEnabled (false);
        material->getTechnique(0)->getPass(0)->setDepthWriteEnabled (false);
        material->getTechnique(0)->getPass(0)->createTextureUnitState ("CameraTexture");

        // Create background rectangle covering the whole screen
        Rectangle2D* rect = new Rectangle2D(true);
        rect->setCorners (-1.0, 1.0, 1.0, -1.0);
        rect->setMaterial ("CameraMaterial");

        // Render the background before everything else
        rect->setRenderQueueGroup (RENDER_QUEUE_BACKGROUND);

        // Hacky, but we need to set the bounding box to something big
        // Use infinite AAB to always stay visible
        AxisAlignedBox aabInf;
        aabInf.setInfinite();
        rect->setBoundingBox (aabInf);

        // Attach background to the scene
        SceneNode* node = mOgreSceneMngr->getRootSceneNode ()->createChildSceneNode ("Background666");
        node->attachObject (rect);
    }

    cout << "HOgreWidget::createCameraBackground: " << iRes << endl;
    return iRes;
}

// Ogre::FrameListener
bool HOgreWidget::frameRenderingQueued (const Ogre::FrameEvent &evt) {
    cout << "In RenderingQueued..." << endl;

    mOgreViewport->setBackgroundColour (Ogre::ColourValue (0.5, 0.5, 0.5));

    unsigned int i;
    int iMarkerCount = -1;
    double position [3], orientation [4];
    Ogre::Quaternion qtrnRotationX (sqrt (0.5), sqrt (0.5), 0, 0), qtrnRotationAruco, qtrnRotationTotal;

    // capture a frame
    if (TheVideoCapturer.grab ()) {//Hay alguna imagen para procesar?
        // undistort image
        TheVideoCapturer.retrieve (TheInputImage);

        if (! mTexture.isNull ())
        {
            cout << "update backGround...";

            //Pedimos a ogre que actualice la imagen desde el PixelBox
            Ogre::HardwarePixelBufferSharedPtr pixelBuffer = mTexture->getBuffer ();
            cout << pixelBuffer.isNull () << endl;
            pixelBuffer->blitFromMemory (mPixelBox);
        }
        else {
            cout << "update backGround...mTexture.isNull () = true!" << endl;

            return false;
        }

        cv::undistort (TheInputImage,
                       TheInputImageUnd,
                       CameraParams.CameraMatrix,
                       CameraParams.Distorsion);

        // detect markers
        MDetector.detect (  TheInputImageUnd,
                            TheMarkers,
                            CameraParamsUnd,
                            TheMarkerSize);

//        iMarkerCount = TheMarkers.size ();
//        cout << iMarkerCount << endl;

        // set object poses
        try { i = 0; }
        catch (Ogre::Exception &e) {
            std::cerr << "An exception has occured: " << e.getFullDescription ().c_str () << std::endl;

            return false;
        }

        if (TheMarkers.size ()) {
            i = 0;
            do {
                cout << TheMarkers [i].id;
                if ((++ i) < TheMarkers.size ())
                    cout << ", ";
                else
                    cout << endl;
            }
            while (i < TheMarkers.size ());

//            for (i = 0; i < TheMarkers.size (); i ++) {
//                cout << TheMarkers [i].id;
//                if ((i + 1) < TheMarkers.size ())
//                    cout << ", ";
//                else
//                    cout << endl;
//            }
        }
        else
            ;

        for (i = 0; i < 64; i ++) {
            if (TheMarkers.size ()) {
                if (i < TheMarkers.size ()) {
                    if (marOgreObjectNode [i]) {
                        marOgreObjectNode [i] ->setVisible (true);

                        try { TheMarkers [i].OgreGetPoseParameters (position, orientation); }
                        catch (Ogre::Exception &e) {
                            std::cerr << "An exception has occured: " << e.getFullDescription ().c_str () << std::endl;
                        }

                        cout << "position={" << position [0] << ":"  << position [1] << ":"  << position [2] << "}" << endl;
                        marOgreObjectNode [i]->setPosition (position [0], position [1], position [2]);

                        cout << "orientation={" << orientation [0] << ":"  << orientation [1] << ":"  << orientation [2] << ":"  << orientation [3] << "}" << endl;
                        cout << "orientation={" << orientation [0]*180/M_PI << ":"  << orientation [1]*180/M_PI << ":"  << orientation [2]*180/M_PI << ":"  << orientation [3]*180/M_PI << "}" << endl;

                        qtrnRotationAruco = Ogre::Quaternion (orientation [0], orientation [1], orientation [2], orientation [3]);
                        qtrnRotationTotal = qtrnRotationAruco * qtrnRotationX;
                        orientation [0] = qtrnRotationTotal.w, orientation [1] = qtrnRotationTotal.x, orientation [2] = qtrnRotationTotal.y, orientation [3] = qtrnRotationTotal.z;

                        marOgreObjectNode [i]->setOrientation (orientation [0], orientation [1], orientation [2], orientation [3]);

//                        // Update animation and correct position
                        marBaseAnim [i]->addTime (0.08);
                        marTopAnim [i]->addTime (0.08);

                        Ogre::Real offset = marOgreEntity [i]->getBoundingBox ().getHalfSize ().y;

                        marOgreObjectNode [i]->translate (0, +offset * mOgreScale, 0, Ogre::Node::TS_LOCAL);
                    }
                    else //Не создан ОДиН из 'entity'
                        ;
                }
                else
                    ; //Счётчик 'i' МЕНьШе числа РАСПОЗНАНных МАРКЕРов
            }
            else //МАРКЕРы ВОВСе НЕ ОБНАРУЖены
                marOgreObjectNode [i]->setVisible (false);
        } //Цикл 'for'
    }
    else
        ; //Нет изображения с 'КАМЕРа'

    cout << "Out RenderingQueued..." << endl;

    return true;
}

bool HOgreWidget::frameStarted (const FrameEvent &evt) {
    cout << "HOgreWidget::frameStarted" << endl;
    return true;
}

bool HOgreWidget::frameEnded (const FrameEvent &evt) {
    cout << "HOgreWidget::frameEnded" << endl;
    return true;
}

Ogre::RenderSystem* HOgreWidget::chooseRenderer (RenderSystemList *renderers) {
    // It would probably be wise to do something more friendly
    // that just use the first available renderer
    return *renderers->begin();
}

int HOgreWidget::initLoop (void) {
    cout << "HOgreWidget::initLoop" << endl;

    //Register as a Window listener
    Ogre::WindowEventUtilities::addWindowEventListener (mOgreRenderWindow, this);

    //Adding as a Window listener
    mOgreRoot->addFrameListener (this);

    return 0;
}

void HOgreWidget::startLoop (void) {
    cout << "HOgreWidget::startLoop" << endl;

    bool bRes = false;

//    while (true) {
//        // Pump window messages for nice behaviour
//        Ogre::WindowEventUtilities::messagePump ();

//        if (mOgreRenderWindow->isClosed ())
//            return ;

//            // Render a frame
//        try { bRes = mOgreRoot->renderOneFrame ();  }
//        catch (Exception &err)
//        {
//            std::cerr << "An exception has occured: " << err.getFullDescription ().c_str () << std::endl;
//        }

//        if (! bRes)
//            return ;
//    }

    cout << mOgreRoot->getNextFrameNumber () << endl;
    if (mOgreRoot->getNextFrameNumber () == 0) {
        try { mOgreRoot->startRendering (); }
        catch (Exception &err)
        {
            std::cerr << "An exception has occured: " << err.getFullDescription ().c_str () << std::endl;
        }
    }
    else
        ;
}

// Ogre::WindowEventListener
void HOgreWidget::windowResized (Ogre::RenderWindow *rw) {
    cout << "HOgreWidget::windowResized" << endl;
    cout << "RenderWindow::width ()=" << rw->getWidth () << ", height ()=" << rw->getHeight () << endl;
    cout << "HOgreWidget::width ()=" << width () << ", height ()=" << height () << endl;
    cout << "HOgreWidget::mWidth=" << mWidth << ", mHeight=" << mHeight << endl;
    cout << "call HOgreWidget::resize" << endl;
//    resize (rw->getWidth (), rw->getHeight ());
    cout << "HOgreWidget::width ()=" << width () << ", height ()=" << height () << endl;
    cout << "HOgreWidget::mWidth=" << mWidth << ", mHeight=" << mHeight << endl;
}

// Ogre::WindowEventListener
void HOgreWidget::windowClosed (Ogre::RenderWindow *rw) {
    cout << "HOgreWidget::windowClosed" << endl;
}