mgs/gedeng
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add Parallax Demo + some bugfixes

Browse Source 
The initialization order in the Application was wrong, so some code has been moved from run to the constructor.
This commit is contained in:
karl 2021-05-03 22:23:15 +02:00
parent 3dacb0c095
commit 482116018f
6 changed files with 823 additions and 720 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SConstruct
View File

@ -10,6 +10,10 @@ def add_strict_compile_flags(env):
env.Append(CCFLAGS=["-Wall", "-Wextra", "-pedantic", "-std=c++17"]) env.Append(CCFLAGS=["-Wall", "-Wextra", "-pedantic", "-std=c++17"])
def add_debug_compile_flags(env):
env.Append(CCFLAGS=["-g"])
# Create the environment and create a Compilation Database for use in VSCodium # Create the environment and create a Compilation Database for use in VSCodium
env = Environment(tools=['default', 'compilation_db']) env = Environment(tools=['default', 'compilation_db'])
env.CompilationDatabase() env.CompilationDatabase()
@ -45,9 +49,11 @@ testEnv.Append(LINKFLAGS=[
add_third_party_includes(testEnv) add_third_party_includes(testEnv)
add_strict_compile_flags(testEnv) add_strict_compile_flags(testEnv)
add_debug_compile_flags(testEnv)
# Build the test programs # Build the test programs
catch_cpp = "test/catch_amalgamated.cpp" catch_cpp = "test/catch_amalgamated.cpp"
testEnv.Program('test/bin/vector-test.out', [catch_cpp, 'test/vector/vector-test.cpp']) testEnv.Program('test/bin/vector-test.out', [catch_cpp, 'test/vector/vector-test.cpp'])
testEnv.Program('test/bin/test-app.out', Glob('test/test-app/*.cpp')) testEnv.Program('test/bin/test-app.out', Glob('test/test-app/*.cpp'))
testEnv.Program('test/bin/parallax-demo.out', Glob('test/parallax-demo/*.cpp'))

10
cpp/Application.cpp
View File

@ -6,12 +6,16 @@
namespace Gedeng { namespace Gedeng {
void Application::run() { Application::Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y,
String window_name)
: MS_PER_UPDATE(ms_per_update), WINDOW_SIZE_X(window_size_x), WINDOW_SIZE_Y(window_size_y),
WINDOW_NAME(window_name) {
// Setup Rendering // Setup Rendering
// FIXME: Make these parameters variable, maybe move this to a different function
RenderBackend::initialize_window(WINDOW_SIZE_X, WINDOW_SIZE_Y, WINDOW_NAME); RenderBackend::initialize_window(WINDOW_SIZE_X, WINDOW_SIZE_Y, WINDOW_NAME);
Input::initialize(RenderBackend::get_window()); Input::initialize(RenderBackend::get_window());
}
void Application::run() {
unsigned long previous_time_ms = Time::get_time_ms(); unsigned long previous_time_ms = Time::get_time_ms();
unsigned long time_until_fixed_update_ms = 0.0; unsigned long time_until_fixed_update_ms = 0.0;
@ -31,6 +35,8 @@ void Application::run() {
} }
dynamic_update(static_cast<double>(elapsed_time_ms) / 1000.0); dynamic_update(static_cast<double>(elapsed_time_ms) / 1000.0);
RenderBackend::render();
} }
} }

203
cpp/vendor/glad.c vendored
View File

@ -19,12 +19,12 @@
https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D4.3 https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D4.3
*/ */
#include <glad/glad.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <glad/glad.h>
static void* get_proc(const char *namez); static void *get_proc(const char *namez);
#if defined(_WIN32) || defined(__CYGWIN__) #if defined(_WIN32) || defined(__CYGWIN__)
#ifndef _WINDOWS_ #ifndef _WINDOWS_
@ -33,34 +33,33 @@ static void* get_proc(const char *namez);
#include <windows.h> #include <windows.h>
static HMODULE libGL; static HMODULE libGL;
typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); typedef void *(APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char *);
static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
#ifdef _MSC_VER #ifdef _MSC_VER
#ifdef __has_include #ifdef __has_include
#if __has_include(<winapifamily.h>) #if __has_include(<winapifamily.h>)
#define HAVE_WINAPIFAMILY 1 #define HAVE_WINAPIFAMILY 1
#endif #endif
#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
#define HAVE_WINAPIFAMILY 1 #define HAVE_WINAPIFAMILY 1
#endif #endif
#endif #endif
#ifdef HAVE_WINAPIFAMILY #ifdef HAVE_WINAPIFAMILY
#include <winapifamily.h> #include <winapifamily.h>
#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define IS_UWP 1 #define IS_UWP 1
#endif #endif
#endif #endif
static static int open_gl(void) {
int open_gl(void) {
#ifndef IS_UWP #ifndef IS_UWP
libGL = LoadLibraryW(L"opengl32.dll"); libGL = LoadLibraryW(L"opengl32.dll");
if(libGL != NULL) { if (libGL != NULL) {
void (* tmp)(void); void (*tmp)(void);
tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); tmp = (void (*)(void))GetProcAddress(libGL, "wglGetProcAddress");
gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE)tmp;
return gladGetProcAddressPtr != NULL; return gladGetProcAddressPtr != NULL;
} }
#endif #endif
@ -68,45 +67,40 @@ int open_gl(void) {
return 0; return 0;
} }
static static void close_gl(void) {
void close_gl(void) { if (libGL != NULL) {
if(libGL != NULL) { FreeLibrary((HMODULE)libGL);
FreeLibrary((HMODULE) libGL);
libGL = NULL; libGL = NULL;
} }
} }
#else #else
#include <dlfcn.h> #include <dlfcn.h>
static void* libGL; static void *libGL;
#if !defined(__APPLE__) && !defined(__HAIKU__) #if !defined(__APPLE__) && !defined(__HAIKU__)
typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); typedef void *(APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char *);
static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr;
#endif #endif
static static int open_gl(void) {
int open_gl(void) {
#ifdef __APPLE__ #ifdef __APPLE__
static const char *NAMES[] = { static const char *NAMES[] = {"../Frameworks/OpenGL.framework/OpenGL",
"../Frameworks/OpenGL.framework/OpenGL",
"/Library/Frameworks/OpenGL.framework/OpenGL", "/Library/Frameworks/OpenGL.framework/OpenGL",
"/System/Library/Frameworks/OpenGL.framework/OpenGL", "/System/Library/Frameworks/OpenGL.framework/OpenGL",
"/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"};
};
#else #else
static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; static const char *NAMES[] = {"libGL.so.1", "libGL.so"};
#endif #endif
unsigned int index = 0; unsigned int index = 0;
for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { for (index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) {
libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL);
if(libGL != NULL) { if (libGL != NULL) {
#if defined(__APPLE__) || defined(__HAIKU__) #if defined(__APPLE__) || defined(__HAIKU__)
return 1; return 1;
#else #else
gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, "glXGetProcAddressARB");
"glXGetProcAddressARB");
return gladGetProcAddressPtr != NULL; return gladGetProcAddressPtr != NULL;
#endif #endif
} }
@ -115,28 +109,26 @@ int open_gl(void) {
return 0; return 0;
} }
static static void close_gl(void) {
void close_gl(void) { if (libGL != NULL) {
if(libGL != NULL) {
dlclose(libGL); dlclose(libGL);
libGL = NULL; libGL = NULL;
} }
} }
#endif #endif
static static void *get_proc(const char *namez) {
void* get_proc(const char *namez) { void *result = NULL;
void* result = NULL; if (libGL == NULL) return NULL;
if(libGL == NULL) return NULL;
#if !defined(__APPLE__) && !defined(__HAIKU__) #if !defined(__APPLE__) && !defined(__HAIKU__)
if(gladGetProcAddressPtr != NULL) { if (gladGetProcAddressPtr != NULL) {
result = gladGetProcAddressPtr(namez); result = gladGetProcAddressPtr(namez);
} }
#endif #endif
if(result == NULL) { if (result == NULL) {
#if defined(_WIN32) || defined(__CYGWIN__) #if defined(_WIN32) || defined(__CYGWIN__)
result = (void*)GetProcAddress((HMODULE) libGL, namez); result = (void *)GetProcAddress((HMODULE)libGL, namez);
#else #else
result = dlsym(libGL, namez); result = dlsym(libGL, namez);
#endif #endif
@ -148,7 +140,7 @@ void* get_proc(const char *namez) {
int gladLoadGL(void) { int gladLoadGL(void) {
int status = 0; int status = 0;
if(open_gl()) { if (open_gl()) {
status = gladLoadGLLoader(&get_proc); status = gladLoadGLLoader(&get_proc);
close_gl(); close_gl();
} }
@ -156,7 +148,7 @@ int gladLoadGL(void) {
return status; return status;
} }
struct gladGLversionStruct GLVersion = { 0, 0 }; struct gladGLversionStruct GLVersion = {0, 0};
#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
#define _GLAD_IS_SOME_NEW_VERSION 1 #define _GLAD_IS_SOME_NEW_VERSION 1
@ -171,7 +163,7 @@ static char **exts_i = NULL;
static int get_exts(void) { static int get_exts(void) {
#ifdef _GLAD_IS_SOME_NEW_VERSION #ifdef _GLAD_IS_SOME_NEW_VERSION
if(max_loaded_major < 3) { if (max_loaded_major < 3) {
#endif #endif
exts = (const char *)glGetString(GL_EXTENSIONS); exts = (const char *)glGetString(GL_EXTENSIONS);
#ifdef _GLAD_IS_SOME_NEW_VERSION #ifdef _GLAD_IS_SOME_NEW_VERSION
@ -188,13 +180,13 @@ static int get_exts(void) {
return 0; return 0;
} }
for(index = 0; index < (unsigned)num_exts_i; index++) { for (index = 0; index < (unsigned)num_exts_i; index++) {
const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); const char *gl_str_tmp = (const char *)glGetStringi(GL_EXTENSIONS, index);
size_t len = strlen(gl_str_tmp); size_t len = strlen(gl_str_tmp);
char *local_str = (char*)malloc((len+1) * sizeof(char)); char *local_str = (char *)malloc((len + 1) * sizeof(char));
if(local_str != NULL) { if (local_str != NULL) {
memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); memcpy(local_str, gl_str_tmp, (len + 1) * sizeof(char));
} }
exts_i[index] = local_str; exts_i[index] = local_str;
} }
@ -206,7 +198,7 @@ static int get_exts(void) {
static void free_exts(void) { static void free_exts(void) {
if (exts_i != NULL) { if (exts_i != NULL) {
int index; int index;
for(index = 0; index < num_exts_i; index++) { for (index = 0; index < num_exts_i; index++) {
free((char *)exts_i[index]); free((char *)exts_i[index]);
} }
free((void *)exts_i); free((void *)exts_i);
@ -216,25 +208,24 @@ static void free_exts(void) {
static int has_ext(const char *ext) { static int has_ext(const char *ext) {
#ifdef _GLAD_IS_SOME_NEW_VERSION #ifdef _GLAD_IS_SOME_NEW_VERSION
if(max_loaded_major < 3) { if (max_loaded_major < 3) {
#endif #endif
const char *extensions; const char *extensions;
const char *loc; const char *loc;
const char *terminator; const char *terminator;
extensions = exts; extensions = exts;
if(extensions == NULL || ext == NULL) { if (extensions == NULL || ext == NULL) {
return 0; return 0;
} }
while(1) { while (1) {
loc = strstr(extensions, ext); loc = strstr(extensions, ext);
if(loc == NULL) { if (loc == NULL) {
return 0; return 0;
} }
terminator = loc + strlen(ext); terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') && if ((loc == extensions || *(loc - 1) == ' ') && (*terminator == ' ' || *terminator == '\0')) {
(*terminator == ' ' || *terminator == '\0')) {
return 1; return 1;
} }
extensions = terminator; extensions = terminator;
@ -242,11 +233,11 @@ static int has_ext(const char *ext) {
#ifdef _GLAD_IS_SOME_NEW_VERSION #ifdef _GLAD_IS_SOME_NEW_VERSION
} else { } else {
int index; int index;
if(exts_i == NULL) return 0; if (exts_i == NULL) return 0;
for(index = 0; index < num_exts_i; index++) { for (index = 0; index < num_exts_i; index++) {
const char *e = exts_i[index]; const char *e = exts_i[index];
if(exts_i[index] != NULL && strcmp(e, ext) == 0) { if (exts_i[index] != NULL && strcmp(e, ext) == 0) {
return 1; return 1;
} }
} }
@ -836,7 +827,7 @@ PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf = NULL;
PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL; PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL;
PFNGLWAITSYNCPROC glad_glWaitSync = NULL; PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
static void load_GL_VERSION_1_0(GLADloadproc load) { static void load_GL_VERSION_1_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_0) return; if (!GLAD_GL_VERSION_1_0) return;
glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace");
glad_glHint = (PFNGLHINTPROC)load("glHint"); glad_glHint = (PFNGLHINTPROC)load("glHint");
@ -887,7 +878,7 @@ static void load_GL_VERSION_1_0(GLADloadproc load) {
glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport");
} }
static void load_GL_VERSION_1_1(GLADloadproc load) { static void load_GL_VERSION_1_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_1) return; if (!GLAD_GL_VERSION_1_1) return;
glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset");
@ -903,14 +894,14 @@ static void load_GL_VERSION_1_1(GLADloadproc load) {
glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture");
} }
static void load_GL_VERSION_1_2(GLADloadproc load) { static void load_GL_VERSION_1_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_2) return; if (!GLAD_GL_VERSION_1_2) return;
glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements");
glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D");
glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D");
glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D");
} }
static void load_GL_VERSION_1_3(GLADloadproc load) { static void load_GL_VERSION_1_3(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_3) return; if (!GLAD_GL_VERSION_1_3) return;
glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage");
glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D");
@ -922,7 +913,7 @@ static void load_GL_VERSION_1_3(GLADloadproc load) {
glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage");
} }
static void load_GL_VERSION_1_4(GLADloadproc load) { static void load_GL_VERSION_1_4(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_4) return; if (!GLAD_GL_VERSION_1_4) return;
glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements");
@ -934,7 +925,7 @@ static void load_GL_VERSION_1_4(GLADloadproc load) {
glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation");
} }
static void load_GL_VERSION_1_5(GLADloadproc load) { static void load_GL_VERSION_1_5(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_5) return; if (!GLAD_GL_VERSION_1_5) return;
glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
@ -956,7 +947,7 @@ static void load_GL_VERSION_1_5(GLADloadproc load) {
glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv");
} }
static void load_GL_VERSION_2_0(GLADloadproc load) { static void load_GL_VERSION_2_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_2_0) return; if (!GLAD_GL_VERSION_2_0) return;
glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate");
glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers");
glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate");
@ -1052,7 +1043,7 @@ static void load_GL_VERSION_2_0(GLADloadproc load) {
glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
} }
static void load_GL_VERSION_2_1(GLADloadproc load) { static void load_GL_VERSION_2_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_2_1) return; if (!GLAD_GL_VERSION_2_1) return;
glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv");
@ -1061,7 +1052,7 @@ static void load_GL_VERSION_2_1(GLADloadproc load) {
glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv");
} }
static void load_GL_VERSION_3_0(GLADloadproc load) { static void load_GL_VERSION_3_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_0) return; if (!GLAD_GL_VERSION_3_0) return;
glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski");
glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
@ -1135,10 +1126,12 @@ static void load_GL_VERSION_3_0(GLADloadproc load) {
glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D");
glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D");
glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer");
glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); glad_glGetFramebufferAttachmentParameteriv =
(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv");
glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap");
glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer");
glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); glad_glRenderbufferStorageMultisample =
(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample");
glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer");
glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange");
glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange");
@ -1148,7 +1141,7 @@ static void load_GL_VERSION_3_0(GLADloadproc load) {
glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray");
} }
static void load_GL_VERSION_3_1(GLADloadproc load) { static void load_GL_VERSION_3_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_1) return; if (!GLAD_GL_VERSION_3_1) return;
glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer");
@ -1166,10 +1159,11 @@ static void load_GL_VERSION_3_1(GLADloadproc load) {
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
} }
static void load_GL_VERSION_3_2(GLADloadproc load) { static void load_GL_VERSION_3_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_2) return; if (!GLAD_GL_VERSION_3_2) return;
glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); glad_glDrawElementsInstancedBaseVertex =
(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex");
glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex");
glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex");
glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync");
@ -1188,7 +1182,7 @@ static void load_GL_VERSION_3_2(GLADloadproc load) {
glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski");
} }
static void load_GL_VERSION_3_3(GLADloadproc load) { static void load_GL_VERSION_3_3(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_3) return; if (!GLAD_GL_VERSION_3_3) return;
glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed");
glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex");
glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers");
@ -1249,7 +1243,7 @@ static void load_GL_VERSION_3_3(GLADloadproc load) {
glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv");
} }
static void load_GL_VERSION_4_0(GLADloadproc load) { static void load_GL_VERSION_4_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_0) return; if (!GLAD_GL_VERSION_4_0) return;
glad_glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)load("glMinSampleShading"); glad_glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)load("glMinSampleShading");
glad_glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)load("glBlendEquationi"); glad_glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)load("glBlendEquationi");
glad_glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)load("glBlendEquationSeparatei"); glad_glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)load("glBlendEquationSeparatei");
@ -1278,7 +1272,8 @@ static void load_GL_VERSION_4_0(GLADloadproc load) {
glad_glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)load("glGetSubroutineUniformLocation"); glad_glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)load("glGetSubroutineUniformLocation");
glad_glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)load("glGetSubroutineIndex"); glad_glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)load("glGetSubroutineIndex");
glad_glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)load("glGetActiveSubroutineUniformiv"); glad_glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)load("glGetActiveSubroutineUniformiv");
glad_glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)load("glGetActiveSubroutineUniformName"); glad_glGetActiveSubroutineUniformName =
(PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)load("glGetActiveSubroutineUniformName");
glad_glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)load("glGetActiveSubroutineName"); glad_glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)load("glGetActiveSubroutineName");
glad_glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)load("glUniformSubroutinesuiv"); glad_glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)load("glUniformSubroutinesuiv");
glad_glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)load("glGetUniformSubroutineuiv"); glad_glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)load("glGetUniformSubroutineuiv");
@ -1298,7 +1293,7 @@ static void load_GL_VERSION_4_0(GLADloadproc load) {
glad_glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)load("glGetQueryIndexediv"); glad_glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)load("glGetQueryIndexediv");
} }
static void load_GL_VERSION_4_1(GLADloadproc load) { static void load_GL_VERSION_4_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_1) return; if (!GLAD_GL_VERSION_4_1) return;
glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler"); glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler");
glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary"); glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary");
glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat"); glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat");
@ -1390,22 +1385,28 @@ static void load_GL_VERSION_4_1(GLADloadproc load) {
glad_glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)load("glGetDoublei_v"); glad_glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)load("glGetDoublei_v");
} }
static void load_GL_VERSION_4_2(GLADloadproc load) { static void load_GL_VERSION_4_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_2) return; if (!GLAD_GL_VERSION_4_2) return;
glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance"); glad_glDrawArraysInstancedBaseInstance =
glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance"); (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance");
glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance"); glad_glDrawElementsInstancedBaseInstance =
(PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance");
glad_glDrawElementsInstancedBaseVertexBaseInstance =
(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)load("glGetInternalformativ"); glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)load("glGetInternalformativ");
glad_glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)load("glGetActiveAtomicCounterBufferiv"); glad_glGetActiveAtomicCounterBufferiv =
(PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)load("glGetActiveAtomicCounterBufferiv");
glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)load("glBindImageTexture"); glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)load("glBindImageTexture");
glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)load("glMemoryBarrier"); glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)load("glMemoryBarrier");
glad_glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)load("glTexStorage1D"); glad_glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)load("glTexStorage1D");
glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)load("glTexStorage2D"); glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)load("glTexStorage2D");
glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)load("glTexStorage3D"); glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)load("glTexStorage3D");
glad_glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced"); glad_glDrawTransformFeedbackInstanced =
glad_glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced"); (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced");
glad_glDrawTransformFeedbackStreamInstanced =
(PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced");
} }
static void load_GL_VERSION_4_3(GLADloadproc load) { static void load_GL_VERSION_4_3(GLADloadproc load) {
if(!GLAD_GL_VERSION_4_3) return; if (!GLAD_GL_VERSION_4_3) return;
glad_glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)load("glClearBufferData"); glad_glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)load("glClearBufferData");
glad_glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)load("glClearBufferSubData"); glad_glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)load("glClearBufferSubData");
glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)load("glDispatchCompute"); glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)load("glDispatchCompute");
@ -1427,7 +1428,8 @@ static void load_GL_VERSION_4_3(GLADloadproc load) {
glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)load("glGetProgramResourceName"); glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)load("glGetProgramResourceName");
glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)load("glGetProgramResourceiv"); glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)load("glGetProgramResourceiv");
glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)load("glGetProgramResourceLocation"); glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)load("glGetProgramResourceLocation");
glad_glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)load("glGetProgramResourceLocationIndex"); glad_glGetProgramResourceLocationIndex =
(PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)load("glGetProgramResourceLocationIndex");
glad_glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)load("glShaderStorageBlockBinding"); glad_glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)load("glShaderStorageBlockBinding");
glad_glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)load("glTexBufferRange"); glad_glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)load("glTexBufferRange");
glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)load("glTexStorage2DMultisample"); glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)load("glTexStorage2DMultisample");
@ -1466,15 +1468,10 @@ static void find_coreGL(void) {
*/ */
int i, major, minor; int i, major, minor;
const char* version; const char *version;
const char* prefixes[] = { const char *prefixes[] = {"OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", NULL};
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
version = (const char*) glGetString(GL_VERSION); version = (const char *)glGetString(GL_VERSION);
if (!version) return; if (!version) return;
for (i = 0; prefixes[i]; i++) { for (i = 0; prefixes[i]; i++) {
@ -1492,8 +1489,10 @@ static void find_coreGL(void) {
sscanf(version, "%d.%d", &major, &minor); sscanf(version, "%d.%d", &major, &minor);
#endif #endif
GLVersion.major = major; GLVersion.minor = minor; GLVersion.major = major;
max_loaded_major = major; max_loaded_minor = minor; GLVersion.minor = minor;
max_loaded_major = major;
max_loaded_minor = minor;
GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
@ -1517,10 +1516,11 @@ static void find_coreGL(void) {
} }
int gladLoadGLLoader(GLADloadproc load) { int gladLoadGLLoader(GLADloadproc load) {
GLVersion.major = 0; GLVersion.minor = 0; GLVersion.major = 0;
GLVersion.minor = 0;
glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
if(glGetString == NULL) return 0; if (glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0; if (glGetString(GL_VERSION) == NULL) return 0;
find_coreGL(); find_coreGL();
load_GL_VERSION_1_0(load); load_GL_VERSION_1_0(load);
load_GL_VERSION_1_1(load); load_GL_VERSION_1_1(load);
@ -1542,4 +1542,3 @@ int gladLoadGLLoader(GLADloadproc load) {
if (!find_extensionsGL()) return 0; if (!find_extensionsGL()) return 0;
return GLVersion.major != 0 || GLVersion.minor != 0; return GLVersion.major != 0 || GLVersion.minor != 0;
} }

6
include/Gedeng/Application.h
View File

@ -6,10 +6,8 @@ namespace Gedeng {
class Application { class Application {
public: public:
Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y, String window_name) Application(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y,
: MS_PER_UPDATE(ms_per_update), WINDOW_SIZE_X(window_size_x), WINDOW_SIZE_Y(window_size_y), String window_name);
WINDOW_NAME(window_name) {
}
// Virtual since this class will be inherited by user-created applications // Virtual since this class will be inherited by user-created applications
virtual ~Application() = default; virtual ~Application() = default;

14
include/Gedeng/Shader.h
View File

@ -2,7 +2,11 @@
// Adapted from LearnOpenGL // Adapted from LearnOpenGL
// Must be the first include
#include <glad/glad.h> #include <glad/glad.h>
// Other includes
#include <GLFW/glfw3.h>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <fstream> #include <fstream>
@ -152,21 +156,17 @@ class Shader {
if (!success) { if (!success) {
glGetShaderInfoLog(shader, 1024, NULL, infoLog); glGetShaderInfoLog(shader, 1024, NULL, infoLog);
std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n"
<< infoLog << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
<< "\n -- --------------------------------------------------- -- "
<< std::endl;
} }
} else { } else {
glGetProgramiv(shader, GL_LINK_STATUS, &success); glGetProgramiv(shader, GL_LINK_STATUS, &success);
if (!success) { if (!success) {
glGetProgramInfoLog(shader, 1024, NULL, infoLog); glGetProgramInfoLog(shader, 1024, NULL, infoLog);
std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n"
<< infoLog << infoLog << "\n -- --------------------------------------------------- -- " << std::endl;
<< "\n -- --------------------------------------------------- -- "
<< std::endl;
} }
} }
} }
}; };
} } // namespace Gedeng

94
test/parallax-demo/main.cpp Normal file
View File

@ -0,0 +1,94 @@
#include "Gedeng/Logger.h"
#define GEDENG_MAIN
#include <Gedeng.h>
class ParallaxApp : public Gedeng::Application {
public:
ParallaxApp(unsigned long ms_per_update, unsigned int window_size_x, unsigned int window_size_y,
Gedeng::String window_name)
: Application(ms_per_update, window_size_x, window_size_y, window_name), number_of_steps(10.0),
number_of_refinement_steps(10.0), bump_depth(0.1),
render_shader(Gedeng::Shader("Shader/bump.vs", "Shader/bump.fs")),
camera(Gedeng::Camera(90, 1920, 1080, 0.1, 1000.0)),
albedo("Resources/Textures/PavingStones/PavingStones070_2K_Color.jpg", Gedeng::Texture::Settings()),
bump("Resources/Textures/PavingStones/PavingStones070_2K_Displacement.jpg", Gedeng::Texture::Settings()),
normal("Resources/Textures/PavingStones/PavingStones070_2K_Normal.jpg", Gedeng::Texture::Settings()) {
// Move and rotate the camera so we see the quad well
camera.translate(glm::vec3(0.0, -1.0, 1.0));
camera.rotate(30, glm::vec3(1.0, 0.0, 0.0));
}
~ParallaxApp() = default;
void fixed_update(double delta) override {
// Settings for bump mapping
if (Gedeng::Input::is_key_down(GLFW_KEY_Q)) {
number_of_steps += delta * 5.0;
}
if (Gedeng::Input::is_key_down(GLFW_KEY_W)) {
number_of_steps -= delta * 5.0;
}
if (Gedeng::Input::is_key_down(GLFW_KEY_A)) {
number_of_refinement_steps += delta * 5.0;
}
if (Gedeng::Input::is_key_down(GLFW_KEY_S)) {
number_of_refinement_steps -= delta * 5.0;
}
if (Gedeng::Input::is_key_down(GLFW_KEY_Z)) {
bump_depth += delta * 0.1;
}
if (Gedeng::Input::is_key_down(GLFW_KEY_X)) {
bump_depth -= delta * 0.1;
}
}
void dynamic_update(double delta) override {
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
render_shader.use();
// Camera
render_shader.setMat4("projection", camera.get_projection());
render_shader.setMat4("view", camera.get_view());
render_shader.setVec3("viewPos", camera.get_translation());
// Lighting
render_shader.setVec3("lightPos", glm::vec3(0.0, 1.0, 5.0));
render_shader.setFloat("number_of_steps", glm::max(0.0f, number_of_steps));
render_shader.setFloat("number_of_refinement_steps", glm::max(0.0f, number_of_refinement_steps));
render_shader.setFloat("bump_depth", glm::max(0.0f, bump_depth));
// Textures
albedo.bind_to(0);
normal.bind_to(1);
bump.bind_to(2);
// Quad which is rendered onto
quad_mesh.rotate(delta * 25.0f, glm::normalize(glm::vec3(0.0, 0.0, 1.0)));
quad_mesh.render(render_shader);
}
private:
float number_of_steps;
float number_of_refinement_steps;
float bump_depth;
Gedeng::Shader render_shader;
Gedeng::VertexBuffer vertex_rectangle;
Gedeng::Camera camera;
Gedeng::Texture albedo;
Gedeng::Texture bump;
Gedeng::Texture normal;
Gedeng::QuadMesh quad_mesh;
};
Gedeng::Application *Gedeng::create_application() {
GG_CLIENT_INFO("Creating Application");
return new ParallaxApp(20, 900, 600, String("Parallax Demo"));
}