Noesis Ogre OpenGL example source

/*
 * File:   NoesisManager.cpp
 * Author: TheSHEEEP
 *
 * Created on 6. August 2013, 16:02
 */

#include "NoesisManager.h"
#include "application/PrototypeApp.h"
#include "gui/MouseCursor.h"
#include "gui/OgreNsGuiFileSystem.h"
#include "util/MemoryLog.h"
#include "util/OgreConsole.h"
#include "scripting/ScriptHostMain.h"
#include "OISMouse.h"

#ifdef __MINGW32__
    // On Windows, using the Ogre glew header version is enough
    #include <GL/glew.h>
#elif __linux__
    // Linux needs a bit more included and defined
    #define GL_GLEXT_PROTOTYPES
    #include <GL/gl.h>
    #include <GL/glx.h>
    #include <gui/glext.h>
#endif

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glext.h>

#include <boost/lexical_cast.hpp>

#include <OgreSceneManager.h>
#include <OgreRoot.h>

#include <Noesis.h>
#include <NsCore/Error.h>
#include <NsCore/Kernel.h>
#include <NsCore/NsSystem.h>
#include <NsResource/IResourceSystem.h>
#include <NsRender/IRenderSystem.h>
#include <NsRender/StateObjects.h>
#include <NsGui/UIElement.h>
#include <NsGui/Button.h>
#include <NsGui/TextBlock.h>
#include <NsGui/Image.h>
#include <NsGui/ImageSource.h>

MemoryLog* NoesisManager::_logger = 0;

EXPORT_OOLUA_FUNCTIONS_NON_CONST(NoesisManager, bindFunctionToButtonClick, setJumping)
EXPORT_OOLUA_FUNCTIONS_CONST(NoesisManager)

//--------------------------------------------------------------------------------------------------
NoesisManager::NoesisManager()
    : _sceneMgr(0)
    , _root(0)
    , _width(0)
    , _height(0)
    , _callbackRegistry(0)
{
}

//--------------------------------------------------------------------------------------------------
NoesisManager::~NoesisManager()
{
}

//--------------------------------------------------------------------------------------------------
bool
NoesisManager::setup(Ogre::SceneManager* p_sceneMgr, Ogre::Root* p_root, MemoryLog* p_logger, OIS::Mouse* p_mouse,
                     int p_width, int p_height)
{
    _sceneMgr = p_sceneMgr;
    _root = p_root;
    _mouse = p_mouse;
    p_mouse->setEventCallback(this);

    _root->getRenderSystem()->addListener(this);

    if (_sceneMgr)
    {
        _sceneMgr->addRenderQueueListener(this);
    }

    // Get required Ogre pointers
    _logger = p_logger;

    // Init Noesis kernel
    Noesis::Core::SetErrorHandler(handleNoesisError);
    NsGetKernel()->Init();

    // Register own classes
    // NsRegisterReflection(NsGetKernel()->GetComponentFactory(), true);

    // Register file system and add folders
    _ogreFileSystem = new Noesis::Gui::OgreNsGuiFileSystem();
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../assets/gui", "FileSystem", "Gui");
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../assets/gui/Drawing/VGL", "FileSystem", "Gui");
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../assets/gui/Gui/Core", "FileSystem", "Gui");
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../assets/gui/Gui/Themes", "FileSystem", "Gui");
    Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../assets/gui/Survivor/Test", "FileSystem", "Gui");
    Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Gui");
    Noesis::Resource::IResourceSystem::SetFileSystem(_ogreFileSystem);

    // Init systems
    NsGetKernel()->InitSystems();

    // Load our own xaml file
    _xamlRoot =
            Noesis::Gui::LoadXaml<Noesis::Gui::FrameworkElement>("Survivor/Test/TestWindow.xaml");

    // Create noesis renderer
    _noesisGLRenderer = Noesis::Gui::CreateRenderer(_xamlRoot.GetPtr());
    _noesisGLRenderer->SetAntialiasingMode(Noesis::Gui::AntialiasingMode_PPAA);
    _noesisGLRenderer->SetSize(p_width, p_height);

    // Create callback registry
    _callbackRegistry = new DynamicCallbackRegistry();
    _callbackRegistry->setup();

    _width = p_width;
    _height = p_height;

    // Create mouse cursor
    _mouseCursor = new MouseCursor();
    _mouseCursor->setImage("mouseCursor.png");
    _mouseCursor->setVisible(true);
    _mouseCursor->setWindowDimensions(_width, _height);

    return true;
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::shutdown()
{
    _root->getRenderSystem()->removeListener(this);

    if (_sceneMgr)
    {
        _sceneMgr->removeRenderQueueListener(this);
    }

    _renderCommands.commands.Reset();
    _renderCommands.offscreenCommands.Reset();

    _noesisGLRenderer.Reset();

    _xamlRoot.Reset();
    NsGetKernel()->Shutdown();
}

//--------------------------------------------------------------------------------------------------
bool
NoesisManager::mouseMoved(const OIS::MouseEvent& p_mouseEvent)
{
    _mouseCursor->updatePosition(p_mouseEvent.state.X.abs, p_mouseEvent.state.Y.abs);
    _noesisGLRenderer->MouseMove(p_mouseEvent.state.X.abs, p_mouseEvent.state.Y.abs);

    return true;
}

//--------------------------------------------------------------------------------------------------
bool
NoesisManager::mousePressed(const OIS::MouseEvent& p_mouseEvent, OIS::MouseButtonID p_id)
{
    switch (p_id)
    {
        case OIS::MB_Left:
            _noesisGLRenderer->MouseButtonDown(p_mouseEvent.state.X.abs, p_mouseEvent.state.Y.abs,
                    Noesis::Gui::MouseButton_Left);
            break;

        case OIS::MB_Right:
            _noesisGLRenderer->MouseButtonDown(p_mouseEvent.state.X.abs, p_mouseEvent.state.Y.abs,
                    Noesis::Gui::MouseButton_Right);
            break;

        default:
            break;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
bool
NoesisManager::mouseReleased(const OIS::MouseEvent& p_mouseEvent, OIS::MouseButtonID p_id)
{
    switch (p_id)
    {
        case OIS::MB_Left:
            _noesisGLRenderer->MouseButtonUp(p_mouseEvent.state.X.abs, p_mouseEvent.state.Y.abs,
                    Noesis::Gui::MouseButton_Left);
            break;

        case OIS::MB_Right:
            _noesisGLRenderer->MouseButtonUp(p_mouseEvent.state.X.abs, p_mouseEvent.state.Y.abs,
                    Noesis::Gui::MouseButton_Right);
            break;

        default:
            break;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::handleNoesisError(const NsChar* p_filename, NsInt p_line, const NsChar* p_desc)
{
    std::string message = "Noesis Error: File: ";
    message.append(p_filename);
    message.append(" Line: ");
    message.append(boost::lexical_cast<std::string>(p_line));
    message.append("\n Description: ");
    message.append(p_desc);
    _logger->logMessageCritical(message);
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::renderQueueStarted(Ogre::uint8 p_queueGroupId,
                                    const Ogre::String& p_invocation, bool& p_skipThisInvocation)
{
    // We're going to render ourselves in the Overlay Queue so we're always on top
    if(p_queueGroupId == Ogre::RENDER_QUEUE_OVERLAY)
    {
        doPostSceneStep();

        restoreRenderStates();
    }
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::doPreSceneStep(const double& p_timeSinceLastFrame)
{
    // Tick
    NsGetKernel()->Tick();

    static double time = 0.0;
    time += p_timeSinceLastFrame;

    // Update with time and wait for update to finish
    // TODO: We should have time since last frame stored somewhere globally accessible
    _noesisGLRenderer->Update(time);
    // TODO: We could do something useful here
    _renderCommands = _noesisGLRenderer->WaitForUpdate();

    // Do the offscreen rendering
    _noesisGLRenderer->Render(_renderCommands.offscreenCommands.GetPtr());

    restoreRenderStates();
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::doPostSceneStep()
{
    storeCurrentRenderStates();

    // Do the onscreen rendering
    _noesisGLRenderer->Render(_renderCommands.commands.GetPtr());
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::storeCurrentRenderStates()
{
    // Matrices
//    glMatrixMode(GL_MODELVIEW);
//    glPushMatrix();
//    glMatrixMode(GL_PROJECTION);
//    glPushMatrix();
//    glMatrixMode(GL_TEXTURE);
//    glPushMatrix();
//    glLoadIdentity(); //Texture addressing should start out as direct.

    // Render states
    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &_rsStorage.frameBuffer);

    glGetFloatv(GL_COLOR_CLEAR_VALUE, _rsStorage.clearColors);
    glGetFloatv(GL_DEPTH_CLEAR_VALUE, &_rsStorage.clearDepth);

    glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &_rsStorage.clearStencil);
    _rsStorage.depthTest = glIsEnabled(GL_DEPTH_TEST);
    glGetBooleanv(GL_DEPTH_WRITEMASK, &_rsStorage.depthWrite);
    glGetIntegerv(GL_DEPTH_FUNC, &_rsStorage.depthFunc);

    _rsStorage.stencilTest = glIsEnabled(GL_STENCIL_TEST);
    glGetIntegerv(GL_STENCIL_FAIL, &_rsStorage.stencilTestFailOp);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &_rsStorage.stencilTestSPDF);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &_rsStorage.stencilTestSPDP);
    glGetIntegerv(GL_STENCIL_FUNC, &_rsStorage.stencilFunc);
    glGetIntegerv(GL_STENCIL_REF, &_rsStorage.stencilRef);
    glGetIntegerv(GL_STENCIL_VALUE_MASK, (int*)&_rsStorage.stencilMask);
    glGetIntegerv(GL_STENCIL_WRITEMASK, (int*)&_rsStorage.stencilWriteMask);

    _rsStorage.scissorTest = glIsEnabled(GL_SCISSOR_TEST);
    _rsStorage.cullFaceEnabled = glIsEnabled(GL_CULL_FACE);
    glGetIntegerv(GL_CULL_FACE_MODE, &_rsStorage.cullFaceMode);

    _rsStorage.blendEnabled = glIsEnabled(GL_BLEND);
    glGetIntegerv(GL_BLEND_EQUATION_RGB, &_rsStorage.blendEquationRGB);
    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &_rsStorage.blendEquationA);
    glGetIntegerv(GL_BLEND_SRC_RGB, &_rsStorage.blendSource);
    glGetIntegerv(GL_BLEND_DST_RGB, &_rsStorage.blendDestination);

    glGetBooleanv(GL_COLOR_WRITEMASK, _rsStorage.colorWriteMask);

//    glPushAttrib(GL_ALL_ATTRIB_BITS);

    // Buffers
    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (int*)&_rsStorage.arrayBuffer);
    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (int*)&_rsStorage.maxVertexAttribs);
    for (NsSize i = 0; i < _rsStorage.maxVertexAttribs; i++)
    {
        glGetVertexAttribiv(i, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &(_rsStorage.vertexAttribsEnabled[i]));
    }

    glGetIntegerv(GL_ACTIVE_TEXTURE, &_rsStorage.activeTexture);

    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, (int*)&_rsStorage.elementArrayBuffer);
    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, (int*)&_rsStorage.maxTextureUnits);
    for (NsSize i = 0; i < 4; i++)
    {
        glActiveTexture(GL_TEXTURE0 + i);
        glGetIntegerv(GL_TEXTURE_BINDING_2D, &(_rsStorage.boundTexture[i]));
    }

    glGetIntegerv(GL_CURRENT_PROGRAM, &_rsStorage.currentProgram);
    glGetIntegerv(GL_UNPACK_ALIGNMENT, &_rsStorage.unpackAlignment);

    _rsStorage.hasState = true;
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::restoreRenderStates()
{
    if (!_rsStorage.hasState)
        return;

    glPixelStorei(GL_UNPACK_ALIGNMENT, _rsStorage.unpackAlignment);
    glUseProgram(_rsStorage.currentProgram);

    // Buffers
    glBindBuffer(GL_ARRAY_BUFFER, _rsStorage.arrayBuffer);
    for (NsSize i = 0; i < _rsStorage.maxVertexAttribs; i++)
    {
        _rsStorage.vertexAttribsEnabled[i] ? glEnableVertexAttribArray(i) : glDisableVertexAttribArray(i);
    }
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _rsStorage.elementArrayBuffer);
    for (NsSize i = 0; i < 4; i++)
    {
        glActiveTexture(GL_TEXTURE0 + i);
        glBindTexture(GL_TEXTURE_2D, _rsStorage.boundTexture[i]);
    }

    glActiveTexture(_rsStorage.activeTexture);

    //Render states
    glClearColor(_rsStorage.clearColors[0], _rsStorage.clearColors[1], _rsStorage.clearColors[2],
            _rsStorage.clearColors[3]);
    glClearDepth(_rsStorage.clearDepth);
    glClearStencil(_rsStorage.clearStencil);

    _rsStorage.depthTest ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
    glDepthMask(_rsStorage.depthWrite);
    glDepthFunc(_rsStorage.depthFunc);

    _rsStorage.stencilTest ? glEnable(GL_STENCIL_TEST) : glDisable(GL_STENCIL_TEST);
    glStencilOp(_rsStorage.stencilTestFailOp, _rsStorage.stencilTestSPDF, _rsStorage.stencilTestSPDP);
    glStencilFunc(_rsStorage.stencilFunc, _rsStorage.stencilRef, _rsStorage.stencilMask);
    glStencilMask(_rsStorage.stencilWriteMask);

    _rsStorage.scissorTest ? glEnable(GL_SCISSOR_TEST) : glDisable(GL_SCISSOR_TEST);
    _rsStorage.cullFaceEnabled ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE);
    glCullFace(_rsStorage.cullFaceMode);

    _rsStorage.blendEnabled ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
    glBlendEquationSeparate(_rsStorage.blendEquationRGB, _rsStorage.blendEquationA);
    glBlendFunc(_rsStorage.blendSource, _rsStorage.blendDestination);

    glColorMask(_rsStorage.colorWriteMask[0], _rsStorage.colorWriteMask[1], _rsStorage.colorWriteMask[2],
            _rsStorage.colorWriteMask[3]);

//    glPopAttrib();

    // Restore matrices
//    glMatrixMode(GL_TEXTURE);
//    glPopMatrix();
//    glMatrixMode(GL_PROJECTION);
//    glPopMatrix();
//    glMatrixMode(GL_MODELVIEW);
//    glPopMatrix();

    // Restore frame buffer and viewport
    glBindFramebuffer(GL_FRAMEBUFFER, _rsStorage.frameBuffer);
    glViewport(0, 0, _width, _height);
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::bindFunctionToButtonClick(std::string p_buttonName, OOLUA::Lua_func_ref p_luaFunc)
{
    // Check if there is a button with that name
    Noesis::Gui::Button* button = (Noesis::Gui::Button*)_xamlRoot->FindName(p_buttonName.c_str());
    if (button == 0)
    {
        CONSOLE_LOG("Button named \"" + p_buttonName + "\" doesn't exist.");
        return;
    }

    // Add dynamic type and register Callback at script host
    _callbackRegistry->addDynamicType(p_buttonName);
    PrototypeApp::Singleton->getScriptHost()
            ->registerCallbackExternalDynamic(p_buttonName, p_luaFunc, _callbackRegistry);

    // FIXME: prevent double delegate adding, or does Noesis do that automatically?
    button->Click() += Noesis::Core::MakeDelegate(this, &NoesisManager::handleButtonClick);
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::setJumping(bool p_isJumping)
{
    Noesis::Gui::TextBlock* status = (Noesis::Gui::TextBlock*)_xamlRoot->FindName("txtStatus");
    Noesis::Gui::Image* imageNorm = (Noesis::Gui::Image*)_xamlRoot->FindName("imgNorm");
    Noesis::Gui::Image* imageJump = (Noesis::Gui::Image*)_xamlRoot->FindName("imgJump");

    if (p_isJumping)
    {
        imageNorm->SetVisibility(Noesis::Gui::Visibility_Collapsed);
        imageJump->SetVisibility(Noesis::Gui::Visibility_Visible);
        status->SetText("Wheeeeee!!!");
    }
    else
    {
        imageJump->SetVisibility(Noesis::Gui::Visibility_Collapsed);
        imageNorm->SetVisibility(Noesis::Gui::Visibility_Visible);
        status->SetText("I am OK!");
    }
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::handleButtonClick(Noesis::Core::BaseComponent* p_baseComp, const Noesis::Gui::RoutedEventArgs& p_args)
{
    Noesis::Gui::Button* button = (Noesis::Gui::Button*)p_baseComp;

    PrototypeApp::Singleton->getScriptHost()
            ->triggerCallbackExternalDynamic(button->GetName().c_str(), _callbackRegistry);
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::eventOccurred(const Ogre::String& p_eventName, const Ogre::NameValuePairList* p_parameters)
{
    if (p_eventName == "DeviceLost")
    {
        deviceLostCallback();
    }
    else if(p_eventName == "DeviceRestored")
    {
        deviceResetCallback();
    }
}

//--------------------------------------------------------------------------------------------------
void
NoesisManager::deviceLostCallback()
{
//    NsGetSystem<Noesis::Render::IRenderSystem>()->OnLostDevice();
}


//--------------------------------------------------------------------------------------------------
void
NoesisManager::deviceResetCallback()
{
//     NsGetSystem<Noesis::Render::IRenderSystem>()->OnResetDevice();
}