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


#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.

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 :-(

With all the glGetError checks in place, does any of them report any errors? What did gDEBugger say?

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?