Window.cpp

Go to the documentation of this file.

#include "Application.hpp"

void glfwOnWindowSizeChanged(GLFWwindow * window, int width, int height);
void glfwOnCursorMove(GLFWwindow * window, double x, double y);
void glfwOnKeyStateChanged(GLFWwindow * window, int key, int scancode, int action, int mods);
void glfwOnError(int errorCode, const char* desc)
{
    cerr << "ERROR: (GLFW) " << desc << endl;
}



void reportOpenGlCaps()
{
    set<string> extensions;
    int nExtensions;
    glGetIntegerv(GL_NUM_EXTENSIONS, &nExtensions);
    for (int i = 0; i < nExtensions; i++)
        extensions.insert(reinterpret_cast<char const *>(glGetStringi(GL_EXTENSIONS, i)));


    cout << endl;
    cout << "OpenGL Caps:" << endl;
    cout << "  GL Version:   " << glGetString(GL_VERSION) << endl;
    cout << "  Vendor:       " << glGetString(GL_VENDOR) << endl;
    cout << "  Renderer:     " << glGetString(GL_RENDERER) << endl;
    cout << "  GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << endl;
    cout << "  Extensions:" << endl;
    for (auto& extension : extensions)
        cout << "    " << extension << endl;

    cout << endl;
}

void APIENTRY debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, GLvoid* userParam)
{
    stringstream ss;

    ss << "Source:";
    if(source == GL_DEBUG_SOURCE_API_ARB)                       ss << "OpenGL";
    else if(source == GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB)        ss << "Windows";
    else if(source == GL_DEBUG_SOURCE_SHADER_COMPILER_ARB)      ss << "Shader Compiler";
    else if(source == GL_DEBUG_SOURCE_THIRD_PARTY_ARB)          ss << "Third Party";
    else if(source == GL_DEBUG_SOURCE_APPLICATION_ARB)          ss << "Application";
    else if(source == GL_DEBUG_SOURCE_OTHER_ARB)                ss << "Other";
    else                                                        ss << "Unknown";
    string sourceStr = ss.str();

    ss.str(string());
    ss << "Type:";
    if(source == GL_DEBUG_TYPE_ERROR_ARB)                       ss << "Error";
    else if(source == GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB)    ss << "Deprecated behavior";
    else if(source == GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB)     ss << "Undefined behavior";
    else if(source == GL_DEBUG_TYPE_PORTABILITY_ARB)            ss << "Portability";
    else if(source == GL_DEBUG_TYPE_PERFORMANCE_ARB)            ss << "Performance";
    else if(source == GL_DEBUG_TYPE_OTHER_ARB)                  ss << "Other";
    else                                                        ss << "Unknown"; 
    string typeStr = ss.str();

    ss.str(string()); 
    ss << "Severity:";
    if(source == GL_DEBUG_SEVERITY_HIGH_ARB)                    ss << "High";
    else if(source == GL_DEBUG_SEVERITY_MEDIUM_ARB)             ss << "Medium";
    else if(source == GL_DEBUG_SEVERITY_LOW_ARB)                ss << "Low";
    else                                                        ss << "Unknown"; 
    string severityStr = ss.str();

    ss.str(string()); 
    ss << "ID:";  
    ss << id; 
    string idStr = ss.str();    
     
    ss.str(string()); 
    ss << "Message:";  
    ss << message;  
    string msgStr = ss.str();    
        
      
    ss.str(string());
    cerr << "ERROR: An OpenGL error occurred(" << sourceStr << ";" << typeStr << ";" << severityStr << ";" << idStr << ";" << msgStr << ")" << endl;
}


Window::Window(Application* app)
    : m_app(app)
    , m_window(nullptr)
    , m_size(m_app->getConfig().resolution())
    , m_cursorInit(false)
    , m_hasProjChanged(2,true)
{

    if (!glfwInit())
    {
        cerr << "ERROR: Failed to init GLFW." << endl;
        exit(EXIT_FAILURE);
    }

    glfwSetErrorCallback(glfwOnError);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef _DEBUG
    glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif

    GLFWmonitor* monitor = nullptr;
    if (m_app->getConfig().isFullScreen())
    {
        monitor = glfwGetPrimaryMonitor();

        if (!m_app->getConfig().hasResolution())
        {
            auto mode = glfwGetVideoMode(monitor);
            m_size.x = (float)mode->width;
            m_size.y = (float)mode->height;
        }
    }

    m_window = glfwCreateWindow((int)m_size.x, (int)m_size.y, m_app->getConfig().windowTitle().c_str(), monitor, nullptr);
    if (!m_window)
    {
        cerr << "ERROR: Failed to open window." << endl;
        exit(EXIT_FAILURE);
    }

    glfwMakeContextCurrent(m_window);
    glfwSetWindowUserPointer(m_window,this);

    glfwSetInputMode(m_window, GLFW_STICKY_KEYS, GL_TRUE);
    glfwSetInputMode(m_window, GLFW_STICKY_MOUSE_BUTTONS, GL_TRUE);
    
    // HIDE original cursor
    glfwSetInputMode(m_window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);


    glfwSetWindowSizeCallback(m_window, glfwOnWindowSizeChanged);
    glfwSetCursorPosCallback(m_window, glfwOnCursorMove);
    glfwSetKeyCallback(m_window, glfwOnKeyStateChanged);

    glewExperimental = true;
    if (glewInit() != GLEW_OK)
    {
        cerr << "ERROR: Failed to init GLEW." << endl;
        exit(EXIT_FAILURE);
    }

    
#ifdef _DEBUG
    if ( glDebugMessageCallbackARB ) 
    {
        glDebugMessageCallbackARB(debugCallback, nullptr);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
    }
#endif

    reportOpenGlCaps();

    onWindowSizeChanged(true);
}
Window::~Window()
{
    glfwTerminate();
}




void glfwOnWindowSizeChanged(GLFWwindow * window, int width, int height)
{
    auto wnd = (Window*)glfwGetWindowUserPointer(window);
    wnd->m_size = vec2(width,height);
    wnd->onWindowSizeChanged();
}
void Window::onWindowSizeChanged(bool initialization)
{
    glViewport(0, 0, (GLsizei)m_size.x, (GLsizei)m_size.y);
    m_projection = glm::perspective(glm::radians(60.0f), m_size.x/m_size.y, 0.1f, 1000.0f);

    m_hasProjChanged[1] = true;
    double x,y;
    glfwGetCursorPos(m_window, &x, &y);

    m_cursorDelta = vec2(0);
    m_cursor = vec2((float)x,(float)y);

    if (!initialization)
        m_app->onWindowSizeChanged(m_size);
}


void glfwOnKeyStateChanged(GLFWwindow * window, int key, int scancode, int action, int mods)
{
    auto wnd = (Window*)glfwGetWindowUserPointer(window);
    wnd->onKeyStateChanged(key, action == GLFW_PRESS);
}
void Window::onKeyStateChanged(int key, bool pressed)
{
    m_app->onKeyStateChanged(key, pressed);
}

void glfwOnCursorMove(GLFWwindow * window, double x, double y)
{
    auto wnd = (Window*)glfwGetWindowUserPointer(window);
    wnd->m_cursor = vec2((float)x,(float)y);
}


void Window::swapBuffers()
{
    glfwSwapBuffers(m_window);
}
bool Window::doEvents()
{
    auto cursor = m_cursor;
    
    glfwPollEvents();

    auto cursorDeltaInMotoSpace = vec2(0, 0);

    if (!m_cursorInit)
    {
        cursorDeltaInMotoSpace = vec2(0,0);
        m_cursorInit = true;
    }
    else
        cursorDeltaInMotoSpace = m_cursor - cursor;

    auto newCursor = m_app->getOwnCursor().calculateCursorPosInVisualSpace(cursor, cursorDeltaInMotoSpace);

    if (newCursor != m_cursor)
    {
        m_cursor = newCursor;
        updatePointerPosition(m_cursor);
        m_cursorDelta = m_cursor - cursor;
    }

    return !glfwWindowShouldClose(m_window);
}



bool Window::keyDown(int key)
{
    return glfwGetKey(m_window, key) == GLFW_PRESS;
}
bool Window::mouseDown(int button)
{
    return glfwGetMouseButton(m_window, button) == GLFW_PRESS;
}

void Window::close()
{
    glfwSetWindowShouldClose(m_window, true);
}


void Window::update(double time, double timeDelta)
{
    m_hasProjChanged[0] = m_hasProjChanged[1];
    m_hasProjChanged[1] = false;
}

void Window::updatePointerPosition(vec2 pos)
{
    glfwSetCursorPos(m_window, pos.x, pos.y);
}