From 789169d70d24ff2c1c9804f0149d0508de6dfcfa Mon Sep 17 00:00:00 2001 From: Enrique Date: Mon, 6 Jan 2025 00:50:11 +0100 Subject: First upload --- ogl/ogl.c | 508 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 508 insertions(+) create mode 100755 ogl/ogl.c (limited to 'ogl/ogl.c') diff --git a/ogl/ogl.c b/ogl/ogl.c new file mode 100755 index 0000000..d2b7ff5 --- /dev/null +++ b/ogl/ogl.c @@ -0,0 +1,508 @@ +#include "ogl.h" + + +BOOL LoadExtensionList(void){ + wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB"); + if(wglChoosePixelFormatARB == NULL){ + return FALSE; + } + wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB"); + if(wglCreateContextAttribsARB == NULL){ + return FALSE; + } + wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT"); + if(wglSwapIntervalEXT == NULL){ + return FALSE; + } + glAttachShader = (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader"); + if(!glAttachShader){ + return FALSE; + } + + glBindBuffer = (PFNGLBINDBUFFERPROC)wglGetProcAddress("glBindBuffer"); + if(!glBindBuffer){ + return FALSE; + } + + glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)wglGetProcAddress("glBindVertexArray"); + if(!glBindVertexArray){ + return FALSE; + } + + glBufferData = (PFNGLBUFFERDATAPROC)wglGetProcAddress("glBufferData"); + if(!glBufferData){ + return FALSE; + } + + glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader"); + if(!glCompileShader){ + return FALSE; + } + + glCreateProgram = (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram"); + if(!glCreateProgram){ + return FALSE; + } + + glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader"); + if(!glCreateShader){ + return FALSE; + } + + glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)wglGetProcAddress("glDeleteBuffers"); + if(!glDeleteBuffers){ + return FALSE; + } + + glDeleteProgram = (PFNGLDELETEPROGRAMPROC)wglGetProcAddress("glDeleteProgram"); + if(!glDeleteProgram){ + return FALSE; + } + + glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader"); + if(!glDeleteShader){ + return FALSE; + } + + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)wglGetProcAddress("glDeleteVertexArrays"); + if(!glDeleteVertexArrays){ + return FALSE; + } + + glDetachShader = (PFNGLDETACHSHADERPROC)wglGetProcAddress("glDetachShader"); + if(!glDetachShader){ + return FALSE; + } + + glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glEnableVertexAttribArray"); + if(!glEnableVertexAttribArray){ + return FALSE; + } + + glGenBuffers = (PFNGLGENBUFFERSPROC)wglGetProcAddress("glGenBuffers"); + if(!glGenBuffers){ + return FALSE; + } + + glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)wglGetProcAddress("glGenVertexArrays"); + if(!glGenVertexArrays){ + return FALSE; + } + + glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)wglGetProcAddress("glGetAttribLocation"); + if(!glGetAttribLocation){ + return FALSE; + } + + glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)wglGetProcAddress("glGetProgramInfoLog"); + if(!glGetProgramInfoLog){ + return FALSE; + } + + glGetProgramiv = (PFNGLGETPROGRAMIVPROC)wglGetProcAddress("glGetProgramiv"); + if(!glGetProgramiv){ + return FALSE; + } + + glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog"); + if(!glGetShaderInfoLog){ + return FALSE; + } + + glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv"); + if(!glGetShaderiv){ + return FALSE; + } + + glLinkProgram = (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram"); + if(!glLinkProgram){ + return FALSE; + } + + glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource"); + if(!glShaderSource){ + return FALSE; + } + + glUseProgram = (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram"); + if(!glUseProgram){ + return FALSE; + } + + glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer"); + if(!glVertexAttribPointer){ + return FALSE; + } + + glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)wglGetProcAddress("glBindAttribLocation"); + if(!glBindAttribLocation){ + return FALSE; + } + + glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)wglGetProcAddress("glGetUniformLocation"); + if(!glGetUniformLocation){ + return FALSE; + } + + glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv"); + if(!glUniformMatrix4fv){ + return FALSE; + } + + glActiveTexture = (PFNGLACTIVETEXTUREPROC)wglGetProcAddress("glActiveTexture"); + if(!glActiveTexture){ + return FALSE; + } + + glUniform1i = (PFNGLUNIFORM1IPROC)wglGetProcAddress("glUniform1i"); + if(!glUniform1i){ + return FALSE; + } + + glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)wglGetProcAddress("glGenerateMipmap"); + if(!glGenerateMipmap){ + return FALSE; + } + + glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glDisableVertexAttribArray"); + if(!glDisableVertexAttribArray){ + return FALSE; + } + + glUniform1f = (PFNGLUNIFORM1FPROC)wglGetProcAddress("glUniform1f"); + if(!glUniform1f){ + return FALSE; + } + + glUniform2f = (PFNGLUNIFORM2FPROC)wglGetProcAddress("glUniform2f"); + if(!glUniform2f){ + return FALSE; + } + + glUniform3f = (PFNGLUNIFORM3FPROC)wglGetProcAddress("glUniform3f"); + if(!glUniform3f){ + return FALSE; + } + + glUniform4f = (PFNGLUNIFORM4FPROC)wglGetProcAddress("glUniform4f"); + if(!glUniform4f){ + return FALSE; + } + + glUniform1i = (PFNGLUNIFORM1IPROC)wglGetProcAddress("glUniform1i"); + if(!glUniform1i){ + return FALSE; + } + + glUniform2i = (PFNGLUNIFORM2IPROC)wglGetProcAddress("glUniform2i"); + if(!glUniform2i){ + return FALSE; + } + + glUniform3i = (PFNGLUNIFORM3IPROC)wglGetProcAddress("glUniform3i"); + if(!glUniform3i){ + return FALSE; + } + + glUniform4i = (PFNGLUNIFORM4IPROC)wglGetProcAddress("glUniform4i"); + if(!glUniform4i){ + return FALSE; + } + + glUniform1ui = (PFNGLUNIFORM1UIPROC)wglGetProcAddress("glUniform1ui"); + if(!glUniform1ui){ + return FALSE; + } + + glUniform2ui = (PFNGLUNIFORM2UIPROC)wglGetProcAddress("glUniform2ui"); + if(!glUniform2ui){ + return FALSE; + } + + glUniform3ui = (PFNGLUNIFORM3UIPROC)wglGetProcAddress("glUniform3ui"); + if(!glUniform3ui){ + return FALSE; + } + + glUniform4ui = (PFNGLUNIFORM4UIPROC)wglGetProcAddress("glUniform4ui"); + if(!glUniform4ui){ + return FALSE; + } + + glUniform1fv = (PFNGLUNIFORM1FVPROC)wglGetProcAddress("glUniform1fv"); + if(!glUniform1fv){ + return FALSE; + } + + glUniform2fv = (PFNGLUNIFORM2FVPROC)wglGetProcAddress("glUniform2fv"); + if(!glUniform2fv){ + return FALSE; + } + + glUniform3fv = (PFNGLUNIFORM3FVPROC)wglGetProcAddress("glUniform3fv"); + if(!glUniform3fv){ + return FALSE; + } + + glUniform4fv = (PFNGLUNIFORM4FVPROC)wglGetProcAddress("glUniform4fv"); + if(!glUniform4fv){ + return FALSE; + } + + glUniform1iv = (PFNGLUNIFORM1IVPROC)wglGetProcAddress("glUniform1iv"); + if(!glUniform1iv){ + return FALSE; + } + + glUniform2iv = (PFNGLUNIFORM2IVPROC)wglGetProcAddress("glUniform2iv"); + if(!glUniform2iv){ + return FALSE; + } + + glUniform3iv = (PFNGLUNIFORM3IVPROC)wglGetProcAddress("glUniform3iv"); + if(!glUniform3iv){ + return FALSE; + } + + glUniform4iv = (PFNGLUNIFORM4IVPROC)wglGetProcAddress("glUniform4iv"); + if(!glUniform4iv){ + return FALSE; + } + + glUniform1uiv = (PFNGLUNIFORM1UIVPROC)wglGetProcAddress("glUniform1uiv"); + if(!glUniform1uiv){ + return FALSE; + } + + glUniform2uiv = (PFNGLUNIFORM2UIVPROC)wglGetProcAddress("glUniform2uiv"); + if(!glUniform2uiv){ + return FALSE; + } + + glUniform3uiv = (PFNGLUNIFORM3UIVPROC)wglGetProcAddress("glUniform3uiv"); + if(!glUniform3uiv){ + return FALSE; + } + + glUniform4uiv = (PFNGLUNIFORM4UIVPROC)wglGetProcAddress("glUniform4uiv"); + if(!glUniform4uiv){ + return FALSE; + } + + glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)wglGetProcAddress("glUniformMatrix2fv"); + if(!glUniformMatrix2fv){ + return FALSE; + } + + glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)wglGetProcAddress("glUniformMatrix3fv"); + if(!glUniformMatrix3fv){ + return FALSE; + } + + glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv"); + if(!glUniformMatrix4fv){ + return FALSE; + } + + glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)wglGetProcAddress("glUniformMatrix2x3fv"); + if(!glUniformMatrix2x3fv){ + return FALSE; + } + + glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)wglGetProcAddress("glUniformMatrix3x2fv"); + if(!glUniformMatrix3x2fv){ + return FALSE; + } + + glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)wglGetProcAddress("glUniformMatrix2x4fv"); + if(!glUniformMatrix2x4fv){ + return FALSE; + } + + glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)wglGetProcAddress("glUniformMatrix4x2fv"); + if(!glUniformMatrix4x2fv){ + return FALSE; + } + + glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)wglGetProcAddress("glUniformMatrix3x4fv"); + if(!glUniformMatrix3x4fv){ + return FALSE; + } + + glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)wglGetProcAddress("glUniformMatrix4x3fv"); + if(!glUniformMatrix4x3fv){ + return FALSE; + } + + return TRUE; +} + +// TODO: error handling +int InitializeOpenGLExtensions(void){ + int error = 0; + + WNDCLASS dummyClass = { + .style = CS_OWNDC, + .lpfnWndProc = DefWindowProc, + .hInstance = GetModuleHandle(0), + .lpszClassName = "dummyClass", + }; + if(RegisterClassA(&dummyClass) == 0){ + error = 1; + goto end_class; + } + + HWND dummyWindow = CreateWindowEx( + 0, + dummyClass.lpszClassName, + "dummyWindow", + 0, + CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, + NULL, NULL, + dummyClass.hInstance, + NULL + ); + if(dummyWindow == NULL) { + error = 2; + goto end_window; + } + HDC dummyDC = GetDC(dummyWindow); + if(dummyDC == NULL){ + error = 3; + goto end_DC; + } + + PIXELFORMATDESCRIPTOR dummyPFD = { + .nSize = sizeof(PIXELFORMATDESCRIPTOR), + .nVersion = 1, + .dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, + .iPixelType = PFD_TYPE_RGBA, + .cColorBits = 32, + .cDepthBits = 24, + .cStencilBits = 8 + }; + int pf = ChoosePixelFormat(dummyDC, &dummyPFD); + if(pf == 0){ + error = 4; + goto end_DC; + } + if(SetPixelFormat(dummyDC, pf, &dummyPFD) == FALSE){ + error = 5; + goto end_DC; + } + + HGLRC dummyContext = wglCreateContext(dummyDC); + if(dummyContext == NULL){ + error = 6; + goto end_context; + } + if(wglMakeCurrent(dummyDC, dummyContext) == FALSE){ + error = 7; + goto end_current; + } + + if(LoadExtensionList() == FALSE){ + error = 8; + } + +end_current: + if(wglMakeCurrent(NULL, NULL) == FALSE){ + error = 9; + } +end_context: + if(wglDeleteContext(dummyContext) == FALSE){ + error = 10; + }else{ + dummyContext = NULL; + } +end_DC: + if(ReleaseDC(dummyWindow, dummyDC) == 0){ + error = 11; + }else{ + dummyDC = NULL; + } +end_window: + if(DestroyWindow(dummyWindow) == 0){ + error = 12; + }else{ + dummyWindow = NULL; + } +end_class: + if(UnregisterClass(dummyClass.lpszClassName, dummyClass.hInstance) == 0){ + error = 13; + } + + return error; +} + +// TODO: abstract away to a platform-independent library +static long getFileSize(FILE *fp){ + long curr = ftell(fp); + fseek(fp, 0, SEEK_END); + long size = ftell(fp); + fseek(fp, curr, SEEK_SET); + return size; +} + +GLuint LoadShaders(char *vertex_file_path, char *fragment_file_path){ + GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER); + GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); + + // use str.h + char *VertexShaderCode; + FILE *VertexShaderStream = fopen(vertex_file_path, "rb"); + if(VertexShaderStream != NULL){ + long fsize = getFileSize(VertexShaderStream); + VertexShaderCode = calloc(fsize, sizeof(char)); + fread(VertexShaderCode, sizeof(char), fsize, VertexShaderStream); + fclose(VertexShaderStream); + }else{ + return 0; + } + + // use str.h + char *FragmentShaderCode; + FILE *FragmentShaderStream = fopen(fragment_file_path, "rb"); + if(FragmentShaderStream != NULL){ + long fsize = getFileSize(VertexShaderStream); + FragmentShaderCode = calloc(fsize, sizeof(char)); + fread(FragmentShaderCode, sizeof(char), fsize, FragmentShaderStream); + fclose(FragmentShaderStream); + }else{ + return 0; + } + + GLint Result; + + glShaderSource(VertexShaderID, 1, &VertexShaderCode, NULL); + glCompileShader(VertexShaderID); + glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result); + if(Result != GL_TRUE){ + return 0; + } + + glShaderSource(FragmentShaderID, 1, &FragmentShaderCode , NULL); + glCompileShader(FragmentShaderID); + glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result); + if(Result != GL_TRUE){ + return 0; + } + + GLuint ProgramID = glCreateProgram(); + glAttachShader(ProgramID, VertexShaderID); + glAttachShader(ProgramID, FragmentShaderID); + glLinkProgram(ProgramID); + + glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result); + if(Result != GL_TRUE){ + return 0; + } + + glDetachShader(ProgramID, VertexShaderID); + glDetachShader(ProgramID, FragmentShaderID); + glDeleteShader(VertexShaderID); + glDeleteShader(FragmentShaderID); + + return ProgramID; +} + -- cgit v1.2.3