source: trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp @ 173

#include <OgreNoMemoryMacros.h>
#include <CEGUI/CEGUI.h>
#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
#include <OgreMemoryMacros.h>
#include "TerrainFrameListener.h"
#include "OgrePlatformQueryManager.h"
#include "OgreVisibilityTerrainSceneManager.h"
#include "VisibilityInfo.h"
#include "OgreOcclusionQueriesQueryManager.h"
#include "TestCullingTerrainApplication.h"


//-- captions for overlays
String TerrainFrameListener::msAlgorithmCaptions[] = 
{
        "View Frustum Culling", 
        "Stop and Wait Culling", 
        "Coherent Hierarchical Culling"
};

String TerrainFrameListener::msQueryTypeCaptions[] = 
{
        "from camera", 
        "from viewpoint"
};

String TerrainFrameListener::msQueryRelativeVisCaptions[] = 
{
        "visible pixels", 
        "relative visibility"
};

String TerrainFrameListener::msQueryMethodCaptions[] = 
{
        "occlusion queries", 
        "item buffer"
};

Real TerrainFrameListener::msObjectTerrainOffsets[] = 
{
        0,
        7,
        0
};

Real TerrainFrameListener::msObjectScales[] = 
{
        0.1,
        0.6,
        0.07
};

String TerrainFrameListener::msObjectCaptions[] =
{
        "robot",
        "athene",
        //"tree2",
        //"HongKong_Tower",
        "ninja"
        //"ogrehead"
};

// output file for frame info
const char* frames_out_filename = "frame.out";
// output file for object positions / orientations
const char* objects_out_filename = "objects.out";


//-----------------------------------------------------------------------
TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam, 
                                                                           SceneManager *sceneManager, 
                                                                           CEGUI::Renderer *renderer,
                                                                           TerrainContentGenerator *sceneGenerator,
                                                                           Camera *vizCamera,
                                                                           SceneNode *camNode,
                                                                           Light *sunLight,
                                                                           TestCullingTerrainApplication *app): 
mCamera(cam),
mWindow(win),
mNumScreenShots(0),
mTimeDelay(0),
mSceneDetailIndex(0),
mMoveScale(0.0f),
mRotScale(0.0f),
mTranslateVector(Vector3::ZERO),
mAniso(1),
mFiltering(TFO_BILINEAR), 
mGUIRenderer(renderer), 
mSceneMgr(sceneManager),
mCurrentObject(NULL),
mTerrainContentGenerator(sceneGenerator),
mVisibilityThreshold(0),
mAssumedVisibility(0),
mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
//mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING),
mNodeVizMode(NODEVIZ_NONE),
mVizCameraHeight(Real(2500.0)),
mCamNode(camNode),
mAppState(WALKTHROUGH),
mCurrentFrame(0),
mReplayTimeElapsed(0),
mRotateSpeed(72),
mMoveSpeed(50),
mVizCamera(vizCamera),
mStatsOn(true),
mShutdownRequested(false), 
mLMouseDown(false),
mRMouseDown(false),
mShowOctree(false),
mUseDepthPass(false),
mTestGeometryForVisibleLeaves(true),
mShowVisualization(false),
mCullCamera(false),
mRecord(false),
mShowShadows(false),
mShowHelp(false),
mDisplayCameraDetails(false),
mVisualizeCulledNodes(false),
mSunLight(sunLight),
mShiftPressed(false),
mShowQueryStats(false),
mQueryManager(NULL),
mVisibilityManager(NULL),
mDelayedQueriesIssued(0.0),
mDelayedTraversedNodes(0.0),
mUseItemBuffer(false),
mRenderPatchesForItemBuffer(false),
mCurrentObjectType(0),
mApplication(app),
mUseAnimation(false),
mDeleteObjects(false)
{
        //mInputDevice = PlatformManager::getSingleton().createInputReader();
        //mInputDevice->initialise(win, true, true);

        mEventProcessor = new EventProcessor();
        
        mEventProcessor->initialise(win);
        mEventProcessor->startProcessingEvents();
        mEventProcessor->addMouseListener(this);
        mEventProcessor->addMouseMotionListener(this);
        mEventProcessor->addKeyListener(this);

        mInputDevice = mEventProcessor->getInputReader();       

        // create ray query executor, used to place objects in terrain
        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
        
        //-- overlays
        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
        mHelpOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/HelpOverlay"); 
        mQueryOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/QueryOverlay"); 
        mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/CullStatsOverlay"); 

        initVisStatsOverlay(); // visibility stats overlay
        initHelpOverlay(); // help overlay
        initQueryOverlay(); // visibility query stats overlay

        // show stats overlays
        showStats(true);
        
        // set culling algorithm type
        setAlgorithm(mCurrentAlgorithm);

        // set scene manager options
        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);

        // apply delayed rendering (i.e., transparents after hierarchical culling pass)
        // only if optimization is not used 
        bool delayRenderTransparents = !mTestGeometryForVisibleLeaves;

        mSceneMgr->setOption("DelayRenderTransparents", &delayRenderTransparents);
        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
        
        mSceneMgr->setOption("ShowOctree", &mShowOctree);
        mSceneMgr->setOption("CullCamera", &mCullCamera);
        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization);

        setObjectType(mCurrentObjectType);

        // reset statistics
        resetStats();
} 
//-----------------------------------------------------------------------
TerrainFrameListener::~TerrainFrameListener()
{
        delete mRayQueryExecutor;
        delete mEventProcessor;

        if (mQueryManager)
        {
                delete mQueryManager;
                mQueryManager = NULL;
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::mouseMoved(MouseEvent *e)
{
        // Update CEGUI with the mouse motion
    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() * 
                mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
}
//-----------------------------------------------------------------------
void TerrainFrameListener::mousePressed(MouseEvent* e)
{
     // Left mouse button down
     if (e->getButtonID() & InputEvent::BUTTON0_MASK)
     {
                 CEGUI::MouseCursor::getSingleton().hide();

                 // Setup the ray scene query
         Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
                 
                 //Vector3 queryResult; mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay);
                 
                 Real val = Math::RangeRandom(0, 360); // random rotation

                 // get results, create a node/entity on the position
                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject(
                         mouseRay.getOrigin()/*queryResult*/, Vector3(val, 0, 0), 
                         msObjectCaptions[mCurrentObjectType]);
                
         mLMouseDown = true; 
     }
     // Right mouse button down
     else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
     {
         CEGUI::MouseCursor::getSingleton().hide();
         mRMouseDown = true;
     }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::mouseDragDropped(MouseEvent* e)
{
        // Left mouse button up
    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
    {
                CEGUI::MouseCursor::getSingleton().show();
                
            mLMouseDown = false;
    }
    // Right mouse button up
    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
    {
        CEGUI::MouseCursor::getSingleton().show();

                mRMouseDown = false;
    }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::mouseReleased(MouseEvent* e)
{
    // Left mouse button up
    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
    {
                CEGUI::MouseCursor::getSingleton().show();
                
                // start animation: only robot has animation phases
                if (mCurrentObject && (mCurrentObjectType == TestCullingTerrainApplication::ROBOT))
                {
                        // HACK: not neccesary the last element
                        Entity *ent = mTerrainContentGenerator->GetGeneratedEntities()->back();
                        EntityState *entState = new EntityState(ent, EntityState::MOVING, Math::RangeRandom(0.5, 1.5));
                        mApplication->getEntityStates().push_back(entState);
                }

            mLMouseDown = false;
    }
    // Right mouse button up
    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
    {
        CEGUI::MouseCursor::getSingleton().show(); 

        mRMouseDown = false;
    }
} 
//-----------------------------------------------------------------------
void TerrainFrameListener::mouseDragged(MouseEvent *e)
 {
         // If we are dragging the left mouse button.            
         if (mLMouseDown)
     {
                 if (!mCurrentObject)
                         return;

                 Vector3 queryResult;
                 Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());

                 if (mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay))
                 {
                         // apply offset so object is ON terrain
                         queryResult.y += msObjectTerrainOffsets[mCurrentObjectType];
                         mCurrentObject->setPosition(queryResult);
                 }
     }
         // If we are dragging the right mouse button.
         if (mRMouseDown)
         {
                 //mCamera->yaw(-e->getRelX() * mRotateSpeed);
                 //mCamera->pitch(-e->getRelY() * mRotateSpeed);
                 mCamNode->yaw(-e->getRelX() * mRotateSpeed);
                 mCamNode->pitch(-e->getRelY() * mRotateSpeed);
         }
}
//-----------------------------------------------------------------------
bool TerrainFrameListener::frameStarted(const FrameEvent &evt)
{
        if (mWindow->isClosed())
        {
        return false;
        }
        
        if (mDeleteObjects)
        {
                mApplication->deleteEntityStates();
                mTerrainContentGenerator->RemoveGeneratedObjects();
                mDeleteObjects = false;
        }

        if (mUseAnimation) // update animations
        {
                mApplication->updateAnimations(evt.timeSinceLastFrame);
        }

        if (mDisplayCameraDetails)  // Print camera details
    {       
        mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + 
                        " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
    }

        //-- setup what is needed for immediate mouse/key movement
        if (mTimeDelay >= 0) 
        {
                mTimeDelay -= evt.timeSinceLastFrame;
        }
        
        // If this is the first frame, pick a speed
        if (evt.timeSinceLastFrame == 0)
        {
                mMoveScale = 1;
                mRotScale = 0.1;
        }
        // Otherwise scale movement units by time passed since last frame
        else
        {
                // Move about 100 units per second,
                mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
                // Take about 10 seconds for full rotation
                mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
        }

        mRotX = 0;
        mRotY = 0;
        mTranslateVector = Vector3::ZERO;

        if (!processUnbufferedKeyInput(evt))
        {
                return false;
        }
/*      if (!processUnbufferedMouseInput(evt))
        {       return false;   }*/

        // --- set parameters for visualization
        if (mShowVisualization)
        {
                // important for visualization => draw octree bounding boxes
                mSceneMgr->setOption("ShowOctree", &mShowVisualization);
                
                // ---- setup visualization camera

                mVizCamera->setPosition(0, 0, 0);
                mVizCamera->setOrientation(Quaternion::IDENTITY);

                Vector3 camPos = mCamNode->getPosition();
                mVizCamera->setPosition(camPos.x, mVizCameraHeight, camPos.z);

                // point down -Z axis
                mVizCamera->pitch(Radian(Degree(270.0)));

                // rotation arounnd X axis
                mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x, 
                        -mCamera->getDerivedDirection().z));
                
                // move by a constant so view plane is on bottom of viewport
                mVizCamera->moveRelative(Vector3(0, 800, 0));
        }

        //-- set application state
        switch (mAppState)
        {
        case REPLAY:
                setCurrentFrameInfo(evt.timeSinceLastFrame);
                break;
        case WALKTHROUGH:
                //-- if we are recording camera status per frame
                if (mRecord)
                {
                        addFrameInfo(mCamNode, evt.timeSinceLastFrame);
                        // print recording message
                        mWindow->setDebugText("Recording frame " + 
                                StringConverter::toString(mFrameInfo.size() - 1));
                }       
                // move camera according to input
                moveCamera();

                // clamp camera so we always walk along the terrain
                mApplication->Clamp2Terrain(mCamNode, 10);
                break;

        default:
                break;
        };      

        return true;
}
//-----------------------------------------------------------------------
void TerrainFrameListener::applyVisibilityQuery(bool fromPoint, bool relativeVisibility, 
                                                                                                bool useItemBuffer)
{
        // TODO: change this (does not work with other scene manager plugins)
        VisibilityTerrainSceneManager *sm = 
                dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr);

        mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(),
                        mWindow->getViewport(0), true, useItemBuffer);
        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false);
        
        sm->GetVisibilityManager()->SetQueryManager(mQueryManager);

        InfoContainer<GtpVisibility::NodeInfo> visibleNodes;
        InfoContainer<GtpVisibility::MeshInfo> visibleGeometry;
        InfoContainer<GtpVisibility::PatchInfo> visiblePatches;


        if (fromPoint)
        {
                mQueryManager->
                        ComputeFromPointVisibility(mCamNode->getPosition(), &visibleNodes, 
                                                                           &visibleGeometry, &visiblePatches, relativeVisibility);
        }
        else
        {
                mQueryManager->ComputeCameraVisibility(*mCamera,
                            &visibleNodes, &visibleGeometry, &visiblePatches, relativeVisibility);
        }
                
        std::stringstream d; 
        d << msQueryTypeCaptions[fromPoint ?  1 : 0].c_str() << " "
          << msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " "
      << msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str();
        LogManager::getSingleton().logMessage(d.str());


        float averageNodeVis = 0, averageGeometryVis = 0, averagePatchVis = 0;
        int geomSize = 0, nodesSize = 0, patchSize = 0;

        InfoContainer<GtpVisibility::MeshInfo>::iterator geomIt, geomIt_end = visibleGeometry.end();

        for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt)
        {
                // add if not 0
                if ((*geomIt).GetVisiblePixels())
                {
                        float vis = relativeVisibility ? 
                                (*geomIt).ComputeRelativeVisibility() : (float)(*geomIt).GetVisiblePixels();
        
                        averageGeometryVis += vis;
                        ++ geomSize;
                        
                        std::stringstream d; 
                        d << "Geometry " << geomSize << " id: " << (*geomIt).GetMesh()->getSubEntity(0)->getId() 
                          << " visibility: "  << (*geomIt).GetVisiblePixels() << ", " << (*geomIt).GetProjectedPixels();
                        LogManager::getSingleton().logMessage(d.str());
                }
        }

        InfoContainer<GtpVisibility::NodeInfo>::iterator nodesIt, nodesIt_end = visibleNodes.end();

        for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt)
        {
                // add if not 0
                if ((*nodesIt).GetVisiblePixels())
                {
                        float vis = relativeVisibility ? 
                                (*nodesIt).ComputeRelativeVisibility() : (float)(*nodesIt).GetVisiblePixels();
                
                        averageNodeVis += vis;
                        ++ nodesSize;

                        std::stringstream d; d << "Node visibility: " << vis;
                        LogManager::getSingleton().logMessage(d.str());
                }       
        }

        InfoContainer<GtpVisibility::PatchInfo>::iterator patchIt, patchIt_end = visiblePatches.end();

        for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++ patchIt)
        {
                // add if not 0
                if ((*patchIt).GetVisiblePixels())
                {
                        float vis = relativeVisibility ? 
                                (*patchIt).ComputeRelativeVisibility() : (float)(*patchIt).GetVisiblePixels();
                
                        averagePatchVis += vis;
                        ++ patchSize;

                        std::stringstream d; d << "Patch visibility: " << vis;
                        LogManager::getSingleton().logMessage(d.str());
                }       
        }

        if (nodesSize)
                averageNodeVis /= (float)nodesSize;
        if (geomSize)
                averageGeometryVis /= (float)geomSize;
        if (patchSize)
                averagePatchVis /= (float)patchSize;

        //-- update visibility queries stats
    try 
        {
                char str[100];
                
                sprintf(str, ": %s, %s, %s", 
                                msQueryTypeCaptions[fromPoint ?  1 : 0].c_str(),
                                msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(),
                                msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str());

                mQueryTypeInfo->setCaption(str);

                sprintf(str, ": %d", (int)nodesSize); 
                mQueryVisibleNodesInfo->setCaption(str);
        
                sprintf(str,": %d", (int)geomSize); 
                mQueryVisibleGeometryInfo->setCaption(str);
                
                sprintf(str,": %d", (int)patchSize); 
                mQueryVisiblePatchInfo->setCaption(str);

                sprintf(str,": %3.3f", averageNodeVis); 
                mQueryNodeVisibilityInfo->setCaption(str);

                sprintf(str,": %3.3f", averageGeometryVis); 
                mQueryGeometryVisibilityInfo->setCaption(str);

                sprintf(str,": %3.3f", averagePatchVis); 
                mQueryPatchVisibilityInfo->setCaption(str);
        }
        catch (...)
        {
                // ignore
        }

        // show the results
        if (!mShowQueryStats && !mShowHelp)
        {
                mQueryOverlay->show();
                mShowQueryStats = true;
        }

        delete mQueryManager;
}

//-----------------------------------------------------------------------
bool TerrainFrameListener::frameEnded(const FrameEvent& evt)
{
        if (mShutdownRequested)
                return false;

    updateStats();

        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly
        mSceneMgr->endFrame();

        if (mTimeDelay <= 0) // approx. one second
                mTimeDelay = 1.0;

        return true;
}
//-----------------------------------------------------------------------
void TerrainFrameListener::moveCamera()
{
        // move node rather than camera so orientation is right in the visualization
        mCamNode->yaw(mRotX);
        mCamNode->pitch(mRotY);
        mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::writeFrames()
{
        std::ofstream ofstr(frames_out_filename);
        
        std::vector<frame_info>::const_iterator it, it_end;

        it_end = mFrameInfo.end();
        for (it = mFrameInfo.begin(); it < it_end; ++it)
        {
                ofstr << StringConverter::toString((*it).position) << " " 
                          << StringConverter::toString((*it).orientation) << " "
                          << StringConverter::toString((*it).timeElapsed) << "\n";
        }
        ofstr.close();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::loadFrames()
{
        std::ifstream ifstr(frames_out_filename);
        char line[256];
        frame_info info;

        // reset current values
        mFrameInfo.clear();
        mCurrentFrame = 0;
        
        while (!ifstr.eof()) 
        {
                ifstr.getline(line, 256);
                sscanf(line, "%f %f %f %f %f %f %f %f", &info.position.x, &info.position.y, &info.position.z,
                           &info.orientation.w, &info.orientation.x, &info.orientation.y, &info.orientation.z,
                           &info.timeElapsed);
                
                mFrameInfo.push_back(info);
                
                // std::stringstream d; d << StringConverter::toString(info.position) << " " << StringConverter::toString(info.orientation);
                // LogManager::getSingleton().logMessage(d.str());
        }
        ifstr.close();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::nextAppState()
{
        mCurrentFrame = 0;

        // if last state was replay state
        if (mAppState == REPLAY)
        {
                // reset debug text and write frame info to file
                mWindow->setDebugText("");
                writeFrames();
                
                float avgFps = (float)mAvgFps / (float)mFrameCount;

                //-- write out stats for recorded walkthrough
                std::stringstream d;
                d << "Algorithm: " << msAlgorithmCaptions[mCurrentAlgorithm] << "\n"
                  //<< "avg. FPS: " << mWindow->getAverageFPS() << "\n"
                  << "avg. FPS: " << avgFps << "\n"
                  << "best FPS: " << mWindow->getBestFPS() << "\n"
                  << "worst FPS: " << mWindow->getWorstFPS() << "\n"
                  << "best frame time: " <<     mWindow->getBestFrameTime() << "\n"
                  << "worst frame time: " << mWindow->getWorstFrameTime();
                
                LogManager::getSingleton().logMessage(d.str());
        }
        
        //-- set the next státe
        mAppState = (mAppState + 1) % STATE_NUM;

        // replay recorded walkthrough
        if (mAppState == REPLAY)
        {
                // no recording during replay
                mRecord = false;

                // load recorded walkthrough
                if (mFrameInfo.size() == 0)
                {
                        loadFrames();
                }

                // if there are no recorded frames => set next state
                if (mFrameInfo.size() == 0) 
                {
                        nextAppState();
                }
                else
                {
                        mWindow->setDebugText("Replay");
                        
                        // reset, because we measure fps stats during walkthrough (warning: average fps broken)
                        mWindow->resetStatistics();
                        resetStats();

                        //-- initialise frame data
                        mReplayTimeElapsed = 0;

                        mCamNode->setPosition(mFrameInfo[0].position);
                        mCamNode->setOrientation(mFrameInfo[0].orientation);
                }
        }

}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleRecord()
{
        mRecord = !mRecord;

        // clear previous camera path
        if (mRecord)
                mFrameInfo.clear();
        else
                mWindow->setDebugText("");
}
//-----------------------------------------------------------------------
void TerrainFrameListener::changeThreshold(int incr)
{
        mVisibilityThreshold += incr; 
        if(mVisibilityThreshold < 0) mVisibilityThreshold = 0;
        
        char str[100]; sprintf(str,": %d", mVisibilityThreshold);

        mSceneMgr->setOption("Threshold", &mVisibilityThreshold); 
        mThresholdInfo->setCaption(str);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::changeAssumedVisibility(int incr)
{
        mAssumedVisibility += incr; 
        if(mAssumedVisibility < 0) mAssumedVisibility = 0;
        
        char str[100]; sprintf(str,": %d", mAssumedVisibility);

        mSceneMgr->setOption("AssumedVisibility", &mAssumedVisibility); 
        mAssumedVisibilityInfo->setCaption(str);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::zoomVizCamera(int zoom)
{
        mVizCameraHeight += zoom; 
        if(mVizCameraHeight < 0) mVizCameraHeight = 0;
}
//-----------------------------------------------------------------------
void TerrainFrameListener::nextAlgorithm()
{
        mCurrentAlgorithm = (mCurrentAlgorithm + 1) % 
                GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS,

        setAlgorithm(mCurrentAlgorithm);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::setObjectType(int objectType)
{
        if (mCurrentObjectType >= 3)
                mCurrentObjectType = 0;

        // parameters for new object
        mTerrainContentGenerator->SetOffset(msObjectTerrainOffsets[mCurrentObjectType]);
        Real scale = msObjectScales[mCurrentObjectType];
        mTerrainContentGenerator->SetScale(Vector3(scale, scale, scale));

        mCurrentObjectTypeInfo->setCaption(": " + msObjectCaptions[mCurrentObjectType]);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::setAlgorithm(int algorithm)
{
        mAlgorithmInfo->setCaption(": " + msAlgorithmCaptions[mCurrentAlgorithm]);
        mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::resetStats()
{
        mAvgFps = 0;
        mFrameCount = 0;
}
//-----------------------------------------------------------------------
void TerrainFrameListener::updateStats()
{
        unsigned int opt = 0;
        char str[100];
        
        static String currFpsString = "Current FPS: ";
        static String avgFpsString = "Average FPS: ";
        static String bestFpsString = "Best FPS: ";
        static String worstFpsString = "Worst FPS: ";
        static String trisString = "Triangle Count: ";

        // HACK: compute average fps ourselfs, because ogre avg. fps is wrong
        // TODO: update only once per second
        mAvgFps += mWindow->getStatistics().lastFPS;
        ++ mFrameCount;
        
        float avgFps = (float)mAvgFps / (float)mFrameCount;
    
        // update stats when necessary
    try 
        {
                OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
                OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
                OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
                OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");

                const RenderTarget::FrameStats& stats = mWindow->getStatistics();

                //guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
                if (mTimeDelay < 0) // only update once per second
                {               
                        guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps) + " ms");
                }

                guiCurr->setCaption(currFpsString + StringConverter::toString(stats.lastFPS));
                guiBest->setCaption(bestFpsString + StringConverter::toString(stats.bestFPS)
                        +" "+StringConverter::toString(stats.bestFrameTime) + " ms");
                guiWorst->setCaption(worstFpsString + StringConverter::toString(stats.worstFPS)
                        +" "+StringConverter::toString(stats.worstFrameTime) + " ms");

                OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
        guiTris->setCaption(trisString + StringConverter::toString(stats.triangleCount));

                OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
                guiDbg->setCaption(mWindow->getDebugText());

                //-- culling stats
                mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt); 
                mFrustumCulledNodesInfo->setCaption(str);

                mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt); 
                mQueryCulledNodesInfo->setCaption(str);
        
                mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt); 
                mHierarchyNodesInfo->setCaption(str);

                mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt); 
                mRenderedNodesInfo->setCaption(str);

                sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount()); 
                mObjectsCountInfo->setCaption(str);

                // take old value into account in order to create no sudden changes
                mSceneMgr->getOption("NumQueriesIssued", &opt); 
                mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2;
                sprintf(str,": %d", (int)mDelayedQueriesIssued); 
                mQueriesIssuedInfo->setCaption(str);

                mSceneMgr->getOption("NumTraversedNodes", &opt); 
                mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2;
                sprintf(str,": %d", (int)mDelayedTraversedNodes); 
                mTraversedNodesInfo->setCaption(str);

        }
        catch (...)
        {
                // ignore
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleTestGeometryForVisibleLeaves()
{
        mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves;
        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);
        
        /* disable optimization which tests geometry instead of aabb
         * for "delayed" rendering of transparents (i.e., render transparents after all the solids)
         * because otherwise visible transparents could be skipped
         */
        bool delayedRendering = !mTestGeometryForVisibleLeaves;

        mSceneMgr->setOption("DelayRenderTransparents", &delayedRendering);

        if (mTestGeometryForVisibleLeaves)
        {
                mTestGeometryForVisibleLeavesInfo->setCaption(": true");
        }
        else
        {
                mTestGeometryForVisibleLeavesInfo->setCaption(": false");
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowOctree()
{
        mShowOctree = !mShowOctree;

        mSceneMgr->setOption("ShowOctree", &mShowOctree);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleUseDepthPass()
{
        mUseDepthPass = !mUseDepthPass;

        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
        
        if (mUseDepthPass)
        {
                mUseDepthPassInfo->setCaption(": true");
        }
        else
        {
                mUseDepthPassInfo->setCaption(": false");
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowViz()
{
        mVisualizeCulledNodes = mShowVisualization = !mShowVisualization;
        
        // create viewport with priority VIZ_VIEWPORT_Z_ORDER: 
        // will be rendered over standard viewport
        if (mShowVisualization)
        {       
                Viewport *vizvp = mWindow->addViewport(mVizCamera, 
                        VIZ_VIEWPORT_Z_ORDER, 0.6, 0.6, 0.4, 0.4); 
                                
                vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1));

                vizvp->setOverlaysEnabled(false);
                // Alter the camera aspect ratio to match the viewport
        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) / 
                                                                   Real(vizvp->getActualHeight()));
                
                mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes);
                //vizvp->setClearEveryFrame(false);

                // Create a skyplane (for visualization background)
                /*
                Plane plane;
                plane.d = -1000;
                plane.normal = Vector3::UNIT_Y;
                mSceneMgr->setSkyPlane(true, plane, "Examples/TransparentTest", 4000, 75, false);
                */
        }
        else
        {
                // remove visualization viewport
                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);

                // octree bounding boxes are shown for visualization purpose, reset now
                mSceneMgr->setOption("ShowOctree", &mShowOctree);
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowShadows()
{
        mShowShadows = !mShowShadows;

        mSunLight->setCastShadows(mShowShadows);

        if (mShowShadows)
        {
                mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE);
                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);           
        }
        else
        {
                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
        }

}
//-----------------------------------------------------------------------
void TerrainFrameListener::nextNodeVizMode()
{
        mNodeVizMode = (mNodeVizMode + 1) % NODEVIZ_MODES_NUM;

        bool renderNodesForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES) || 
                (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
        bool renderNodesContentForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
        //bool renderNodesContentForViz = mNodeVizMode == NODEVIZ_RENDER_GEOMETRY;

        mSceneMgr->setOption("RenderNodesForViz", &renderNodesForViz);
        mSceneMgr->setOption("RenderNodesContentForViz", &renderNodesContentForViz);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::keyPressed(KeyEvent* e)
{
        // hide exact visibility query overlay
        if (mShowQueryStats)
        {
                mQueryOverlay->hide();
                mShowQueryStats = false;
        }

        switch(e->getKey())
        {
        case KC_ESCAPE:
                mShutdownRequested = true;
                e->consume();
                return;

        case KC_SPACE:
                nextAlgorithm();
                break;
        
    case KC_F:
                nextFilter();
                break;
        case KC_R:
                nextSceneDetailLevel();
                break;
        case KC_P:
                toggleDisplayCameraDetails();
                break;
        case KC_G:
                toggleTestGeometryForVisibleLeaves();
                break;
        case KC_T:
                toggleShowOctree();
                break;
        case KC_X:
                toggleUseDepthPass();
                break;
        case KC_S:
                toggleShowShadows();
                break;

        case KC_I:
                mUseItemBuffer = !mUseItemBuffer;
                break;

        case KC_C:
                mRenderPatchesForItemBuffer = !mRenderPatchesForItemBuffer;
                break;

        case KC_SUBTRACT:
                changeThreshold(-10);
                break;
        case KC_ADD:
                changeThreshold(10);
                break;

        //-- visualization
        case KC_1:
                toggleShowViz();
                break;
        case KC_2:
                nextNodeVizMode();
                break;

        case KC_F1:
                toggleShowHelp();
                break;
        case KC_F2:
                toggleShowStats();
                break;
        case KC_F3:
                nextAppState();
                break;
        case KC_F4:
                toggleRecord();
                break;
        case KC_F5:
                applyVisibilityQuery(false, mShiftPressed, mUseItemBuffer);
                break;
        case KC_F6:
                applyVisibilityQuery(true, mShiftPressed, mUseItemBuffer);
                break;
        
        case KC_F7:
                setObjectType(++mCurrentObjectType);
                break;
        case KC_F8:
                mApplication->generateScene(500, mCurrentObjectType);
                break;
        case KC_F9:
                mUseAnimation = !mUseAnimation;
                break;
        case KC_F11:
                takeScreenshot();
                break;
        case KC_F12:
                mTerrainContentGenerator->WriteObjects(objects_out_filename);
                break;

        case KC_8:
                changeAssumedVisibility(-1);
                break;
        case KC_9:
                changeAssumedVisibility(1);
                break;
        case KC_LSHIFT:
                mShiftPressed = true;
                break;
        case KC_DELETE:
                mDeleteObjects = true;
                break;
        //KEY_PRESSED(KC_F3, 0.3, writeFrames());
        //KEY_PRESSED(KC_F4, 0.3, loadFrames());
        default:
                break;
        }

        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
        CEGUI::System::getSingleton().injectChar(e->getKeyChar());
        e->consume();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::keyReleased(KeyEvent* e)
{
        if (e->getKey() == KC_LSHIFT)
        {
                mShiftPressed = false;
        }
        
        CEGUI::System::getSingleton().injectKeyUp(e->getKey());
        e->consume();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::keyClicked(KeyEvent* e) 
{
        // Do nothing
        e->consume();
}
//-----------------------------------------------------------------------
void TerrainFrameListener::addFrameInfo(SceneNode *camNode, Real timeElapsed)
{
        frame_info info;
        info.orientation = mCamNode->getOrientation();
        info.position = mCamNode->getPosition();
        info.timeElapsed = timeElapsed;

        mFrameInfo.push_back(info);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::setCurrentFrameInfo(Real timeElapsed)
{
        //-- find current frame relative to elapsed frame time          
        mReplayTimeElapsed -= timeElapsed;

        while ((mReplayTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1))
        {
                mReplayTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed;
        }

        frame_info new_frame = mFrameInfo[mCurrentFrame];
        frame_info old_frame = mFrameInfo[mCurrentFrame - 1];
                
        //-- interpolate frames
        Real factor = 1;

        if (old_frame.timeElapsed > 0)
        {
                factor = mReplayTimeElapsed / old_frame.timeElapsed;
        }

        Vector3 camPos = old_frame.position + factor 
                * (new_frame.position - old_frame.position);
        Quaternion camOrienation = Quaternion::Slerp(factor, old_frame.orientation, 
                new_frame.orientation, true);

        mCamNode->setPosition(camPos);
        mCamNode->setOrientation(camOrienation);
        
        // stop replay after a full walkthrough
        if (mCurrentFrame == (int)mFrameInfo.size() - 1)
        {
                nextAppState();
        }
}
//-----------------------------------------------------------------------    
bool TerrainFrameListener::processUnbufferedKeyInput(const FrameEvent& evt)
{
        bool cursorPressed = false;
        
        /* Move camera forward by keypress. */
    if (mInputDevice->isKeyDown(KC_UP))
        {
                mTranslateVector.z = -mMoveScale;
                cursorPressed = true;
        }
    /* Move camera backward by keypress. */
    if (mInputDevice->isKeyDown(KC_DOWN))
    {
                mTranslateVector.z = mMoveScale;
                cursorPressed = true;
    }

    if (mInputDevice->isKeyDown(KC_RIGHT))
    {
        mCamNode->yaw(-mRotScale);
                cursorPressed = true;
    }
        
    if (mInputDevice->isKeyDown(KC_LEFT))
    {
        mCamNode->yaw(mRotScale);
                cursorPressed = true;
    }
        // visualization camera
        if (mInputDevice->isKeyDown(KC_3))
        {
                zoomVizCamera(50);
        }
        if (mInputDevice->isKeyDown(KC_4))
        {
                zoomVizCamera(-50);
        }

        // show the results
        if (cursorPressed && mShowQueryStats)
        {
                mQueryOverlay->hide();
                mShowQueryStats = false;
        }

    // Return true to continue rendering
    return true;
}
//-----------------------------------------------------------------------
void TerrainFrameListener::nextFilter()
{
        switch (mFiltering)
        {
        case TFO_BILINEAR:
                mFiltering = TFO_TRILINEAR;
                mAniso = 1;
                break;
        case TFO_TRILINEAR:
                mFiltering = TFO_ANISOTROPIC;
                mAniso = 8;
                break;
        case TFO_ANISOTROPIC:
                mFiltering = TFO_BILINEAR;
                mAniso = 1;
                break;
        default:
                break;
        }

    MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
    MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);

        // reload stats
    showStats(mStatsOn);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::nextSceneDetailLevel()
{
        mSceneDetailIndex = (mSceneDetailIndex + 1) % 3;
        switch (mSceneDetailIndex) 
        {
                case 0: 
                        mCamera->setDetailLevel(SDL_SOLID); 
                        break;
                case 1: 
                        mCamera->setDetailLevel(SDL_WIREFRAME); 
                        break;
                case 2: 
                        mCamera->setDetailLevel(SDL_POINTS); 
                        break;
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::takeScreenshot()
{
        char tmp[20];
        sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
    mWindow->writeContentsToFile(tmp);
    mWindow->setDebugText(String("Wrote ") + tmp);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleDisplayCameraDetails()
{
        mDisplayCameraDetails = !mDisplayCameraDetails;
        
    if (!mDisplayCameraDetails)
        {
                mWindow->setDebugText("");
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::showStats(bool show)
{
        if (mDebugOverlay && mCullStatsOverlay)
        {
                if (show)
                {
                        mDebugOverlay->show();
                        mCullStatsOverlay->show();
                }
                else
                {
                        mDebugOverlay->hide();
                        mCullStatsOverlay->hide();
                }
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowStats()
{
        mStatsOn = !mStatsOn;

        showStats(mStatsOn);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::toggleShowHelp()
{
        mShowHelp = !mShowHelp;

        if (mShowHelp)
        {
                mHelpOverlay->show();
        }
        else
        {
                mHelpOverlay->hide();
        }
}
//-----------------------------------------------------------------------
void TerrainFrameListener::initOverlayElement(OverlayElement **elInfo, String ext, 
                                                                                          String name, int top, String caption)
{
        OverlayElement *el = 
                OverlayManager::getSingleton().getOverlayElement(ext + name);

        (*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
        (*elInfo)->setCaption(caption);

        el->setTop(top);
        (*elInfo)->setTop(top);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::initHelpOverlayElement(String name, int top)
{
        OverlayElement *el = OverlayManager::getSingleton().getOverlayElement(
                "Example/Visibility/Help/" + name);

        el->setTop(top);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::initHelpOverlay()
{
        const int vert_space = 15;
        int top = 30;

        initHelpOverlayElement("ShowHelp", top); top += vert_space;
        initHelpOverlayElement("Stats", top); top += vert_space;
        initHelpOverlayElement("AppState", top); top += vert_space;
        initHelpOverlayElement("Recorded", top); top += vert_space;
        initHelpOverlayElement("Animation", top); top += vert_space;
        initHelpOverlayElement("Screenshots", top); top += vert_space;
        initHelpOverlayElement("WriteOut", top); top += vert_space;

        top +=vert_space;
        initHelpOverlayElement("SceneDetail", top); top += vert_space;
        initHelpOverlayElement("DisplayCameraDetails", top); top += vert_space;
        initHelpOverlayElement("DisplayOctree", top); top += vert_space;
        initHelpOverlayElement("UseShadows", top); top += vert_space;
        initHelpOverlayElement("Filter", top); top += vert_space;

        //-- visualization
        top += vert_space;
        initHelpOverlayElement("VizSection", top); top += vert_space;
        initHelpOverlayElement("Viz", top); top += vert_space;
        initHelpOverlayElement("NextVizMode", top); top += vert_space;
        initHelpOverlayElement("ZoomViz", top); top += vert_space;


        //-- visibility queries
        top += vert_space;
        initHelpOverlayElement("VisQuery", top); top += vert_space;
        initHelpOverlayElement("FromCameraQuery", top); top += vert_space;
        initHelpOverlayElement("FromPointQuery", top); top += vert_space;
        initHelpOverlayElement("QueryType", top); top += vert_space;
        initHelpOverlayElement("QueryTarget", top); top += vert_space;

        //-- object generation
        top += vert_space;
        initHelpOverlayElement("SceneObjects", top); top += vert_space;
        initHelpOverlayElement("GenerateObjects", top); top += vert_space;
        initHelpOverlayElement("RemoveObjects", top); top += vert_space;
        initHelpOverlayElement("DropObject", top); top += vert_space;

        OverlayElement *helpPanel = OverlayManager::getSingleton().getOverlayElement(
                "Example/Visibility/Help/HelpPanel");

        helpPanel->setHeight(top + 10);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::initVisStatsOverlay()
{
        const int border_height = 10;
        const int vert_space = 15;

        //-- visibility culling stats overlay
        int top = border_height;

        String ext = "Example/Visibility/";
        
        initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top,
                ": " + msAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space;

        initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space;
        initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext, 
                "TestGeometryForVisibleLeaves", top, ": true"); top += vert_space;
        initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space;
        initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space;
        initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space;
        //initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space;

        OverlayElement *optionsPanel = OverlayManager::getSingleton().
                getOverlayElement("Example/Visibility/VisibilityPanel");

        optionsPanel->setHeight(top + border_height);

        top = border_height;
        //ext = "Example/Visibility/";
        initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
        initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
        initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
        initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
        initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
        initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
        initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;

        OverlayElement *visPanel = OverlayManager::getSingleton().
                getOverlayElement("Example/Visibility/VisibilityStatsPanel");

        visPanel->setHeight(top + border_height);
}
//-----------------------------------------------------------------------
void TerrainFrameListener::initQueryOverlay()
{
        const int border_height = 10;
        const int vert_space = 15;

        //-- visibility culling stats overlay
        int top = border_height + 25;

        String ext = "Example/Visibility/Query/";
            
        initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top,     ": 0"); top += vert_space;
        
        initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,  ": 0"); top += vert_space;
        initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top,    ": 0"); top += vert_space;
        initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top,        ": 0"); top += vert_space;
        
        initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top,      ": 0"); top += vert_space;
        initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top,      ": 0"); top += vert_space;
        initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top,    ": 0"); top += vert_space;


        OverlayElement *queryPanel = OverlayManager::getSingleton().
                getOverlayElement("Example/Visibility/Query/QueryPanel");

        queryPanel->setHeight(top + border_height);
}