scene graph always stay at left-bottom of ogreWindow

Anything and everything that's related to OGRE or the wider graphics field that doesn't fit into the other forums.
Post Reply
lainegates
Gnoblar
Posts: 9
Joined: Thu Jun 12, 2014 3:16 am

scene graph always stay at left-bottom of ogreWindow

Post by lainegates » Sat Feb 24, 2018 12:27 am

Hi, I try to use ogre (1.10 stable release) with qt5 (5.10).
I find an strange behavior of ogre scene that it always stay at left-bottom corner of current viewport .
Image
if I resize my window, the secene size is not updated.
Image
And this is a FHD (1920*1080) monitor, without HiDPI.
ogreWindow code:
.h

Code: Select all

#ifndef QTOGREWINDOW_H
#define QTOGREWINDOW_H

/*
Qt headers
*/
#include <QtWidgets/QApplication>
#include <QtGui/QKeyEvent>
#include <QtGui/QWindow>
#include <QtCore/QTimer>


/*
Ogre3D header
*/
#include <Ogre.h>

namespace Ogre {
class OverlaySystem;
}

/*
Changed SdkCameraMan implementation to work with QKeyEvent, QMouseEvent, QWheelEvent
*/

#include <OgreCameraMan.h>

/*
With the headers included we now need to inherit from QWindow.
*/
class QTOgreWindow : public QWindow, public Ogre::FrameListener
{
    /*
    A QWindow still inherits from QObject and can have signals/slots; we need to add the appropriate
    Q_OBJECT keyword so that Qt's intermediate compiler can do the necessary wireup between our class
    and the rest of Qt.
    */
    Q_OBJECT

public:
    explicit QTOgreWindow(QWindow *parent = NULL);
    ~QTOgreWindow();

    /*
    We declare these methods virtual to allow for further inheritance.
    */
    virtual void render(QPainter *painter);
    virtual void render();
    virtual void initialize();
    virtual void loadScene();
    virtual void createCube();
#if OGRE_VERSION >= ((2 << 16) | (0 << 8) | 0)
    virtual void createCompositor();
#endif

    void setAnimating(bool animating);

public slots:

    virtual void renderLater();
    virtual void renderNow();

    /*
    We use an event filter to be able to capture keyboard/mouse events. More on this later.
    */
    virtual bool eventFilter(QObject *target, QEvent *event);

    void takeSnapshot(Ogre::String& fileName);

signals:
    /*
    Event for clicking on an entity.
    */
    void entitySelected(Ogre::Entity* entity);

    void getStepNumber(int stepNumber);
    void getTotalStepNumber(int stepNumber);

protected:
    /// Locad "resources.cfg"
    void _loadResources();
    /*
    The below methods are what is actually fired when they keys on the keyboard are hit.
    Similar events are fired when the mouse is pressed or other events occur.
    */
    virtual void keyPressEvent(QKeyEvent * ev);
    virtual void keyReleaseEvent(QKeyEvent * ev);
    virtual void mouseMoveEvent(QMouseEvent* e);
    virtual void wheelEvent(QWheelEvent* e);
    virtual void mousePressEvent(QMouseEvent* e);
    virtual void mouseReleaseEvent(QMouseEvent* e);
    virtual void exposeEvent(QExposeEvent *event);
    virtual bool event(QEvent *event);

    /*
    FrameListener method
    */
    virtual bool frameRenderingQueued(const Ogre::FrameEvent& evt);

    /*
    Write log messages to Ogre log
    */
    void log(Ogre::String msg);
    void log(QString msg);

    /*
     * create Axis
     */
    void createAxis();

protected:
    /*
    Ogre3D pointers added here. Useful to have the pointers here for use by the window later.
    */
    Ogre::Root* m_ogreRoot;
    Ogre::RenderWindow* m_ogreWindow;
    Ogre::SceneManager* m_ogreSceneMgr;
    Ogre::Camera* m_ogreCamera;
    Ogre::ColourValue m_ogreBackground;
    Ogre::OverlaySystem* mOverlaySystem;
    OgreBites::CameraMan* m_cameraMan;
    Ogre::SceneNode* m_cameraNode;
    Ogre::SceneNode* m_Axis;

	QMouseEvent _lastMouseEvent;

    bool m_update_pending;
    bool m_animating;


private:
    QTimer _qtime;
};
}

#endif // QTOGREWINDOW_H
.cpp

Code: Select all

#include "QTOgreWindow.h"
#include "OgreManualObject.h"
#include "OgreMaterial.h"
#include <OgreAxisAlignedBox.h>
#include <OgreSceneNode.h>
#include <OgreViewport.h>
#include <Overlay/OgreOverlaySystem.h>

#include <QDir>


/*
Note that we pass any supplied QWindow parent to the base QWindow class. This is necessary should we
need to use our class within a container.
*/

QTOgreWindow::QTOgreWindow(QWindow *parent)
    : QWindow(parent)
    , m_update_pending(false)
    , m_animating(false)
    , m_ogreRoot(nullptr)
    , m_ogreWindow(nullptr)
    , m_ogreCamera(nullptr)
    , m_cameraMan(nullptr)
	, m_Axis(nullptr)
	, m_cameraNode(nullptr)
	, _lastMouseEvent(QEvent::Type::MouseButtonPress, QPointF(), Qt::MouseButton::LeftButton, Qt::MouseButtons(), Qt::KeyboardModifiers())
{
    setAnimating(true);
    installEventFilter(this);
    m_ogreBackground = Ogre::ColourValue(0.0f, 0.5f, 1.0f);
}

/*
Upon destruction of the QWindow object we destroy the Ogre3D scene.
*/
QTOgreWindow::~QTOgreWindow()
{
    if (m_cameraMan) 	{	delete m_cameraMan;		m_cameraMan = nullptr;	}
    delete m_ogreRoot;
}

/*
In case any drawing surface backing stores (QRasterWindow or QOpenGLWindow) of Qt are supplied to this
class in any way we inform Qt that they will be unused.
*/
void QTOgreWindow::render(QPainter *painter)
{
    Q_UNUSED(painter);
}

/*
Our initialization function. Called by our renderNow() function once when the window is first exposed.
*/
void QTOgreWindow::initialize()
{
    /*
    As shown Ogre3D is initialized normally; just like in other documentation.
    */
#ifdef _MSC_VER
	std::string dir = QDir::currentPath().toStdString();
	Ogre::String pluginFile = Ogre::String("plugins" OGRE_BUILD_SUFFIX ".cfg");
    m_ogreRoot = new Ogre::Root(pluginFile);
#else
    m_ogreRoot = new Ogre::Root(Ogre::String("plugins.cfg"));
#endif

    const Ogre::RenderSystemList& rsList = m_ogreRoot->getAvailableRenderers();
    Ogre::RenderSystem* rs = rsList[0];

    /*
    This list setup the search order for used render system.
    */
    Ogre::StringVector renderOrder;
#if defined(Q_OS_WIN)
    renderOrder.push_back("Direct3D9");
    renderOrder.push_back("Direct3D11");
#endif
    renderOrder.push_back("OpenGL");
    renderOrder.push_back("OpenGL 3+");
    for (Ogre::StringVector::iterator iter = renderOrder.begin(); iter != renderOrder.end(); iter++)
    {
        for (Ogre::RenderSystemList::const_iterator it = rsList.begin(); it != rsList.end(); it++)
        {
            if ((*it)->getName().find(*iter) != Ogre::String::npos)
            {
                rs = *it;
                break;
            }
        }
        if (rs != NULL) break;
    }
    if (rs == NULL)
    {
        if (!m_ogreRoot->restoreConfig())
        {
            if (!m_ogreRoot->showConfigDialog())
                OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS,
                    "Abort render system configuration",
                    "QTOgreWindow::initialize");
        }
    }

    /*
    Setting size and VSync on windows will solve a lot of problems
    */
    QString dimensions = QString("%1 x %2").arg(this->width()).arg(this->height());
    rs->setConfigOption("Video Mode", dimensions.toStdString());
    rs->setConfigOption("Full Screen", "No");
    rs->setConfigOption("VSync", "Yes");
    rs->setConfigOption("FSAA", "8");
    m_ogreRoot->setRenderSystem(rs);
    m_ogreRoot->initialise(false);
//    m_ogreRoot->initialise(true);

    Ogre::NameValuePairList parameters;
    /*
    Flag within the parameters set so that Ogre3D initializes an OpenGL context on it's own.
    */
    if (rs->getName().find("GL") <= rs->getName().size())
        parameters["currentGLContext"] = Ogre::String("false");

    /*
    We need to supply the low level OS window handle to this QWindow so that Ogre3D knows where to draw
    the scene. Below is a cross-platform method on how to do this.
    If you set both options (externalWindowHandle and parentWindowHandle) this code will work with OpenGL
    and DirectX.
    */
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
    parameters["externalWindowHandle"] = Ogre::StringConverter::toString((size_t)(this->winId()));
    parameters["parentWindowHandle"] = Ogre::StringConverter::toString((size_t)(this->winId()));
#else
    parameters["externalWindowHandle"] = Ogre::StringConverter::toString((unsigned long)(this->winId()));
    parameters["parentWindowHandle"] = Ogre::StringConverter::toString((unsigned long)(this->winId()));
#endif

#if defined(Q_OS_MAC)
    parameters["macAPI"] = "cocoa";
    parameters["macAPICocoaUseNSView"] = "true";
#endif

    // enable antialiasing
    parameters["FSAA"] = "8";

    /*
    Note below that we supply the creation function for the Ogre3D window the width and height
    from the current QWindow object using the "this" pointer.
    */
    m_ogreWindow = m_ogreRoot->createRenderWindow("QT Window",
        this->width(),
        this->height(),
        false,
        &parameters);
    m_ogreWindow->setVisible(true);

    /*
    The rest of the code in the initialization function is standard Ogre3D scene code. Consult other
    tutorials for specifics.
    */
#if OGRE_VERSION >= ((2 << 16) | (0 << 8) | 0)
    const size_t numThreads = std::max<int>(1, Ogre::PlatformInformation::getNumLogicalCores());
    Ogre::InstancingTheadedCullingMethod threadedCullingMethod = Ogre::INSTANCING_CULLING_SINGLETHREAD;
    if (numThreads > 1)threadedCullingMethod = Ogre::INSTANCING_CULLING_THREADED;
    m_ogreSceneMgr = m_ogreRoot->createSceneManager(Ogre::ST_GENERIC, numThreads, threadedCullingMethod);
#else
    m_ogreSceneMgr = m_ogreRoot->createSceneManager(Ogre::ST_GENERIC);
#endif

    _loadResources();

    /////////////////////////
    /// Camera
    /////////////////////////
    m_ogreCamera = m_ogreSceneMgr->createCamera("MainCamera");
//    m_ogreCamera->setPosition(Ogre::Vector3(0.0f, 0.0f, 10.0f));
//    m_ogreCamera->lookAt(Ogre::Vector3(0.0f, 0.0f, -300.0f));
	m_cameraNode = m_ogreSceneMgr->getRootSceneNode()->createChildSceneNode();
	m_cameraNode->attachObject(m_ogreCamera);
    m_ogreCamera->setNearClipDistance(0.1f);
    m_ogreCamera->setFarClipDistance(2000.0f);
	m_ogreCamera->setAspectRatio(180);
	m_cameraMan = new OgreBites::CameraMan(m_cameraNode);
	m_cameraMan->setStyle(OgreBites::CameraStyle::CS_ORBIT);
	m_cameraMan->setYawPitchDist(Ogre::Degree(-10), Ogre::Degree(0), 20);
	m_cameraMan->setTopSpeed(50);

    Ogre::Viewport* pViewport = m_ogreWindow->addViewport(m_ogreCamera);
    pViewport->setBackgroundColour(m_ogreBackground);

	m_ogreCamera->setAspectRatio((Ogre::Real)pViewport->getActualWidth() / (Ogre::Real)pViewport->getActualHeight());
    m_ogreCamera->setAutoAspectRatio(true);

    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
    Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

    createCube();
    createAxis();
	m_cameraMan->setTarget(m_Axis);

}

void QTOgreWindow::createAxis()
{
    const size_t nVertices = 8;
    const size_t vbufCount = 3*2*nVertices;

    float vertices[vbufCount] = {
            0.0,0.0,0.0,        //0 position
            10.0,0.0,0.0,        //1 position
            0.0,0.0,0.0,        //2 position
            0.0,10.0,0.0,        //3 position
            0.0,0.0,0.0,        //4 position
            0.0,0.0,10.0,        //5 position
    };
    float normals[6][3] = {
        { 1, 0, 0},
        { 1, 0, 0},
        { 0, 1, 0},
        { 0, 1, 0},
        { 0, 0, 1},
        { 0, 0, 1}
    };

    float colors[6][3] = {
        { 1, 0, 0},
        { 1, 0, 0},
        { 0, 1, 0},
        { 0, 1, 0},
        { 0, 0, 1},
        { 0, 0, 1}
    };

    const int size = 6;
    const Ogre::String mb("Axis");
    Ogre::ManualObject* mob = m_ogreSceneMgr->createManualObject(mb);
    mob->begin("NormalColors/Vertex", Ogre::RenderOperation::OT_LINE_LIST);
    for(int i=0; i<size; i++)
    {
        for(int j=0; j<3; j++)
        {
            mob->position(vertices[3*i+0], vertices[3*i+1],vertices[3*i+2]);
            mob->normal(normals[i][0], normals[i][1], normals[i][2]);
            mob->colour(colors[i][0], colors[i][1], colors[i][2]);
        }
    }
    mob->end();

    Ogre::AxisAlignedBox aaBox( 0, 0, 0, 5, 5, 5);
    mob->setBoundingBox(aaBox);

    const Ogre::String node("Axis");
    m_Axis = m_ogreSceneMgr->getRootSceneNode()
                                    ->createChildSceneNode(node);
    m_Axis->attachObject(mob);
    m_Axis->_updateBounds();
}

void QTOgreWindow::createCube()
{

    m_ogreSceneMgr->setAmbientLight(Ogre::ColourValue(1.0f, 1.0f, 1.0f));
    Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(
          "Test/ColourTest", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
    material->getTechnique(0)->getPass(0)->setVertexColourTracking(Ogre::TVC_AMBIENT);

    const size_t nVertices = 8;
    const size_t vbufCount = 3*2*nVertices;


    float vertices[vbufCount] = {
            0.0,1.0,0.0,        //0 position
            1.0,1.0,0.0,        //1 position
            1.0,0.0,0.0,        //2 position
            0.0,0.0,0.0,        //3 position
            0.0,1.0,1.0,        //4 position
            1.0,1.0,1.0,        //5 position
            1.0,0.0,1.0,        //6 position
            0.0,0.0,1.0,        //7 position
    };
    float normals[6][3] = {
        { 0, 0,-1},
        { 1, 0, 0},
        { 0, 0, 1},
        {-1, 0, 0},
        { 0, 1, 0},
        { 0,-1, 0}
    };

    /// Define 12 triangles (two triangles per cube face)
    /// The values in this table refer to vertices in the above table
    const size_t ibufCount = 36;
    unsigned short faces[ibufCount] = {
            0,2,3,
            0,1,2,
            1,6,2,
            1,5,6,
            4,6,5,
            4,7,6,
            0,7,4,
            0,3,7,
            0,5,1,
            0,4,5,
            2,7,3,
            2,6,7
    };


    int pIdx, fIdx;
    const int size = 12;
    const Ogre::String mb("Cube");
    Ogre::ManualObject* mob = m_ogreSceneMgr->createManualObject(mb);
    for(int i=0; i<size; i++)
    {
        mob->begin("Test/ColourTest", Ogre::RenderOperation::OT_TRIANGLE_LIST);
        for(int j=0; j<3; j++)
        {
            pIdx = faces[3*i+j];
            fIdx = i/2;

            mob->position(vertices[3*pIdx+0], vertices[3*pIdx+1],vertices[3*pIdx+2]);
            mob->normal(normals[fIdx][0], normals[fIdx][1], normals[fIdx][2]);
            mob->colour(1,0,1);
        }
        mob->end();
    }

    Ogre::AxisAlignedBox aaBox( 0, 0, 0, 5, 5, 5);
    mob->setBoundingBox(aaBox);

    const Ogre::String node("Cube");
    Ogre::SceneNode* thisSceneNode = m_ogreSceneMgr->getRootSceneNode()->createChildSceneNode(node);
    thisSceneNode->attachObject(mob);

//    thisSceneNode->showBoundingBox(true);
//    thisSceneNode->setPosition(8,0,0);

//    m_cameraMan->setTarget(thisSceneNode);

    Ogre::Light* light = m_ogreSceneMgr->createLight("MainLight3");
    light->setPosition(10.0f, 1.0f, 6.0f);
    light->setDiffuseColour(0.8, 0.8, 0.8);
    light->setSpecularColour(1.0, 1.0, 1.0);
}

void QTOgreWindow::loadScene()
{
    /*
    Example scene
    Derive this class for your own purpose and overwite this function to have a working Ogre widget with
    your own content.
    */
    m_ogreSceneMgr->setAmbientLight(Ogre::ColourValue(1.0f, 1.0f, 1.0f));

    Ogre::Light* light = m_ogreSceneMgr->createLight("MainLight");
    light->setPosition(6.0f, 6.0f, 6.0f);
    light->setDiffuseColour(1.0, 1.0, 1.0);
    light->setSpecularColour(1.0, 1.0, 1.0);
    m_ogreSceneMgr->getRootSceneNode()->attachObject(light);

    light = m_ogreSceneMgr->createLight("MainLight2");
    light->setPosition(6.0f, -6.0f, 6.0f);
    light->setDiffuseColour(1.0, 1.0, 1.0);
    light->setSpecularColour(1.0, 1.0, 1.0);
    m_ogreSceneMgr->getRootSceneNode()->attachObject(light);
}

void QTOgreWindow::render()
{
    Ogre::WindowEventUtilities::messagePump();
    m_ogreRoot->renderOneFrame();
}

void QTOgreWindow::renderLater()
{
    if (!m_update_pending)
    {
        m_update_pending = true;
        QApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
    }
}

bool QTOgreWindow::event(QEvent *event)
{
    return QWindow::event(event);
}

/*
Called after the QWindow is reopened or when the QWindow is first opened.
*/
void QTOgreWindow::exposeEvent(QExposeEvent *event)
{
    Q_UNUSED(event);

    if (isExposed())
        renderNow();

    if(!_qtime.isActive())  {
        QObject::connect(&_qtime, SIGNAL(timeout()), this, SLOT(renderNow()));
        _qtime.start(40);
    }
}

/*
The renderNow() function calls the initialize() function when needed and if the QWindow is already
initialized and prepped calls the render() method.
*/
void QTOgreWindow::renderNow()
{
    if (!isExposed())
        return;

    if (m_ogreRoot == NULL)
    {
        initialize();
    }

    render();

    if (m_animating)
        renderLater();
}

/*
Our event filter; handles the resizing of the QWindow. When the size of the QWindow changes note the
call to the Ogre3D window and camera. This keeps the Ogre3D scene looking correct.
*/
bool QTOgreWindow::eventFilter(QObject *target, QEvent *event)
{
    if (target == this)
    {
        if (event->type() == QEvent::Resize)
        {
            if (isExposed() && m_ogreWindow != NULL)
            {
                m_ogreWindow->resize(this->width(), this->height());
            }
        }
    }

    return false;
}

void QTOgreWindow::takeSnapshot(Ogre::String& fileName)
{
    m_ogreWindow->writeContentsToFile(fileName);
}

void QTOgreWindow::_loadResources()
{
    Ogre::ResourceGroupManager& mgr = Ogre::ResourceGroupManager::getSingleton();
    Ogre::ConfigFile cf;
    cf.load("resources.cfg");//load resources config file
    Ogre::ConfigFile::SectionIterator sectionIter = cf.getSectionIterator();
    Ogre::String sectionName,typeName,dataname;
    while(sectionIter.hasMoreElements())
    {
        // get section name
        sectionName = sectionIter.peekNextKey();
        // get scetion settings and iterator
        Ogre::ConfigFile::SettingsMultiMap *settings = sectionIter.getNext();
        Ogre::ConfigFile::SettingsMultiMap::iterator i;
        for(i = settings->begin(); i != settings->end(); ++i)
        {
            typeName = i->first;
            dataname = i->second;
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
           // OS X does not set the working directory relative to the app,
           // In order to make things portable on OS X we need to provide
           // the loading with it's own bundle path location
           mgr.addResourceLocation(String(macBundlePath() + "/" + archName)
                                   , typeName, secName);
#else
            mgr.addResourceLocation(dataname,typeName,sectionName);
#endif
        }
    }
    // init resources loaded, ONLY after this ".mesh" files can be loaded
    mgr.initialiseAllResourceGroups();
}

/*
How we handle keyboard and mouse events.
*/
void QTOgreWindow::keyPressEvent(QKeyEvent * ev)
{
}

void QTOgreWindow::keyReleaseEvent(QKeyEvent * ev)
{
}

void mapMouseBtnEvent(QMouseEvent* curE, OgreBites::MouseButtonEvent& oe) 
{
	if(curE->button()==Qt::MouseButton::LeftButton)
		oe.button = OgreBites::BUTTON_LEFT ;
	else if (curE->button()==Qt::MouseButton::RightButton)
		oe.button = OgreBites::BUTTON_RIGHT;
	else 
		oe.button = OgreBites::BUTTON_MIDDLE;

	oe.timestamp = curE->timestamp();

	oe.clicks = 1;
	 
	oe.x = curE->x();
	oe.y = curE->y();
}

void mapMouseMotionEvent(QMouseEvent* curE, QMouseEvent* preE, OgreBites::MouseMotionEvent& oe) 
{
	oe.type = SDL_MOUSEMOTION;
	oe.timestamp = curE->timestamp();
	 
	oe.x = curE->x();
	oe.y = curE->y();
	oe.xrel = curE->x() - preE->x();
	oe.yrel = curE->y() - preE->y();
}

void mapMouseWheelEvent(QWheelEvent* curE, QMouseEvent* preE, OgreBites::MouseWheelEvent& oe) 
{
	oe.type = SDL_MOUSEWHEEL;
	oe.timestamp = curE->timestamp();
	 
	oe.x = curE->x() - preE->x();
	oe.y = curE->y() - preE->y();

	oe.direction = SDL_MOUSEWHEEL_NORMAL;
}


void QTOgreWindow::mouseMoveEvent( QMouseEvent* e )
{
	OgreBites::MouseMotionEvent ogreE;
	mapMouseMotionEvent(e, &_lastMouseEvent, ogreE);
	if (m_cameraMan && (e->buttons() & Qt::LeftButton))
		m_cameraMan->mouseMoved(ogreE);
	_lastMouseEvent = *e;
}

void QTOgreWindow::wheelEvent(QWheelEvent *e)
{
	OgreBites::MouseWheelEvent ogreE;
	mapMouseWheelEvent(e, &_lastMouseEvent, ogreE);
	if (m_cameraMan)
		m_cameraMan->mouseWheelRolled(ogreE);
	//_lastMouseEvent = *e;
}

void QTOgreWindow::mousePressEvent( QMouseEvent* e )
{
	OgreBites::MouseButtonEvent ogreE;
	mapMouseBtnEvent(e, ogreE);
	ogreE.state = SDL_PRESSED;
	m_cameraMan->mousePressed(ogreE);
	_lastMouseEvent = *e;
}

void QTOgreWindow::mouseReleaseEvent( QMouseEvent* e )
{	
	OgreBites::MouseButtonEvent ogreE;
	mapMouseBtnEvent(e, ogreE);
	ogreE.state = SDL_RELEASED;
	m_cameraMan->mousePressed(ogreE);
	_lastMouseEvent = *e;
    return;
}

/*
Function to keep track of when we should and shouldn't redraw the window; we wouldn't want to do
rendering when the QWindow is minimized. This takes care of those scenarios.
*/
void QTOgreWindow::setAnimating(bool animating)
{
    m_animating = animating;

    if (animating)
        renderLater();
}

bool QTOgreWindow::frameRenderingQueued(const Ogre::FrameEvent& evt)
{
    //m_cameraMan->frameRenderingQueued(evt);
    return true;
}

void QTOgreWindow::log(Ogre::String msg)
{
    if(Ogre::LogManager::getSingletonPtr() != NULL) Ogre::LogManager::getSingletonPtr()->logMessage(msg);
}

void QTOgreWindow::log(QString msg)
{
}

void QTOgreWindow::setTargetSceneNode(Ogre::SceneNode *t)
{
    m_cameraMan->setTarget(t);
}

Ogre::SceneNode* QTOgreWindow::getTargetSceneNode()
{
    return m_cameraMan->getTarget();
}

const Ogre::SceneNode* QTOgreWindow::getTargetSceneNode()const
{
    return m_cameraMan->getTarget();
}
could anyone help me?
0 x

User avatar
dark_sylinc
OGRE Team Member
OGRE Team Member
Posts: 3849
Joined: Sat Jul 21, 2007 4:55 pm
Location: Buenos Aires, Argentina
x 150
Contact:

Re: scene graph always stay at left-bottom of ogreWindow

Post by dark_sylinc » Sat Feb 24, 2018 12:49 am

Try calling window->windowMovedOrResized() after your call to window->resize()
0 x

lainegates
Gnoblar
Posts: 9
Joined: Thu Jun 12, 2014 3:16 am

Re: scene graph always stay at left-bottom of ogreWindow

Post by lainegates » Sat Feb 24, 2018 12:53 am

Thank your very much for your fast reply.
And with your advice this problem is solved. :D
0 x

Post Reply