#include "GPUCVHardware/GLContext.h"
#include "GPUCVHardware/hardware.h"
#include "GPUCVHardware/GlobalSettings.h"
#if _GPUCV_DEBUG_MEMORY_LEAK
#include "SugoiTools/debug_new.h"
#endif
//=================================================
void InitGLView(TextSize<GLsizei> & _size)
{
InitGLView(0, _size._GetWidth(), 0, _size._GetHeight());
}
//=================================================
void InitGLView(int x_max, int y_max)
{
InitGLView(0, x_max, 0, y_max);
}
//=================================================
void InitGLView(int x_min, int x_max, int y_min, int y_max)
{
_GPUCV_GL_ERROR_TEST();
glEnable(GL_SCISSOR_TEST);
glScissor(x_min,y_min,x_max, y_max);
glViewport(x_min, y_min, x_max, y_max);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-1, 1, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// glEnable(GetHardProfile()->GetTextType());
//glClearDepth(0.);
// glClearColor(0., 0., 0., 0.);
_GPUCV_GL_ERROR_TEST();
//rise unknown error 1286...most of the time, this is due to wrong framebuffer format
//if(!GetHardProfile()->GetMainGPU()->IsHardwareFamily(GenericGPU::HRD_FAM_ATI))
{//don't know why, this crash on my ATI radeon 9700
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT|GL_ACCUM_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT);//| GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT|GL_ACCUM_BUFFER_BIT);
_GPUCV_GL_ERROR_TEST();
}
}
//=================================================
void InitGLViewPerspective(int width, int height, float _near/*=0.01*/, float _far/*=1000.*/)
{
_GPUCV_GL_ERROR_TEST();
glEnable(GL_SCISSOR_TEST);
glScissor(0,0,width,height);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(30., 4/3., _near, _far);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GetHardProfile()->GetTextType());
// glEnable(GL_DEPTH_TEST);
_GPUCV_GL_ERROR_TEST();
//glClearDepth(0.);
//glClearColor(0., 0., 0., 0.);
//??rise unknown error 1286...
//if(!GetHardProfile()->GetMainGPU()->IsHardwareFamily(GenericGPU::HRD_FAM_ATI))
{//don't know why, this crash on my ATI radeon 9700
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT|GL_ACCUM_BUFFER_BIT);
}
_GPUCV_GL_ERROR_TEST();
}
//=================================================
/*static*/
GLContext* GLContext::m_CurrentContext = NULL;
bool GLContext::m_MultiContext = false;
std::vector <GLContext*> GLContext::m_ContextVector;
/*static*/
void GLContext::PushCurrentGLContext()
{
if (!m_MultiContext)
return;
glFinish();
if(m_CurrentContext)//not the first time
m_ContextVector.push_back(m_CurrentContext);
#ifdef _WINDOWS
m_CurrentContext = new GLContext(wglGetCurrentDC(), wglGetCurrentContext());
m_CurrentContext->MakeCurrent();
#endif
}
//=================================================
/*static*/
void GLContext::PopCurrentGLContext()
{
if (!m_MultiContext)
return;
glFinish();
SG_Assert(m_ContextVector.size() >= 1, "GLContext::PopCurrentGLContext() => no more context to pop");
delete m_CurrentContext;
m_CurrentContext = m_ContextVector[m_ContextVector.size() -1];
m_ContextVector.pop_back();
m_CurrentContext->MakeCurrent();
}
//=================================================
/*static*/
GLContext* GLContext::GetActiveContext()
{
SG_Assert(m_ContextVector.size() >= 1, "GLContext::GetActiveContext() => No active context.");
return m_CurrentContext;
}
//=================================================
/*static*/
void GLContext::SetMultiContext(bool _multi)
{
m_MultiContext = _multi;
}
//=================================================
/*_GPUCV_HARDWARE_INLINE*/
void GLContext::MakeCurrent()
{
#ifdef _WINDOWS
SG_Assert(m_hDC!=0 && m_hRC!=0, "GLContext::MakeCurrent() => Empty context.");
wglMakeCurrent( m_hDC, m_hRC );
#endif
}
//=================================================
GLContext::GLContext()
#ifdef _WINDOWS
:
m_hDC(0),
m_hRC(0)
#endif
{
if(!m_CurrentContext)
m_CurrentContext = this;
}
//=================================================
#ifdef _WINDOWS
GLContext::GLContext(HDC hDC , HGLRC hRC)
:m_hDC(0),
m_hRC(0)
{
m_hDC = hDC;
m_hRC = hRC;
if(!m_CurrentContext)
m_CurrentContext = this;
}
#endif
//=================================================
GLContext::~GLContext()
{}
//=================================================
void GLContext :: PushAttribs()
{
//GPUCV_DEBUG("====>GLContext :: PushAttribs()")
glPushAttrib(
//##################################
//when some of this flags are set, FBO does not work any more
// GL_ACCUM_BUFFER_BIT|
// GL_COLOR_BUFFER_BIT|
// GL_CURRENT_BIT|
// GL_DEPTH_BUFFER_BIT|
//##################################
// to be tested, but we don't use all of them in GPUCV
// GL_EVAL_BIT|
// GL_FOG_BIT|
// GL_HINT_BIT|
// GL_LINE_BIT|
// GL_LIST_BIT|
// GL_STENCIL_BUFFER_BIT|
// GL_TRANSFORM_BIT|
/* GL_PIXEL_MODE_BIT|
GL_POINT_BIT|
GL_POLYGON_BIT|
GL_POLYGON_STIPPLE_BIT|
*/
//##################################
GL_ENABLE_BIT| //ok
GL_LIGHTING_BIT| //ok
GL_SCISSOR_BIT| //OK
GL_TEXTURE_BIT| //OK
GL_VIEWPORT_BIT //OK
);
}
//=================================================
void GLContext :: PopAttribs()
{
// GPUCV_DEBUG("<====GLContext :: PopAttribs()")
glPopAttrib();
}
//=================================================
GLContext* getGLContext()
{
static GLContext GLContextSingleton;
return &GLContextSingleton;
}
//=================================================
bool ShowOpenGLError(char * File, long Line)
{
if(!GET_GPUCV_OPTION(GpuCVSettings::GPUCV_SETTINGS_GL_ERROR_CHECK))
return false;
int GLERROR = glGetError();
if (GLERROR==GL_NO_ERROR) return false;
Beep(5000, 20);
std::string FullMsg = "\n\n!!!!!!!!!!!!! OPENGL ERROR !!!!!!!!!!!!!!!";
FullMsg += "\nFILE : ";
FullMsg += File;
FullMsg += "\nLINE : ";
FullMsg += Line;
FullMsg += "\nCODE : ";
FullMsg += SGE::ToCharStr(GLERROR);
string Msg="";
const GLubyte *errStr;
errStr = gluErrorString(GLERROR);
if (errStr)
{
Msg = "\nMSG(OpenGL): ";
Msg +=(char*)errStr;
}
else
{
Msg = "\nMSG(Custom):";
switch(GLERROR)
{
case GL_INVALID_ENUM : Msg += "GLenum argument out of range.";break;
case GL_INVALID_VALUE : Msg += "Numeric argument out of range.";break;
case GL_INVALID_OPERATION : Msg += "Operation illegal in current state.";break;
case GL_STACK_OVERFLOW : Msg += "Function would cause a stack overflow.";break;
case GL_STACK_UNDERFLOW : Msg += "Function would cause a stack underflow.";break;
case GL_OUT_OF_MEMORY : Msg += "Not enough memory left to execute function.";break;
case 1286 : Msg += "It seems that glClear() or glClearColor() raised an error, due to wrong framebuffer format.";break;
default : Msg += "Unknown OpenGL error message.";
}
}
FullMsg+= Msg;
int green=0, blue=0, red=0, alpha=0, depth=0;
glGetIntegerv(GL_GREEN_BITS, &green);
glGetIntegerv(GL_BLUE_BITS, &blue);
glGetIntegerv(GL_RED_BITS, &red);
glGetIntegerv(GL_ALPHA_BITS, &alpha);
glGetIntegerv(GL_DEPTH_BITS, &depth);
if(green*blue*red == 0)
FullMsg+="\nFrameBuffer bits (Red, Green, Blue) are empty => May be using incompatible framebuffer format.";
if(alpha == 0)
FullMsg+="\nFrameBuffer bits (Alpha) is empty => May be using incompatible framebuffer format.";
if(depth == 0)
FullMsg+="\nFrameBuffer bits (Depth) is empty => May be using incompatible framebuffer format.";
FullMsg+="\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
if(GET_GPUCV_OPTION(GpuCVSettings::GPUCV_SETTINGS_GL_ERROR_RISE_EXCEPTION))
{
GPUCV_ERROR(FullMsg);
SG_Assert(0, FullMsg);
}
else
{ GPUCV_ERROR(FullMsg);}
return true;
}
//=================================================
std::string GetStrGLTextureFormat(GLuint format)
{
string FormatStr;
switch (format)
{
case GL_RED: FormatStr="GL_RED"; break;
case GL_BLUE: FormatStr="GL_BLUE"; break;
case GL_GREEN: FormatStr="GL_GREEN"; break;
case GL_LUMINANCE: FormatStr="GL_LUMINANCE";break;
case GL_LUMINANCE_ALPHA: FormatStr="GL_LUMINANCE_ALPHA";break;
case GL_BGR: FormatStr="GL_BGR"; break;
case GL_RGB: FormatStr="GL_RGB"; break;
case GL_BGRA: FormatStr="GL_BGRA"; break;
case GL_RGBA: FormatStr="GL_RGBA"; break;
case GL_RGBA_FLOAT16_ATI: FormatStr="GL_RGBA_FLOAT16_ATI"; break;
case GL_RGBA_FLOAT32_ATI: FormatStr="GL_RGBA_FLOAT32_ATI"; break;
default: FormatStr = "UNKOWN"; break;
}
return FormatStr;
}
//=================================================
std::string GetStrGLInternalTextureFormat(GLuint format)
{
string FormatStr;
switch (format)
{
//alpha
case GL_ALPHA4: FormatStr="GL_ALPHA4"; break;
case GL_ALPHA8: FormatStr="GL_ALPHA8"; break;
case GL_ALPHA12: FormatStr="GL_ALPHA12"; break;
case GL_ALPHA16: FormatStr="GL_ALPHA16"; break;
//luminance
case GL_LUMINANCE4: FormatStr="GL_LUMINANCE4";break;
case GL_LUMINANCE8: FormatStr="GL_LUMINANCE8";break;
case GL_LUMINANCE12: FormatStr="GL_LUMINANCE12";break;
case GL_LUMINANCE16: FormatStr="GL_LUMINANCE16";break;
/*add GL_LUMINANCE16_ALPHA16*/
case GL_LUMINANCE16_ALPHA16: FormatStr="GL_LUMINANCE16_ALPHA16";break;
case GL_LUMINANCE_ALPHA16F_ARB: FormatStr="GL_LUMINANCE_ALPHA16F_ARB";break;
case GL_LUMINANCE_ALPHA16I_EXT: FormatStr="GL_LUMINANCE_ALPHA16I_ARB";break;
case GL_LUMINANCE_ALPHA16UI_EXT: FormatStr="GL_LUMINANCE_ALPHA16UI_ARB";break;
// case GL_LUMINANCE_ALPHA_FLOAT16_APPLE: FormatStr="GL_LUMINANCE_ALPHA_FLOAT16_APPLE";break;
// case GL_LUMINANCE_ALPHA_FLOAT16_ATI: FormatStr="GL_LUMINANCE_ALPHA_FLOAT16_ATI";break;
case GL_LUMINANCE_ALPHA32F_ARB: FormatStr="GL_LUMINANCE_ALPHA32F_ARB";break;
case GL_LUMINANCE_ALPHA32I_EXT: FormatStr="GL_LUMINANCE_ALPHA32I_EXT";break;
case GL_LUMINANCE_ALPHA32UI_EXT: FormatStr="GL_LUMINANCE_ALPHA32UI_EXT";break;
// case GL_LUMINANCE_ALPHA_FLOAT32_APPLE: FormatStr="GL_LUMINANCE_ALPHA_FLOAT32_APPLE";break;
// case GL_LUMINANCE_ALPHA_FLOAT32_ATI: FormatStr="GL_LUMINANCE_ALPHA_FLOAT32_ATI";break;
case GL_INTENSITY4: FormatStr="GL_INTENSITY4";break;
case GL_INTENSITY8: FormatStr="GL_INTENSITY8";break;
case GL_INTENSITY12: FormatStr="GL_INTENSITY12";break;
case GL_INTENSITY16: FormatStr="GL_INTENSITY16";break;
//rgb
case GL_R3_G3_B2: FormatStr="GL_R3_G3_B2";break;
case GL_RGB4: FormatStr="GL_RGB4";break;
case GL_RGB5: FormatStr="GL_RGB5";break;
case GL_RGB8: FormatStr="GL_RGB8";break;
case GL_RGB12: FormatStr="GL_RGB12";break;
case GL_RGB16: FormatStr="GL_RGB16";break;
case GL_RGB32F_ARB: FormatStr="GL_RGB32F_ARB";break;
// case GL_RGB16_EXT: FormatStr="GL_RGB16_EXT";break;
//rgba
case GL_RGBA2: FormatStr="GL_RGBA2";break;
case GL_RGBA4: FormatStr="GL_RGBA4";break;
case GL_RGB5_A1: FormatStr="GL_RGB5_A1";break;
case GL_RGBA8: FormatStr="GL_RGBA8";break;
case GL_RGB10_A2: FormatStr="GL_RGB10_A2";break;
case GL_RGBA12: FormatStr="GL_RGBA12";break;
case GL_RGBA16: FormatStr="GL_RGBA16";break;
// case GL_RGBA16_EXT: FormatStr="GL_RGBA16_EXT";break;
case GL_RGBA32F_ARB: FormatStr="GL_RGBA32F_ARB";break;
case GL_RGBA_FLOAT16_ATI: FormatStr="GL_RGBA_FLOAT16_ATI"; break;
// case GL_RGBA_FLOAT32_ATI: FormatStr="GL_RGBA_FLOAT32_ATI"; break;
//depth
case GL_DEPTH_COMPONENT: FormatStr="GL_DEPTH_COMPONENT";break;
case GL_DEPTH_COMPONENT16: FormatStr="GL_DEPTH_COMPONENT16";break;
case GL_DEPTH_COMPONENT24: FormatStr="GL_DEPTH_COMPONENT24";break;
case GL_DEPTH_COMPONENT32: FormatStr="GL_DEPTH_COMPONENT32";break;
case GL_DEPTH_COMPONENT32F_NV : FormatStr="GL_DEPTH_COMPONENT32F_NV";break;
default: FormatStr = "UNKOWN"; break;
}
return FormatStr;
}
//=================================================
std::string GetStrGLTexturePixelType(GLuint format)
{
string FormatStr;
switch (format)
{
case GL_UNSIGNED_BYTE: FormatStr="GL_UNSIGNED_BYTE"; break;
case GL_BYTE: FormatStr="GL_BYTE"; break;
case GL_BITMAP: FormatStr="GL_BITMAP"; break;
case GL_UNSIGNED_SHORT: FormatStr="GL_UNSIGNED_SHORT";break;
case GL_SHORT: FormatStr="GL_SHORT"; break;
case GL_UNSIGNED_INT: FormatStr="GL_UNSIGNED_INT"; break;
case GL_INT: FormatStr="GL_INT"; break;
case GL_FLOAT: FormatStr="GL_FLOAT"; break;
default: FormatStr = "UNKOWN"; break;
}
return FormatStr;
}
//=================================================
GLenum GetGLNbrComponent(GLenum format)
{
char Res = 0;
switch(format)
{
case GL_GREEN:
case GL_BLUE:
case GL_RED:
case GL_LUMINANCE: Res = 1; break;
case GL_LUMINANCE_ALPHA: Res = 2;break;
case GL_RGB :
case GL_BGR : Res = 3; break;
case GL_RGBA :
case GL_BGRA : Res = 4; break;
default : SG_Assert(0, "Critical : GetGLNbrComponent()=> Unknown texture format...Please update function GetGLNbrComponent().");
Res = 4;
break;
}
return Res;
}
//=================================================
/**
\todo fomat GL_BITMAP not managed.
\todo fomat GL_RGBAFLOAT not managed.
*/
GLenum GetGLPixelSize(GLenum format, GLenum type)
{
char NbrComponent = GetGLNbrComponent(format);
char Res = 0;
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_BYTE: Res = sizeof(char); break;
// case GL_BITMAP: FormatStr="GL_BITMAP"; break;
case GL_UNSIGNED_SHORT:
case GL_SHORT: Res = sizeof(short int);break;
case GL_UNSIGNED_INT:
case GL_INT: Res = sizeof(int);break;
case GL_FLOAT: Res = sizeof(float);break;
//case GL_RGBAFLOAT: Res = sizeof(float);break;
default:
GPUCV_ERROR("Critical : GetGLPixelSize()=> Unknown texture format...Using GL_BYTE");
Res = sizeof(char);
break;
}
return Res * NbrComponent;
}
//=================================================
std::string GetStrColorAttachment(GLuint format)
{
string FormatStr;
switch (format)
{
case 0: FormatStr="NO Attachement"; break;
case GL_COLOR_ATTACHMENT0_EXT: FormatStr="GL_COLOR_ATTACHMENT0_EXT"; break;
case GL_COLOR_ATTACHMENT1_EXT: FormatStr="GL_COLOR_ATTACHMENT1_EXT"; break;
case GL_COLOR_ATTACHMENT2_EXT: FormatStr="GL_COLOR_ATTACHMENT2_EXT"; break;
case GL_COLOR_ATTACHMENT3_EXT: FormatStr="GL_COLOR_ATTACHMENT3_EXT"; break;
case GL_COLOR_ATTACHMENT4_EXT: FormatStr="GL_COLOR_ATTACHMENT4_EXT"; break;
case GL_COLOR_ATTACHMENT5_EXT: FormatStr="GL_COLOR_ATTACHMENT5_EXT"; break;
case GL_COLOR_ATTACHMENT6_EXT: FormatStr="GL_COLOR_ATTACHMENT6_EXT"; break;
case GL_COLOR_ATTACHMENT7_EXT: FormatStr="GL_COLOR_ATTACHMENT7_EXT"; break;
case GL_COLOR_ATTACHMENT8_EXT: FormatStr="GL_COLOR_ATTACHMENT8_EXT"; break;
case GL_DEPTH_ATTACHMENT_EXT: FormatStr="GL_DEPTH_ATTACHMENT_EXT"; break;
case GL_STENCIL_ATTACHMENT_EXT: FormatStr="GL_STENCIL_ATTACHMENT_EXT"; break;
default: FormatStr = "UNKOWN"; break;
}
return FormatStr;
}
//=================================================
#if _GPUCV_DEBUG_MEMORY_LEAK
#include "SugoiTools/debug_new_off.h"
#endif
|
