Jump to content

  • Log In with Google      Sign In   
  • Create Account


PiouPiou

Member Since 07 Jun 2012
Offline Last Active Jun 11 2012 10:34 AM

Topics I've Started

Open a 3.2 OPENGL context or superior

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

PARTNERS