Stuff

#include <iostream>
#include <string>
#include <fstream.h>
#include <vector>

#include "SDL/SDL_video.h"

#include "nvgl/nvgl.h"
#include "nvmath/Vec3f.h"
#include "nvtraverser/GLTraverser.h"
#include "nvutil/Tools.h"

#include "Render/SDLRenderArea.h"
#include "Render/Video.h"

#include "nvutil/DbgNew.h" // this must be the last include

using namespace nvgl;
using namespace nvsg;
using nvtraverser::GLTraverser;
using nvui::RenderArea;

SDLRenderArea::SDLRenderArea() :
    RenderArea()
{
}

SDLRenderArea::~SDLRenderArea()
{
}

unsigned int shader_num;

bool SDLRenderArea::init(RenderArea* sharedArea)
{
    std::cout << "Initializing SDLRenderArea" << std::endl;
    

#if defined(_WIN32)
    m_hglrc = wglGetCurrentContext();
    m_hdc = wglGetCurrentDC();
    WGLAttachContext(m_hdc, m_hglrc);
#elif defined(LINUX)
    m_hglrc = glXGetCurrentContext();
    m_drawable = glXGetCurrentDrawable();
    m_dpy = glXGetCurrentDisplay();
    GLXAttachContext(m_dpy, m_hglrc);
#else
#error
#endif

    makeCurrent();

    if (!nvui::RenderArea::init(sharedArea))
        throw std::string("bad");

    NVSG_ASSERT(m_renderTraverser == 0);
    NVSG_VERIFY(m_renderTraverser = new GLTraverser);

    // Load Shaders
    std::cout << "Begin loading shaders." << std::endl;
    std::string path;
    nvutil::GetCurrentDir( path );
    path += "/shaders/blue.cg";
    std::ifstream shader_file;
    shader_file.open(path.c_str());
    if(!shader_file) {
      std::cout << "Unable to open shader file" << std::endl;
    }

    std::cout << "Loaded shader: " << path << std::endl;
    
    std::stringstream ss;
    ss << shader_file.rdbuf();
    std::string shader_string = ss.str();  
    //std::cout << shader_string << std::endl;

    std::vector<GLubyte> shader_code (shader_string.begin(), shader_string.end());

    GLEnable(GL_VERTEX_PROGRAM_NV);
    
    unsigned int shader_no;  

    GLGenPrograms(1, &shader_no);
    GLBindProgram(GL_VERTEX_PROGRAM_NV, shader_no);
    GLLoadProgram(GL_VERTEX_PROGRAM_NV, shader_no, shader_string.length(), &shader_code.front());

    GLDisable(GL_VERTEX_PROGRAM_NV);

    shader_num = shader_no;

    m_renderTraverser->addRef();
}

void SDLRenderArea::destroy()
{
    std::cout << "Destroying SDLRenderArea" << std::endl;
    nvui::RenderArea::destroy();
    makeCurrent();
    if (m_renderTraverser)
    {
        m_renderTraverser->removeRef();
        m_renderTraverser = 0;
    }
#if defined(_WIN32)
    WGLDetachContext(m_hglrc);
#elif defined(LINUX)
    GLXDetachContext(m_hglrc);
#else
#error
#endif
}

void SDLRenderArea::makeCurrent()
{
#if defined(_WIN32)
    WGLMakeCurrent(m_hdc, m_hglrc);
#elif defined(LINUX)
    GLXMakeCurrent(m_dpy, m_drawable, m_hglrc);
#else
#error
#endif
}

void SDLRenderArea::setViewportSize(size_t width, size_t height)
{
    RenderArea::setViewportSize(width, height);
    makeCurrent();
    GLViewport(0, 0, (GLsizei)width, (GLsizei)height);
}

void SDLRenderArea::triggerRedraw()
{
    RenderArea::triggerRedraw();
    Video::instance()->requestRedraw();
}

void SDLRenderArea::renderScene()
{
    makeCurrent();

    if (m_scene)
    {
        nvmath::Vec3f backColor = nvutil::ReadableObject<Scene>(m_scene)->getBackColor();
        GLClearColor(backColor[0], backColor[1], backColor[2], 0.0f);
    }
    GLClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    GLEnable(GL_VERTEX_PROGRAM_NV);
    GLBindProgram(GL_VERTEX_PROGRAM_NV, shader_num);

    RenderArea::renderScene();

    GLDisable(GL_VERTEX_PROGRAM_NV);

    SDL_GL_SwapBuffers();
}