Miscellany

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

#include "SDL/SDL_video.h"

#include <Cg/cg.h>    // Including Cg runtime API
#include <Cg/cgGL.h>  // Including OpenGL-specific Cg runtime API

#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()
{
}

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";
    // Create the context, this is a container for Cg programs    
    //CGcontext context = cgCreateContext();
    //CGcontext context = nvsg::cgfxContext;
    
    if(nvsg::cgfxContext == NULL){
      std::cout << "Failed to create CGcontext." << std::endl;
      exit(-1);
    }else{
      CGprogram program = cgCreateProgramFromFile(
	  nvsg::cgfxContext,  // The context where we want it added
	  CG_SOURCE,        // The following parameter is an
			    // array of bytes containing Cg source
	  path.c_str(),     // The sourcefile
  	  CG_PROFILE_ARBVP1,// The profile 
	  "main",           // The entry function 
	  NULL              // Compiler options
	  );

      if(program==NULL){
	std::cout << "Failed to compile the program: " << path.c_str() << std::endl;
	exit(-1);
      }else{
	std::cout << "Loaded shader: " << path << std::endl;
	// Now load the program
	cgGLLoadProgram(program);
	
	// Enable the profile
	cgGLEnableProfile(CG_PROFILE_ARBVP1);
	
	// Bind the program
	cgGLBindProgram(program);
      }
    }

    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();
}