Jump to content

  • Log In with Google      Sign In   
  • Create Account

Open a 3.2 OPENGL context or superior


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
5 replies to this topic

#1 PiouPiou   Members   -  Reputation: 105

Like
0Likes
Like

Posted 10 June 2012 - 09:07 AM

Hi all,

just 2 questions
here is my code, I use the correct method to open a context "core profile"?
I have a yellow texture, please consider I clearly see my yellow triangle when I'm context <3.2 and if I open a context> = 3.2 my texture disappears (the triangle become black)

thank you in advance for your answers

my code :
#define WIDTH  800
#define HEIGHT  600
#define NBP   32
#define MAJOR  3	// for creating context opengl MAJOR VERSION  TRY MAJOR = 3
#define MINOR  1	// for creating context opengl MINOR VERSION  TRY MINOR >= 2
#define FULLSCREEN false
#define PI 3.14159265
#define TEXTURESIZE 256 * 256 * 3
#include <Windows.h>
#include <math.h>  
#include <stdio.h>	   // fopen, fread, fclose
#include "GL3\gl3.h"

class mat4
{
public:
float m[16];
const float* GetMatriceOpengl() const;
void mat4::Identity();
};
#ifdef __cplusplus
extern "C" {
#endif
GLAPI void APIENTRY glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
GLAPI void APIENTRY glClear (GLbitfield mask);
GLAPI const GLubyte * APIENTRY glGetString (GLenum name);
GLAPI void APIENTRY glEnable (GLenum cap);
GLAPI void APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
GLAPI void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
GLAPI void APIENTRY glDisable (GLenum cap);
GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
GLAPI void APIENTRY glBindTexture (GLenum target, GLuint texture);
GLAPI void APIENTRY glGenTextures (GLsizei n, GLuint *textures);
GLAPI void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
GLAPI void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
GLAPI void APIENTRY glGetIntegerv (GLenum pname, GLint *params);
#ifdef __cplusplus
}
#endif
PFNGLCREATEPROGRAMPROC	glCreateProgram	= NULL;
PFNGLUNIFORMMATRIX4FVPROC   glUniformMatrix4fv   = NULL;
PFNGLGENVERTEXARRAYSPROC   glGenVertexArrays   = NULL;
PFNGLBINDVERTEXARRAYPROC   glBindVertexArray   = NULL;
PFNGLGENBUFFERSPROC	 glGenBuffers	= NULL;
PFNGLBINDBUFFERPROC	 glBindBuffer	= NULL;
PFNGLBUFFERDATAPROC	 glBufferData	= NULL;
PFNGLVERTEXATTRIBPOINTERPROC  glVertexAttribPointer  = NULL;
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = NULL;
PFNGLCREATESHADERPROC	glCreateShader	= NULL;
PFNGLSHADERSOURCEPROC	glShaderSource	= NULL;
PFNGLCOMPILESHADERPROC	glCompileShader	= NULL;
PFNGLBINDATTRIBLOCATIONPROC   glBindAttribLocation  = NULL;
PFNGLATTACHSHADERPROC	glAttachShader	= NULL;
PFNGLLINKPROGRAMPROC	glLinkProgram	= NULL;
PFNGLUSEPROGRAMPROC	 glUseProgram	= NULL;
PFNGLGETUNIFORMLOCATIONPROC   glGetUniformLocation  = NULL;
PFNGLGETSHADERIVPROC	glGetShaderiv	= NULL;
PFNGLGETPROGRAMIVPROC	glGetProgramiv	= NULL;
PFNGLGETSHADERINFOLOGPROC   glGetShaderInfoLog   = NULL;
PFNGLGETPROGRAMINFOLOGPROC   glGetProgramInfoLog   = NULL;
PFNGLACTIVETEXTUREPROC	glActiveTexture	= NULL;
PFNGLUNIFORM1IPROC	 glUniform1i	 = NULL;
PFNGLGETSTRINGIPROC	 glGetStringi	= NULL;
unsigned int vao;
unsigned int vbo[2];
float   incx, incy, incz;
GLuint   vshader;
GLuint   fshader;
GLuint   program;
char   source1[1024*1024*4];
char   source2[1024*1024*4];
short   taillex, tailley;
unsigned char *data = new unsigned char[TEXTURESIZE];
GLuint   texture;
GLuint   tex;
mat4   pmatrix;
mat4   mmatrix;
float   A, B, C, D, E, F, AD, BD;
LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam );
float triangle[] = { // pos // Map
-1.0f,  1.0f, 1.0f, 0.0f, 0.0f,
-1.0f, -1.0f, 1.0f, 0.0f, 4.0f,
  1.0f, -1.0f, 1.0f, 4.0f, 4.0f };
GLuint indicetriangle[] = { 0,1,2 };
#define WGL_CONTEXT_MAJOR_VERSION_ARB		   0x2091
#define WGL_CONTEXT_MINOR_VERSION_ARB		   0x2092
#define WGL_CONTEXT_PROFILE_MASK_ARB   0x9126
#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
int attriblist[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, MAJOR, WGL_CONTEXT_MINOR_VERSION_ARB, MINOR, WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, 0, 0 };
HGLRC wglCreateContextAttribsARB(HDC hDC, HGLRC hShareContext, const int *attribList)
{
	typedef HGLRC (APIENTRY * PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC hDC, HGLRC hShareContext, const int *attribList);
	static PFNWGLCREATECONTEXTATTRIBSARBPROC pfnCreateContextAttribsARB = 0;  
  
	HGLRC hContext = 0;
	HGLRC hCurrentContext = wglGetCurrentContext();
  
	if (!hCurrentContext)
	{
		if (!(hCurrentContext = wglCreateContext(hDC)))
			return 0;
		if (!wglMakeCurrent(hDC, hCurrentContext))
		{
			wglDeleteContext(hCurrentContext);
			return 0;
		}
		pfnCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(wglGetProcAddress("wglCreateContextAttribsARB"));
	  
		if (pfnCreateContextAttribsARB)
			hContext = pfnCreateContextAttribsARB(hDC, hShareContext, attribList);
		wglMakeCurrent(hDC, 0);
		wglDeleteContext(hCurrentContext);
	}
	else
	{
		if (!wglMakeCurrent(hDC, hCurrentContext))
			return 0;
		pfnCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(wglGetProcAddress("wglCreateContextAttribsARB"));
		if (pfnCreateContextAttribsARB)
			hContext = pfnCreateContextAttribsARB(hDC, hShareContext, attribList);
	}
	return hContext;
}
const float* mat4::GetMatriceOpengl() const
{
return &m[0];
}
void mat4::Identity()
{
memset(m, 0, sizeof(float)*16);
m[0] = m[5] = m[10] = m[15] = 1.0f;
}
mat4 MultMatrice(mat4* m, mat4 *n)
{
static mat4 mat;
mat.m[0]  = m->m[0]*n->m[0] + m->m[4]*n->m[1] + m->m[8]*n->m[2] + m->m[12]*n->m[3];
mat.m[1]  = m->m[1]*n->m[0] + m->m[5]*n->m[1] + m->m[9]*n->m[2] + m->m[13]*n->m[3];
mat.m[2]  = m->m[2]*n->m[0] + m->m[6]*n->m[1] + m->m[10]*n->m[2] + m->m[14]*n->m[3];
mat.m[3]  = m->m[3]*n->m[0] + m->m[7]*n->m[1] + m->m[11]*n->m[2] + m->m[15]*n->m[3];
mat.m[4]  = m->m[0]*n->m[4] + m->m[4]*n->m[5] + m->m[8]*n->m[6] + m->m[12]*n->m[7];
mat.m[5]  = m->m[1]*n->m[4] + m->m[5]*n->m[5] + m->m[9]*n->m[6] + m->m[13]*n->m[7];
mat.m[6]  = m->m[2]*n->m[4] + m->m[6]*n->m[5] + m->m[10]*n->m[6] + m->m[14]*n->m[7];
mat.m[7]  = m->m[3]*n->m[4] + m->m[7]*n->m[5] + m->m[11]*n->m[6] + m->m[15]*n->m[7];
mat.m[8]  = m->m[0]*n->m[8] + m->m[4]*n->m[9] + m->m[8]*n->m[10] + m->m[12]*n->m[11];
mat.m[9]  = m->m[1]*n->m[8] + m->m[5]*n->m[9] + m->m[9]*n->m[10] + m->m[13]*n->m[11];
mat.m[10] = m->m[2]*n->m[8] + m->m[6]*n->m[9] + m->m[10]*n->m[10] + m->m[14]*n->m[11];
mat.m[11] = m->m[3]*n->m[8] + m->m[7]*n->m[9] + m->m[11]*n->m[10] + m->m[15]*n->m[11];
mat.m[12] = m->m[0]*n->m[12] + m->m[4]*n->m[13] + m->m[8]*n->m[14] + m->m[12]*n->m[15];
mat.m[13] = m->m[1]*n->m[12] + m->m[5]*n->m[13] + m->m[9]*n->m[14] + m->m[13]*n->m[15];
mat.m[14] = m->m[2]*n->m[12] + m->m[6]*n->m[13] + m->m[10]*n->m[14] + m->m[14]*n->m[15];
mat.m[15] = m->m[3]*n->m[12] + m->m[7]*n->m[13] + m->m[11]*n->m[14] + m->m[15]*n->m[15];

return mat;
}
void glTranslate(mat4 *mat, float x, float y, float z)
{
static mat4 m;
	m.m[0] = m.m[5] = m.m[10] = m.m[15] = 1.0f;
	m.m[1] = m.m[2] = m.m[3] = m.m[4] = m.m[6] = m.m[7] = m.m[8] = m.m[9] = m.m[11] = 0.0f;
	m.m[12] = x;
	m.m[13] = y;
	m.m[14] = z;
*mat = MultMatrice(mat,&m);
}
void glPerspective( mat4 &mat, float fovy, float ratio, float znear, float zfar )
{
static float ymax, xmax;
static float temp, temp4;
ymax = float(znear * tanf(float(fovy * PI / 360.0f)));
xmax = ymax * ratio;
temp = znear + znear;
temp4 = zfar - znear;
mat.m[0] = znear / xmax;
mat.m[1] =mat.m[2] =mat.m[3] =mat.m[4] =mat.m[6] =mat.m[7] =mat.m[8] =mat.m[9] =mat.m[12] =mat.m[13] =mat.m[15] = 0.0;
mat.m[5] = znear / ymax;
mat.m[10] = (-zfar - znear) / temp4;
mat.m[11] = -1.0;
mat.m[14] = (-temp * zfar) / temp4;
}
void LoadFile(char *name, char *buffer)
{
FILE *hfile = fopen(name, "rb");
if (hfile)	
{
  fread(buffer, 1, 10000, hfile);
  fclose(hfile);
}
}
void Init()
{
glCreateProgram	= (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram");
glUniformMatrix4fv   = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv");
glGenVertexArrays   = (PFNGLGENVERTEXARRAYSPROC)wglGetProcAddress("glGenVertexArrays");
glBindVertexArray   = (PFNGLBINDVERTEXARRAYPROC)wglGetProcAddress("glBindVertexArray");
glGenBuffers	= (PFNGLGENBUFFERSPROC)wglGetProcAddress("glGenBuffers");
glBindBuffer	= (PFNGLBINDBUFFERPROC)wglGetProcAddress("glBindBuffer");
glBufferData	= (PFNGLBUFFERDATAPROC)wglGetProcAddress("glBufferData");
glVertexAttribPointer  = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer");
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glEnableVertexAttribArray");
glCreateShader	= (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
glShaderSource	= (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
glCompileShader	= (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
glBindAttribLocation  = (PFNGLBINDATTRIBLOCATIONPROC)wglGetProcAddress("glBindAttribLocation");
glAttachShader	= (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader");
glLinkProgram	= (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram");
glUseProgram	= (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram");
glGetUniformLocation  = (PFNGLGETUNIFORMLOCATIONPROC)wglGetProcAddress("glGetUniformLocation");
glGetShaderiv	= (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
glGetProgramiv	= (PFNGLGETPROGRAMIVPROC)wglGetProcAddress("glGetProgramiv");
glGetShaderInfoLog   = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");
glGetProgramInfoLog   = (PFNGLGETPROGRAMINFOLOGPROC)wglGetProcAddress("glGetProgramInfoLog");
glActiveTexture	= (PFNGLACTIVETEXTUREPROC)wglGetProcAddress("glActiveTexture");
glUniform1i	 = (PFNGLUNIFORM1IPROC)wglGetProcAddress("glUniform1i");
glGetStringi	= (PFNGLGETSTRINGIPROC)wglGetProcAddress("glGetStringi");
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(2, &vbo[0]);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(triangle), triangle, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indicetriangle), indicetriangle, GL_STATIC_DRAW);
glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 20, 0);
glVertexAttribPointer((GLuint)1, 2, GL_FLOAT, GL_FALSE, 20, (void*)12);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glBindVertexArray(0);
const char  *src = source1;
vshader   = glCreateShader(GL_VERTEX_SHADER);
fshader   = glCreateShader(GL_FRAGMENT_SHADER);
LoadFile("vert.txt", source1);
glShaderSource(vshader, 1, &src, NULL);
glCompileShader(vshader);
LoadFile("frag.txt", source2);
src = source2;
glShaderSource(fshader, 1, &src, NULL);
glCompileShader(fshader);
program = glCreateProgram();
glAttachShader(program, vshader);
glAttachShader(program, fshader);
// glBindAttribLocation(program,0, "vert");
// glBindAttribLocation(program,1, "texture");
glLinkProgram(program);
tex = glGetUniformLocation(program, "gsample");

taillex = 256;
tailley = 256;

unsigned char *p = data;
for (int t = 0 ; t < taillex*tailley ; t++)   // i create a yellow texture just for testing
  *p++ = 255, *p++ = 255, *p++ = 0;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D , 0 , 3 , taillex , tailley , 0 , GL_RGB , GL_UNSIGNED_BYTE , data);
glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_WRAP_S , GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_WRAP_T , GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, 0);
};
int  MainSub()
{
glUseProgram(program);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0f,0.2f,0.4f,1.0f);	
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mmatrix.Identity();
incz = -3.5f;
glTranslate(&mmatrix, incx, incy, incz);
glUniformMatrix4fv(glGetUniformLocation(program, "projectionmatrix"), 1, GL_FALSE, pmatrix.GetMatriceOpengl());
	glUniformMatrix4fv(glGetUniformLocation(program, "modelmatrix"), 1, GL_FALSE, mmatrix.GetMatriceOpengl());
glBindVertexArray(vao);
glUniform1i(tex, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,texture);
//glDrawArrays(GL_TRIANGLES, 0, 3); // draw first object  
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT,0);
glBindVertexArray(0);
glUseProgram(0);
return true;
}
int WINAPI WinMain(HINSTANCE hinst,HINSTANCE hprev, LPSTR cmdline, int cmdshow)
{
static MSG   msg;	
HWND	hwnd;
HDC	 hdc;
HGLRC	hrc;
WNDCLASSEX   wnd;
DWORD	style;			
DWORD	exstyle;

wnd.cbSize   = sizeof( WNDCLASSEX ) ;  
	wnd.style   = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;  
	wnd.lpfnWndProc  = WndProc;	  
	wnd.hInstance  = hinst;	  
	wnd.hCursor   = LoadCursor( NULL, IDC_HAND );  
wnd.hIcon   = LoadIcon(NULL, IDI_ASTERISK);  
	wnd.hIconSm   = LoadIcon(NULL, IDI_WINLOGO);  
wnd.hbrBackground = 0;	  
	wnd.lpszMenuName = 0;		
wnd.cbClsExtra  = 0;		
wnd.cbWndExtra  = 0;	  
wnd.lpszClassName = "wc";	  
RegisterClassEx(&wnd);

if (FULLSCREEN)
{
  DEVMODE dm;		  
  memset(&dm, 0, sizeof(dm));	  
  dm.dmSize  = sizeof(dm);	  
  dm.dmPelsWidth = WIDTH;	  
  dm.dmPelsHeight = HEIGHT;	  
  dm.dmBitsPerPel = NBP;	  
  dm.dmFields  = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
  ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
  style   = WS_POPUP;	
  exstyle   = WS_EX_APPWINDOW;	
  ShowCursor(FALSE);	
}
else
{
  style   = WS_OVERLAPPEDWINDOW;	
  exstyle   = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
}
	RECT rc = { 0, 0, WIDTH, HEIGHT };	
	AdjustWindowRectEx( &rc, style, false, exstyle );
hwnd = CreateWindowEx( exstyle, "wc", "MyWindows", style, 0, 0, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hinst, NULL );
static PIXELFORMATDESCRIPTOR pfd =  
{
  sizeof(PIXELFORMATDESCRIPTOR),  
  1,		  
  PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
  PFD_TYPE_RGBA,	  
  NBP,		
  0, 0, 0, 0, 0, 0,	  
  0,		  
  0,		
  0,		
  0, 0, 0, 0,		
  16,		  // 16Bit Z-Buffer (Depth Buffer)
  0,		
  0,		
  PFD_MAIN_PLANE,	  
  0,		  
  0, 0, 0		
};
hdc = GetDC(hwnd);
unsigned int pixelformat = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, pixelformat, &pfd);
if  (MAJOR < 3)		// open Standard Context
  hrc = wglCreateContext(hdc);
else
  hrc = wglCreateContextAttribsARB(hdc, 0, attriblist); // open à New Core Context
wglMakeCurrent(hdc, hrc);
ShowWindow( hwnd, cmdshow );

Init();
const GLubyte *version = glGetString(GL_VERSION);
MessageBox(NULL,(char *)version ,"Opengl Version",MB_OK|MB_ICONEXCLAMATION);
while( msg.message != WM_QUIT )
	{
		if( PeekMessage( &msg, 0, 0, 0, PM_REMOVE ) )
		{
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
  MainSub();
  SwapBuffers(hdc);		// Double Buffer
}

if (FULLSCREEN)
{
  ChangeDisplaySettings(NULL,0);  
  ShowCursor(TRUE);	
}
wglMakeCurrent(NULL,NULL);  
wglDeleteContext(hrc);  
hrc = 0;		
ReleaseDC(hwnd,hdc);
hdc = 0;	  
DestroyWindow(hwnd);
hwnd = 0;		
UnregisterClass("wclasse",hinst);
delete [] data;
return static_cast<int>( msg.wParam );
}
LRESULT CALLBACK WndProc( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam )
{
static short width;
static short height;
	switch( message )
	{
  
  case WM_DESTROY:
   PostQuitMessage( 0 );
   break;
  case WM_SIZE:	  
   width= LOWORD(lparam);
   height = HIWORD(lparam);
   if ( height == 0 )		
	height = 1;
   glViewport(0, 0, width, height);
   glPerspective( pmatrix, 45.0f, (GLfloat)width/(GLfloat)height, 0.1f, 100.0f );
   break;	  
		default:
			return DefWindowProc( hwnd, message, wparam, lparam );
	}
	return 0;
}

Vertex shader :
#version 330
layout(location = 0)in vec3 vertex;
layout(location = 1)in vec2 texture;
out vec2  _texture;
uniform mat4 projectionmatrix;
uniform mat4 modelmatrix;
void main(void)
{
mat4 mvpMatrix = projectionmatrix * modelmatrix;
_texture = texture;
	gl_Position = mvpMatrix * vec4(vertex, 1.0);
}

Fragment Shader :
#version 330
in vec2 _texture;
out vec4 fragcolor;
uniform sampler2D gsample;
void main(void)
{
fragcolor = texture2D(gsample, _texture);
}


Sponsor:

#2 clb   Members   -  Reputation: 1781

Like
2Likes
Like

Posted 10 June 2012 - 09:28 AM

#1 guideline: In debug mode, after each call to a glXXX function, call http://www.opengl.org/sdk/docs/man/xhtml/glGetError.xml . With OpenGL, you can never be sure, and you must at least detect the few problems OpenGL is capable of reporting. I call the following function after each glXXX call:

int Graphics::CheckErrors(const char *hintOperation)
{
#ifndef OPTIMIZED_RELEASE
GLenum returnError = 0;
GLenum error = GL_NO_ERROR+1;
int maxIters = 100; // Arbitrarily cap the number of iterations to avoid infinite loop on buggy drivers.
while(error != GL_NO_ERROR && maxIters-- > 0)
{
error = glGetError();
if (error != GL_NO_ERROR)
{
LOGW("glGetError: \"%s\" failed: Error %s (0x%X) received!\n", hintOperation, GetGLErrorString(error), (int)error);
returnError = error;
}
}
return returnError;
#else
return 0;
#endif
}
Then I do something along the lines of
#define GL_CALL(x) { x; Graphics::CheckErrors(#x); }

GL_CALL(glBindVertexArray(vb->vertexArrayObject));

#2: Use gDEBugger to peek inside your application execution. This allows you to verify GL server side state and confirm that everything is as you expected.

I find that the combination of #1 and #2 has allowed me to get past all the problems I've encountered, without having to spend days scratching my head.
Me+PC=clb.demon.fi | C++ Math and Geometry library: MathGeoLib, test it live! | C++ Game Networking: kNet | 2D Bin Packing: RectangleBinPack | Use gcc/clang/emcc from VS: vs-tool | Resume+Portfolio | gfxapi, test it live!

#3 PiouPiou   Members   -  Reputation: 105

Like
0Likes
Like

Posted 10 June 2012 - 11:09 AM

thanks Clb,

I delete all the verification that the source is as short as possible.

but it's true that I should use glGetError but even with use are
this does not solve my problem :-(

#4 clb   Members   -  Reputation: 1781

Like
0Likes
Like

Posted 10 June 2012 - 01:11 PM

With all the glGetError checks in place, does any of them report any errors? What did gDEBugger say?
Me+PC=clb.demon.fi | C++ Math and Geometry library: MathGeoLib, test it live! | C++ Game Networking: kNet | 2D Bin Packing: RectangleBinPack | Use gcc/clang/emcc from VS: vs-tool | Resume+Portfolio | gfxapi, test it live!

#5 PiouPiou   Members   -  Reputation: 105

Like
0Likes
Like

Posted 10 June 2012 - 03:09 PM

I'm an idiot

in fact I did not put glGetError everywhere, I thought one was enough to know if opengl met an error.
I was in my wrong :-(
my problem of texture came from :

glTexImage2D (GL_TEXTURE_2D, 0, 3, taillex, tailley, 0, GL_RGB, GL_UNSIGNED_BYTE, data);

glGetError tells me an "GL_INVALID_ENUM"

must be replaced by:

glTexImage2D (GL_TEXTURE_2D, 0, GL_RGB, taillex, tailley, 0, GL_RGB, GL_UNSIGNED_BYTE, data);


I have not had time yet to test gldebugger (but I'll do it soon)

thank you very much Clb for helping me find this bug.

another question:

attriblist int [] = {WGL_CONTEXT_MAJOR_VERSION_ARB, MAJOR, WGL_CONTEXT_MINOR_VERSION_ARB, MINOR, WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, 0, 0};

and

attriblist int [] = {WGL_CONTEXT_MAJOR_VERSION_ARB, MAJOR, WGL_CONTEXT_MINOR_VERSION_ARB, MINOR, 0};

appears to be identical?

#6 Yours3!f   Members   -  Reputation: 1336

Like
0Likes
Like

Posted 16 June 2012 - 01:31 PM

I hacked sfml a bit to have this functionality, here's how:
http://en.sfml-dev.org/forums/index.php?topic=7903.0




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS