void initGLExtensions() {
#ifdef PLATFORM_LINUX
glBindVertexArrayOESEXT = (PFNGLBINDVERTEXARRAYPROC)glfwGetProcAddress("glBindVertexArray");
glDeleteVertexArraysOESEXT = (PFNGLDELETEVERTEXARRAYSPROC)glfwGetProcAddress("glDeleteVertexArrays");
glGenVertexArraysOESEXT = (PFNGLGENVERTEXARRAYSPROC)glfwGetProcAddress("glGenVertexArrays");
#endif
}
static void list_extensions(int major, int minor)
{
int i;
GLint count;
const GLubyte* extensions;
printf("OpenGL context supported extensions:\n");
if (major > 2)
{
PFNGLGETSTRINGIPROC glGetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!glGetStringi)
exit(EXIT_FAILURE);
glGetIntegerv(GL_NUM_EXTENSIONS, &count);
for (i = 0; i < count; i++)
puts((const char*) glGetStringi(GL_EXTENSIONS, i));
}
else
{
extensions = glGetString(GL_EXTENSIONS);
while (*extensions != '\0')
{
if (*extensions == ' ')
putchar('\n');
else
putchar(*extensions);
extensions++;
}
}
putchar('\n');
}
void UploadTexture(void * data){
#ifndef HAS_GL_TEX_IMAGE_3D
glTexImage3D = (PFNGLTEXIMAGE3DPROC) glfwGetProcAddress("glTexImage3D");
if (glTexImage3D == NULL)
return;
#endif //HAS_GL_TEX_IMAGE_3D
glTexEnvi(GL_TEXTURE_ENV,
GL_TEXTURE_ENV_MODE,
GL_REPLACE); // our texture colors will replace the untextured colors
// request 1 texture name from OpenGL
if(!texname)glGenTextures(1, &texname);
// tell OpenGL we're going to be setting up the
//texture name it gave us
glBindTexture(GL_TEXTURE_3D, texname);
// when this texture needs to be shrunk
//to fit on small polygons, use linear
//interpolation of the texels to determine the color
glTexParameteri(GL_TEXTURE_3D,
GL_TEXTURE_MIN_FILTER,
GL_LINEAR);//GL_NEAREST);
// when this texture needs to be magnified to fit on
//a big polygon, use linear interpolation of the texels
//to determine the color
glTexParameteri(GL_TEXTURE_3D,
GL_TEXTURE_MAG_FILTER,
GL_LINEAR);//GL_NEAREST);
// we want the texture to repeat over the S axis,
//so if we specify coordinates out of range
//we still get textured.
glTexParameteri(GL_TEXTURE_3D,
GL_TEXTURE_WRAP_S,
GL_REPEAT);
// same as above for T axis
glTexParameteri(GL_TEXTURE_3D,
GL_TEXTURE_WRAP_T,
GL_REPEAT);
// same as above for R axis
glTexParameteri(GL_TEXTURE_3D,
GL_TEXTURE_WRAP_R,
GL_REPEAT);
// this is a 3d texture, level 0 (max detail),
//GL should store it in RGB8 format,
//its WIDTHxHEIGHTxDEPTH in size,
// it doesnt have a border, we're giving it to
//GL in RGB format as a series of unsigned bytes,
// and texels is where the texel data is.
// memset(data, 100, SIZE*SIZE*SIZE*BPP);
glTexImage3D(GL_TEXTURE_3D, 0,
GL_RGBA8,
SIZE, SIZE, SIZE, 0,
GL_RGBA, GL_UNSIGNED_BYTE, data);
};
GLboolean _glfwRefreshContextParams(void)
{
_GLFWwindow* window = _glfwLibrary.currentWindow;
if (!parseGLVersion(&window->glMajor,
&window->glMinor,
&window->glRevision))
{
return GL_FALSE;
}
if (window->glMajor > 2)
{
// OpenGL 3.0+ uses a different function for extension string retrieval
// We cache it here instead of in glfwExtensionSupported mostly to alert
// users as early as possible that their build may be broken
window->GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!window->GetStringi)
{
_glfwSetError(GLFW_PLATFORM_ERROR,
"glfwCreateWindow: Entry point retrieval is broken");
return GL_FALSE;
}
}
// Read back forward-compatibility flag
{
window->glForward = GL_FALSE;
if (window->glMajor >= 3)
{
GLint flags;
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
window->glForward = GL_TRUE;
if (flags & 0)
window->glDebug = GL_TRUE;
}
}
// Read back OpenGL context profile
{
window->glProfile = 0;
if (window->glMajor > 3 || (window->glMajor == 3 && window->glMinor >= 2))
{
GLint mask;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
window->glProfile = GLFW_OPENGL_CORE_PROFILE;
}
}
return GL_TRUE;
}
void initGPUTimer(struct GPUtimer* timer)
{
memset(timer, 0, sizeof(*timer));
timer->supported = glfwExtensionSupported("GL_ARB_timer_query");
if (timer->supported) {
#ifndef GL_ARB_timer_query
glGetQueryObjectui64v = (pfnGLGETQUERYOBJECTUI64V)glfwGetProcAddress("glGetQueryObjectui64v");
if (!glGetQueryObjectui64v) {
timer->supported = GL_FALSE;
return;
}
#endif
glGenQueries(GPU_QUERY_COUNT, timer->queries);
}
}
static void list_extensions(int api, int major, int minor)
{
int i;
GLint count;
const GLubyte* extensions;
printf("%s context supported extensions:\n", get_client_api_name(api));
if (api == GLFW_OPENGL_API && major > 2)
{
PFNGLGETSTRINGIPROC glGetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!glGetStringi)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glGetIntegerv(GL_NUM_EXTENSIONS, &count);
for (i = 0; i < count; i++)
puts((const char*) glGetStringi(GL_EXTENSIONS, i));
}
else
{
extensions = glGetString(GL_EXTENSIONS);
while (*extensions != '\0')
{
if (*extensions == ' ')
putchar('\n');
else
putchar(*extensions);
extensions++;
}
}
putchar('\n');
}
GLboolean _glfwRefreshContextAttribs(void)
{
_GLFWwindow* window = _glfwPlatformGetCurrentContext();
if (!parseGLVersion(&window->clientAPI,
&window->glMajor,
&window->glMinor,
&window->glRevision))
{
return GL_FALSE;
}
#if defined(_GLFW_USE_OPENGL)
if (window->glMajor > 2)
{
// OpenGL 3.0+ uses a different function for extension string retrieval
// We cache it here instead of in glfwExtensionSupported mostly to alert
// users as early as possible that their build may be broken
window->GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!window->GetStringi)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Entry point retrieval is broken");
return GL_FALSE;
}
}
if (window->clientAPI == GLFW_OPENGL_API)
{
// Read back context flags (OpenGL 3.0 and above)
if (window->glMajor >= 3)
{
GLint flags;
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
window->glForward = GL_TRUE;
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
window->glDebug = GL_TRUE;
else if (glfwExtensionSupported("GL_ARB_debug_output"))
{
// HACK: This is a workaround for older drivers (pre KHR_debug)
// not setting the debug bit in the context flags for debug
// contexts
window->glDebug = GL_TRUE;
}
}
// Read back OpenGL context profile (OpenGL 3.2 and above)
if (window->glMajor > 3 ||
(window->glMajor == 3 && window->glMinor >= 2))
{
GLint mask;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
window->glProfile = GLFW_OPENGL_CORE_PROFILE;
}
// Read back robustness strategy
if (glfwExtensionSupported("GL_ARB_robustness"))
{
// NOTE: We avoid using the context flags for detection, as they are
// only present from 3.0 while the extension applies from 1.1
GLint strategy;
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
}
}
else
{
// Read back robustness strategy
if (glfwExtensionSupported("GL_EXT_robustness"))
{
// NOTE: The values of these constants match those of the OpenGL ARB
// one, so we can reuse them here
GLint strategy;
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
}
}
#endif // _GLFW_USE_OPENGL
return GL_TRUE;
}
GLFWglproc call(const char* procname) {
return glfwGetProcAddress(procname);
}
void* GLUSAPIENTRY glusGetProcAddress(const GLUSchar* procname)
{
return glfwGetProcAddress(procname);
}
mbgl::gl::ProcAddress GLFWView::initializeExtension(const char* name) {
return glfwGetProcAddress(name);
}
void flextLoadOpenGLFunctions(void)
{
/* --- Function pointer loading --- */
/* GL_ARB_geometry_shader4 */
glpfProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARB_PROC*)glfwGetProcAddress("glProgramParameteriARB");
glpfFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARB_PROC*)glfwGetProcAddress("glFramebufferTextureARB");
glpfFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARB_PROC*)glfwGetProcAddress("glFramebufferTextureLayerARB");
glpfFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARB_PROC*)glfwGetProcAddress("glFramebufferTextureFaceARB");
/* GL_EXT_framebuffer_object */
glpfIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXT_PROC*)glfwGetProcAddress("glIsRenderbufferEXT");
glpfBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXT_PROC*)glfwGetProcAddress("glBindRenderbufferEXT");
glpfDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXT_PROC*)glfwGetProcAddress("glDeleteRenderbuffersEXT");
glpfGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXT_PROC*)glfwGetProcAddress("glGenRenderbuffersEXT");
glpfRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXT_PROC*)glfwGetProcAddress("glRenderbufferStorageEXT");
glpfGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXT_PROC*)glfwGetProcAddress("glGetRenderbufferParameterivEXT");
glpfIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXT_PROC*)glfwGetProcAddress("glIsFramebufferEXT");
glpfBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXT_PROC*)glfwGetProcAddress("glBindFramebufferEXT");
glpfDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXT_PROC*)glfwGetProcAddress("glDeleteFramebuffersEXT");
glpfGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXT_PROC*)glfwGetProcAddress("glGenFramebuffersEXT");
glpfCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXT_PROC*)glfwGetProcAddress("glCheckFramebufferStatusEXT");
glpfFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXT_PROC*)glfwGetProcAddress("glFramebufferTexture1DEXT");
glpfFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXT_PROC*)glfwGetProcAddress("glFramebufferTexture2DEXT");
glpfFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXT_PROC*)glfwGetProcAddress("glFramebufferTexture3DEXT");
glpfFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXT_PROC*)glfwGetProcAddress("glFramebufferRenderbufferEXT");
glpfGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXT_PROC*)glfwGetProcAddress("glGetFramebufferAttachmentParameterivEXT");
glpfGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXT_PROC*)glfwGetProcAddress("glGenerateMipmapEXT");
/* GL_EXT_transform_feedback */
glpfBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXT_PROC*)glfwGetProcAddress("glBeginTransformFeedbackEXT");
glpfEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXT_PROC*)glfwGetProcAddress("glEndTransformFeedbackEXT");
glpfBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXT_PROC*)glfwGetProcAddress("glBindBufferRangeEXT");
glpfBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXT_PROC*)glfwGetProcAddress("glBindBufferOffsetEXT");
glpfBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXT_PROC*)glfwGetProcAddress("glBindBufferBaseEXT");
glpfTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXT_PROC*)glfwGetProcAddress("glTransformFeedbackVaryingsEXT");
glpfGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXT_PROC*)glfwGetProcAddress("glGetTransformFeedbackVaryingEXT");
/* GL_VERSION_1_2 */
glpfBlendColor = (PFNGLBLENDCOLOR_PROC*)glfwGetProcAddress("glBlendColor");
glpfBlendEquation = (PFNGLBLENDEQUATION_PROC*)glfwGetProcAddress("glBlendEquation");
glpfDrawRangeElements = (PFNGLDRAWRANGEELEMENTS_PROC*)glfwGetProcAddress("glDrawRangeElements");
glpfTexImage3D = (PFNGLTEXIMAGE3D_PROC*)glfwGetProcAddress("glTexImage3D");
glpfTexSubImage3D = (PFNGLTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glTexSubImage3D");
glpfCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glCopyTexSubImage3D");
glpfColorTable = (PFNGLCOLORTABLE_PROC*)glfwGetProcAddress("glColorTable");
glpfColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFV_PROC*)glfwGetProcAddress("glColorTableParameterfv");
glpfColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIV_PROC*)glfwGetProcAddress("glColorTableParameteriv");
glpfCopyColorTable = (PFNGLCOPYCOLORTABLE_PROC*)glfwGetProcAddress("glCopyColorTable");
glpfGetColorTable = (PFNGLGETCOLORTABLE_PROC*)glfwGetProcAddress("glGetColorTable");
glpfGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFV_PROC*)glfwGetProcAddress("glGetColorTableParameterfv");
glpfGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIV_PROC*)glfwGetProcAddress("glGetColorTableParameteriv");
glpfColorSubTable = (PFNGLCOLORSUBTABLE_PROC*)glfwGetProcAddress("glColorSubTable");
glpfCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLE_PROC*)glfwGetProcAddress("glCopyColorSubTable");
glpfConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1D_PROC*)glfwGetProcAddress("glConvolutionFilter1D");
glpfConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2D_PROC*)glfwGetProcAddress("glConvolutionFilter2D");
glpfConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERF_PROC*)glfwGetProcAddress("glConvolutionParameterf");
glpfConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFV_PROC*)glfwGetProcAddress("glConvolutionParameterfv");
glpfConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERI_PROC*)glfwGetProcAddress("glConvolutionParameteri");
glpfConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIV_PROC*)glfwGetProcAddress("glConvolutionParameteriv");
glpfCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1D_PROC*)glfwGetProcAddress("glCopyConvolutionFilter1D");
glpfCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2D_PROC*)glfwGetProcAddress("glCopyConvolutionFilter2D");
glpfGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTER_PROC*)glfwGetProcAddress("glGetConvolutionFilter");
glpfGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFV_PROC*)glfwGetProcAddress("glGetConvolutionParameterfv");
glpfGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIV_PROC*)glfwGetProcAddress("glGetConvolutionParameteriv");
glpfGetSeparableFilter = (PFNGLGETSEPARABLEFILTER_PROC*)glfwGetProcAddress("glGetSeparableFilter");
glpfSeparableFilter2D = (PFNGLSEPARABLEFILTER2D_PROC*)glfwGetProcAddress("glSeparableFilter2D");
glpfGetHistogram = (PFNGLGETHISTOGRAM_PROC*)glfwGetProcAddress("glGetHistogram");
glpfGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFV_PROC*)glfwGetProcAddress("glGetHistogramParameterfv");
glpfGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIV_PROC*)glfwGetProcAddress("glGetHistogramParameteriv");
glpfGetMinmax = (PFNGLGETMINMAX_PROC*)glfwGetProcAddress("glGetMinmax");
glpfGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFV_PROC*)glfwGetProcAddress("glGetMinmaxParameterfv");
glpfGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIV_PROC*)glfwGetProcAddress("glGetMinmaxParameteriv");
glpfHistogram = (PFNGLHISTOGRAM_PROC*)glfwGetProcAddress("glHistogram");
glpfMinmax = (PFNGLMINMAX_PROC*)glfwGetProcAddress("glMinmax");
glpfResetHistogram = (PFNGLRESETHISTOGRAM_PROC*)glfwGetProcAddress("glResetHistogram");
glpfResetMinmax = (PFNGLRESETMINMAX_PROC*)glfwGetProcAddress("glResetMinmax");
/* GL_VERSION_1_3 */
glpfActiveTexture = (PFNGLACTIVETEXTURE_PROC*)glfwGetProcAddress("glActiveTexture");
glpfSampleCoverage = (PFNGLSAMPLECOVERAGE_PROC*)glfwGetProcAddress("glSampleCoverage");
glpfCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3D_PROC*)glfwGetProcAddress("glCompressedTexImage3D");
glpfCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2D_PROC*)glfwGetProcAddress("glCompressedTexImage2D");
glpfCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1D_PROC*)glfwGetProcAddress("glCompressedTexImage1D");
glpfCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glCompressedTexSubImage3D");
glpfCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC*)glfwGetProcAddress("glCompressedTexSubImage2D");
glpfCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC*)glfwGetProcAddress("glCompressedTexSubImage1D");
glpfGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGE_PROC*)glfwGetProcAddress("glGetCompressedTexImage");
glpfClientActiveTexture = (PFNGLCLIENTACTIVETEXTURE_PROC*)glfwGetProcAddress("glClientActiveTexture");
glpfMultiTexCoord1d = (PFNGLMULTITEXCOORD1D_PROC*)glfwGetProcAddress("glMultiTexCoord1d");
glpfMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DV_PROC*)glfwGetProcAddress("glMultiTexCoord1dv");
glpfMultiTexCoord1f = (PFNGLMULTITEXCOORD1F_PROC*)glfwGetProcAddress("glMultiTexCoord1f");
glpfMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FV_PROC*)glfwGetProcAddress("glMultiTexCoord1fv");
glpfMultiTexCoord1i = (PFNGLMULTITEXCOORD1I_PROC*)glfwGetProcAddress("glMultiTexCoord1i");
glpfMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IV_PROC*)glfwGetProcAddress("glMultiTexCoord1iv");
glpfMultiTexCoord1s = (PFNGLMULTITEXCOORD1S_PROC*)glfwGetProcAddress("glMultiTexCoord1s");
glpfMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SV_PROC*)glfwGetProcAddress("glMultiTexCoord1sv");
glpfMultiTexCoord2d = (PFNGLMULTITEXCOORD2D_PROC*)glfwGetProcAddress("glMultiTexCoord2d");
glpfMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DV_PROC*)glfwGetProcAddress("glMultiTexCoord2dv");
glpfMultiTexCoord2f = (PFNGLMULTITEXCOORD2F_PROC*)glfwGetProcAddress("glMultiTexCoord2f");
glpfMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FV_PROC*)glfwGetProcAddress("glMultiTexCoord2fv");
glpfMultiTexCoord2i = (PFNGLMULTITEXCOORD2I_PROC*)glfwGetProcAddress("glMultiTexCoord2i");
glpfMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IV_PROC*)glfwGetProcAddress("glMultiTexCoord2iv");
glpfMultiTexCoord2s = (PFNGLMULTITEXCOORD2S_PROC*)glfwGetProcAddress("glMultiTexCoord2s");
glpfMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SV_PROC*)glfwGetProcAddress("glMultiTexCoord2sv");
glpfMultiTexCoord3d = (PFNGLMULTITEXCOORD3D_PROC*)glfwGetProcAddress("glMultiTexCoord3d");
glpfMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DV_PROC*)glfwGetProcAddress("glMultiTexCoord3dv");
glpfMultiTexCoord3f = (PFNGLMULTITEXCOORD3F_PROC*)glfwGetProcAddress("glMultiTexCoord3f");
glpfMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FV_PROC*)glfwGetProcAddress("glMultiTexCoord3fv");
glpfMultiTexCoord3i = (PFNGLMULTITEXCOORD3I_PROC*)glfwGetProcAddress("glMultiTexCoord3i");
glpfMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IV_PROC*)glfwGetProcAddress("glMultiTexCoord3iv");
glpfMultiTexCoord3s = (PFNGLMULTITEXCOORD3S_PROC*)glfwGetProcAddress("glMultiTexCoord3s");
glpfMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SV_PROC*)glfwGetProcAddress("glMultiTexCoord3sv");
glpfMultiTexCoord4d = (PFNGLMULTITEXCOORD4D_PROC*)glfwGetProcAddress("glMultiTexCoord4d");
glpfMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DV_PROC*)glfwGetProcAddress("glMultiTexCoord4dv");
glpfMultiTexCoord4f = (PFNGLMULTITEXCOORD4F_PROC*)glfwGetProcAddress("glMultiTexCoord4f");
glpfMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FV_PROC*)glfwGetProcAddress("glMultiTexCoord4fv");
glpfMultiTexCoord4i = (PFNGLMULTITEXCOORD4I_PROC*)glfwGetProcAddress("glMultiTexCoord4i");
glpfMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IV_PROC*)glfwGetProcAddress("glMultiTexCoord4iv");
glpfMultiTexCoord4s = (PFNGLMULTITEXCOORD4S_PROC*)glfwGetProcAddress("glMultiTexCoord4s");
glpfMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SV_PROC*)glfwGetProcAddress("glMultiTexCoord4sv");
glpfLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXF_PROC*)glfwGetProcAddress("glLoadTransposeMatrixf");
glpfLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXD_PROC*)glfwGetProcAddress("glLoadTransposeMatrixd");
glpfMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXF_PROC*)glfwGetProcAddress("glMultTransposeMatrixf");
glpfMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXD_PROC*)glfwGetProcAddress("glMultTransposeMatrixd");
/* GL_VERSION_1_4 */
glpfBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATE_PROC*)glfwGetProcAddress("glBlendFuncSeparate");
glpfMultiDrawArrays = (PFNGLMULTIDRAWARRAYS_PROC*)glfwGetProcAddress("glMultiDrawArrays");
glpfMultiDrawElements = (PFNGLMULTIDRAWELEMENTS_PROC*)glfwGetProcAddress("glMultiDrawElements");
glpfPointParameterf = (PFNGLPOINTPARAMETERF_PROC*)glfwGetProcAddress("glPointParameterf");
glpfPointParameterfv = (PFNGLPOINTPARAMETERFV_PROC*)glfwGetProcAddress("glPointParameterfv");
glpfPointParameteri = (PFNGLPOINTPARAMETERI_PROC*)glfwGetProcAddress("glPointParameteri");
glpfPointParameteriv = (PFNGLPOINTPARAMETERIV_PROC*)glfwGetProcAddress("glPointParameteriv");
glpfFogCoordf = (PFNGLFOGCOORDF_PROC*)glfwGetProcAddress("glFogCoordf");
glpfFogCoordfv = (PFNGLFOGCOORDFV_PROC*)glfwGetProcAddress("glFogCoordfv");
glpfFogCoordd = (PFNGLFOGCOORDD_PROC*)glfwGetProcAddress("glFogCoordd");
glpfFogCoorddv = (PFNGLFOGCOORDDV_PROC*)glfwGetProcAddress("glFogCoorddv");
glpfFogCoordPointer = (PFNGLFOGCOORDPOINTER_PROC*)glfwGetProcAddress("glFogCoordPointer");
glpfSecondaryColor3b = (PFNGLSECONDARYCOLOR3B_PROC*)glfwGetProcAddress("glSecondaryColor3b");
glpfSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BV_PROC*)glfwGetProcAddress("glSecondaryColor3bv");
glpfSecondaryColor3d = (PFNGLSECONDARYCOLOR3D_PROC*)glfwGetProcAddress("glSecondaryColor3d");
glpfSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DV_PROC*)glfwGetProcAddress("glSecondaryColor3dv");
glpfSecondaryColor3f = (PFNGLSECONDARYCOLOR3F_PROC*)glfwGetProcAddress("glSecondaryColor3f");
glpfSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FV_PROC*)glfwGetProcAddress("glSecondaryColor3fv");
glpfSecondaryColor3i = (PFNGLSECONDARYCOLOR3I_PROC*)glfwGetProcAddress("glSecondaryColor3i");
glpfSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IV_PROC*)glfwGetProcAddress("glSecondaryColor3iv");
glpfSecondaryColor3s = (PFNGLSECONDARYCOLOR3S_PROC*)glfwGetProcAddress("glSecondaryColor3s");
glpfSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SV_PROC*)glfwGetProcAddress("glSecondaryColor3sv");
glpfSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UB_PROC*)glfwGetProcAddress("glSecondaryColor3ub");
glpfSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBV_PROC*)glfwGetProcAddress("glSecondaryColor3ubv");
glpfSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UI_PROC*)glfwGetProcAddress("glSecondaryColor3ui");
glpfSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIV_PROC*)glfwGetProcAddress("glSecondaryColor3uiv");
glpfSecondaryColor3us = (PFNGLSECONDARYCOLOR3US_PROC*)glfwGetProcAddress("glSecondaryColor3us");
glpfSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USV_PROC*)glfwGetProcAddress("glSecondaryColor3usv");
glpfSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTER_PROC*)glfwGetProcAddress("glSecondaryColorPointer");
glpfWindowPos2d = (PFNGLWINDOWPOS2D_PROC*)glfwGetProcAddress("glWindowPos2d");
glpfWindowPos2dv = (PFNGLWINDOWPOS2DV_PROC*)glfwGetProcAddress("glWindowPos2dv");
glpfWindowPos2f = (PFNGLWINDOWPOS2F_PROC*)glfwGetProcAddress("glWindowPos2f");
glpfWindowPos2fv = (PFNGLWINDOWPOS2FV_PROC*)glfwGetProcAddress("glWindowPos2fv");
glpfWindowPos2i = (PFNGLWINDOWPOS2I_PROC*)glfwGetProcAddress("glWindowPos2i");
glpfWindowPos2iv = (PFNGLWINDOWPOS2IV_PROC*)glfwGetProcAddress("glWindowPos2iv");
glpfWindowPos2s = (PFNGLWINDOWPOS2S_PROC*)glfwGetProcAddress("glWindowPos2s");
glpfWindowPos2sv = (PFNGLWINDOWPOS2SV_PROC*)glfwGetProcAddress("glWindowPos2sv");
glpfWindowPos3d = (PFNGLWINDOWPOS3D_PROC*)glfwGetProcAddress("glWindowPos3d");
glpfWindowPos3dv = (PFNGLWINDOWPOS3DV_PROC*)glfwGetProcAddress("glWindowPos3dv");
glpfWindowPos3f = (PFNGLWINDOWPOS3F_PROC*)glfwGetProcAddress("glWindowPos3f");
glpfWindowPos3fv = (PFNGLWINDOWPOS3FV_PROC*)glfwGetProcAddress("glWindowPos3fv");
glpfWindowPos3i = (PFNGLWINDOWPOS3I_PROC*)glfwGetProcAddress("glWindowPos3i");
glpfWindowPos3iv = (PFNGLWINDOWPOS3IV_PROC*)glfwGetProcAddress("glWindowPos3iv");
glpfWindowPos3s = (PFNGLWINDOWPOS3S_PROC*)glfwGetProcAddress("glWindowPos3s");
glpfWindowPos3sv = (PFNGLWINDOWPOS3SV_PROC*)glfwGetProcAddress("glWindowPos3sv");
/* GL_VERSION_1_5 */
glpfGenQueries = (PFNGLGENQUERIES_PROC*)glfwGetProcAddress("glGenQueries");
glpfDeleteQueries = (PFNGLDELETEQUERIES_PROC*)glfwGetProcAddress("glDeleteQueries");
glpfIsQuery = (PFNGLISQUERY_PROC*)glfwGetProcAddress("glIsQuery");
glpfBeginQuery = (PFNGLBEGINQUERY_PROC*)glfwGetProcAddress("glBeginQuery");
glpfEndQuery = (PFNGLENDQUERY_PROC*)glfwGetProcAddress("glEndQuery");
glpfGetQueryiv = (PFNGLGETQUERYIV_PROC*)glfwGetProcAddress("glGetQueryiv");
glpfGetQueryObjectiv = (PFNGLGETQUERYOBJECTIV_PROC*)glfwGetProcAddress("glGetQueryObjectiv");
glpfGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIV_PROC*)glfwGetProcAddress("glGetQueryObjectuiv");
glpfBindBuffer = (PFNGLBINDBUFFER_PROC*)glfwGetProcAddress("glBindBuffer");
glpfDeleteBuffers = (PFNGLDELETEBUFFERS_PROC*)glfwGetProcAddress("glDeleteBuffers");
glpfGenBuffers = (PFNGLGENBUFFERS_PROC*)glfwGetProcAddress("glGenBuffers");
glpfIsBuffer = (PFNGLISBUFFER_PROC*)glfwGetProcAddress("glIsBuffer");
glpfBufferData = (PFNGLBUFFERDATA_PROC*)glfwGetProcAddress("glBufferData");
glpfBufferSubData = (PFNGLBUFFERSUBDATA_PROC*)glfwGetProcAddress("glBufferSubData");
glpfGetBufferSubData = (PFNGLGETBUFFERSUBDATA_PROC*)glfwGetProcAddress("glGetBufferSubData");
glpfMapBuffer = (PFNGLMAPBUFFER_PROC*)glfwGetProcAddress("glMapBuffer");
glpfUnmapBuffer = (PFNGLUNMAPBUFFER_PROC*)glfwGetProcAddress("glUnmapBuffer");
glpfGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIV_PROC*)glfwGetProcAddress("glGetBufferParameteriv");
glpfGetBufferPointerv = (PFNGLGETBUFFERPOINTERV_PROC*)glfwGetProcAddress("glGetBufferPointerv");
/* GL_VERSION_2_0 */
glpfBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATE_PROC*)glfwGetProcAddress("glBlendEquationSeparate");
glpfDrawBuffers = (PFNGLDRAWBUFFERS_PROC*)glfwGetProcAddress("glDrawBuffers");
glpfStencilOpSeparate = (PFNGLSTENCILOPSEPARATE_PROC*)glfwGetProcAddress("glStencilOpSeparate");
glpfStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATE_PROC*)glfwGetProcAddress("glStencilFuncSeparate");
glpfStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATE_PROC*)glfwGetProcAddress("glStencilMaskSeparate");
glpfAttachShader = (PFNGLATTACHSHADER_PROC*)glfwGetProcAddress("glAttachShader");
glpfBindAttribLocation = (PFNGLBINDATTRIBLOCATION_PROC*)glfwGetProcAddress("glBindAttribLocation");
glpfCompileShader = (PFNGLCOMPILESHADER_PROC*)glfwGetProcAddress("glCompileShader");
glpfCreateProgram = (PFNGLCREATEPROGRAM_PROC*)glfwGetProcAddress("glCreateProgram");
glpfCreateShader = (PFNGLCREATESHADER_PROC*)glfwGetProcAddress("glCreateShader");
glpfDeleteProgram = (PFNGLDELETEPROGRAM_PROC*)glfwGetProcAddress("glDeleteProgram");
glpfDeleteShader = (PFNGLDELETESHADER_PROC*)glfwGetProcAddress("glDeleteShader");
glpfDetachShader = (PFNGLDETACHSHADER_PROC*)glfwGetProcAddress("glDetachShader");
glpfDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAY_PROC*)glfwGetProcAddress("glDisableVertexAttribArray");
glpfEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAY_PROC*)glfwGetProcAddress("glEnableVertexAttribArray");
glpfGetActiveAttrib = (PFNGLGETACTIVEATTRIB_PROC*)glfwGetProcAddress("glGetActiveAttrib");
glpfGetActiveUniform = (PFNGLGETACTIVEUNIFORM_PROC*)glfwGetProcAddress("glGetActiveUniform");
glpfGetAttachedShaders = (PFNGLGETATTACHEDSHADERS_PROC*)glfwGetProcAddress("glGetAttachedShaders");
glpfGetAttribLocation = (PFNGLGETATTRIBLOCATION_PROC*)glfwGetProcAddress("glGetAttribLocation");
glpfGetProgramiv = (PFNGLGETPROGRAMIV_PROC*)glfwGetProcAddress("glGetProgramiv");
glpfGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOG_PROC*)glfwGetProcAddress("glGetProgramInfoLog");
glpfGetShaderiv = (PFNGLGETSHADERIV_PROC*)glfwGetProcAddress("glGetShaderiv");
glpfGetShaderInfoLog = (PFNGLGETSHADERINFOLOG_PROC*)glfwGetProcAddress("glGetShaderInfoLog");
glpfGetShaderSource = (PFNGLGETSHADERSOURCE_PROC*)glfwGetProcAddress("glGetShaderSource");
glpfGetUniformLocation = (PFNGLGETUNIFORMLOCATION_PROC*)glfwGetProcAddress("glGetUniformLocation");
glpfGetUniformfv = (PFNGLGETUNIFORMFV_PROC*)glfwGetProcAddress("glGetUniformfv");
glpfGetUniformiv = (PFNGLGETUNIFORMIV_PROC*)glfwGetProcAddress("glGetUniformiv");
glpfGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDV_PROC*)glfwGetProcAddress("glGetVertexAttribdv");
glpfGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFV_PROC*)glfwGetProcAddress("glGetVertexAttribfv");
glpfGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIV_PROC*)glfwGetProcAddress("glGetVertexAttribiv");
glpfGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERV_PROC*)glfwGetProcAddress("glGetVertexAttribPointerv");
glpfIsProgram = (PFNGLISPROGRAM_PROC*)glfwGetProcAddress("glIsProgram");
glpfIsShader = (PFNGLISSHADER_PROC*)glfwGetProcAddress("glIsShader");
glpfLinkProgram = (PFNGLLINKPROGRAM_PROC*)glfwGetProcAddress("glLinkProgram");
glpfShaderSource = (PFNGLSHADERSOURCE_PROC*)glfwGetProcAddress("glShaderSource");
glpfUseProgram = (PFNGLUSEPROGRAM_PROC*)glfwGetProcAddress("glUseProgram");
glpfUniform1f = (PFNGLUNIFORM1F_PROC*)glfwGetProcAddress("glUniform1f");
glpfUniform2f = (PFNGLUNIFORM2F_PROC*)glfwGetProcAddress("glUniform2f");
glpfUniform3f = (PFNGLUNIFORM3F_PROC*)glfwGetProcAddress("glUniform3f");
glpfUniform4f = (PFNGLUNIFORM4F_PROC*)glfwGetProcAddress("glUniform4f");
glpfUniform1i = (PFNGLUNIFORM1I_PROC*)glfwGetProcAddress("glUniform1i");
glpfUniform2i = (PFNGLUNIFORM2I_PROC*)glfwGetProcAddress("glUniform2i");
glpfUniform3i = (PFNGLUNIFORM3I_PROC*)glfwGetProcAddress("glUniform3i");
glpfUniform4i = (PFNGLUNIFORM4I_PROC*)glfwGetProcAddress("glUniform4i");
glpfUniform1fv = (PFNGLUNIFORM1FV_PROC*)glfwGetProcAddress("glUniform1fv");
glpfUniform2fv = (PFNGLUNIFORM2FV_PROC*)glfwGetProcAddress("glUniform2fv");
glpfUniform3fv = (PFNGLUNIFORM3FV_PROC*)glfwGetProcAddress("glUniform3fv");
glpfUniform4fv = (PFNGLUNIFORM4FV_PROC*)glfwGetProcAddress("glUniform4fv");
glpfUniform1iv = (PFNGLUNIFORM1IV_PROC*)glfwGetProcAddress("glUniform1iv");
glpfUniform2iv = (PFNGLUNIFORM2IV_PROC*)glfwGetProcAddress("glUniform2iv");
glpfUniform3iv = (PFNGLUNIFORM3IV_PROC*)glfwGetProcAddress("glUniform3iv");
glpfUniform4iv = (PFNGLUNIFORM4IV_PROC*)glfwGetProcAddress("glUniform4iv");
glpfUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FV_PROC*)glfwGetProcAddress("glUniformMatrix2fv");
glpfUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FV_PROC*)glfwGetProcAddress("glUniformMatrix3fv");
glpfUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FV_PROC*)glfwGetProcAddress("glUniformMatrix4fv");
glpfValidateProgram = (PFNGLVALIDATEPROGRAM_PROC*)glfwGetProcAddress("glValidateProgram");
glpfVertexAttrib1d = (PFNGLVERTEXATTRIB1D_PROC*)glfwGetProcAddress("glVertexAttrib1d");
glpfVertexAttrib1dv = (PFNGLVERTEXATTRIB1DV_PROC*)glfwGetProcAddress("glVertexAttrib1dv");
glpfVertexAttrib1f = (PFNGLVERTEXATTRIB1F_PROC*)glfwGetProcAddress("glVertexAttrib1f");
glpfVertexAttrib1fv = (PFNGLVERTEXATTRIB1FV_PROC*)glfwGetProcAddress("glVertexAttrib1fv");
glpfVertexAttrib1s = (PFNGLVERTEXATTRIB1S_PROC*)glfwGetProcAddress("glVertexAttrib1s");
glpfVertexAttrib1sv = (PFNGLVERTEXATTRIB1SV_PROC*)glfwGetProcAddress("glVertexAttrib1sv");
glpfVertexAttrib2d = (PFNGLVERTEXATTRIB2D_PROC*)glfwGetProcAddress("glVertexAttrib2d");
glpfVertexAttrib2dv = (PFNGLVERTEXATTRIB2DV_PROC*)glfwGetProcAddress("glVertexAttrib2dv");
glpfVertexAttrib2f = (PFNGLVERTEXATTRIB2F_PROC*)glfwGetProcAddress("glVertexAttrib2f");
glpfVertexAttrib2fv = (PFNGLVERTEXATTRIB2FV_PROC*)glfwGetProcAddress("glVertexAttrib2fv");
glpfVertexAttrib2s = (PFNGLVERTEXATTRIB2S_PROC*)glfwGetProcAddress("glVertexAttrib2s");
glpfVertexAttrib2sv = (PFNGLVERTEXATTRIB2SV_PROC*)glfwGetProcAddress("glVertexAttrib2sv");
glpfVertexAttrib3d = (PFNGLVERTEXATTRIB3D_PROC*)glfwGetProcAddress("glVertexAttrib3d");
glpfVertexAttrib3dv = (PFNGLVERTEXATTRIB3DV_PROC*)glfwGetProcAddress("glVertexAttrib3dv");
glpfVertexAttrib3f = (PFNGLVERTEXATTRIB3F_PROC*)glfwGetProcAddress("glVertexAttrib3f");
glpfVertexAttrib3fv = (PFNGLVERTEXATTRIB3FV_PROC*)glfwGetProcAddress("glVertexAttrib3fv");
glpfVertexAttrib3s = (PFNGLVERTEXATTRIB3S_PROC*)glfwGetProcAddress("glVertexAttrib3s");
glpfVertexAttrib3sv = (PFNGLVERTEXATTRIB3SV_PROC*)glfwGetProcAddress("glVertexAttrib3sv");
glpfVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBV_PROC*)glfwGetProcAddress("glVertexAttrib4Nbv");
glpfVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIV_PROC*)glfwGetProcAddress("glVertexAttrib4Niv");
glpfVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSV_PROC*)glfwGetProcAddress("glVertexAttrib4Nsv");
glpfVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUB_PROC*)glfwGetProcAddress("glVertexAttrib4Nub");
glpfVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBV_PROC*)glfwGetProcAddress("glVertexAttrib4Nubv");
glpfVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIV_PROC*)glfwGetProcAddress("glVertexAttrib4Nuiv");
glpfVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSV_PROC*)glfwGetProcAddress("glVertexAttrib4Nusv");
glpfVertexAttrib4bv = (PFNGLVERTEXATTRIB4BV_PROC*)glfwGetProcAddress("glVertexAttrib4bv");
glpfVertexAttrib4d = (PFNGLVERTEXATTRIB4D_PROC*)glfwGetProcAddress("glVertexAttrib4d");
glpfVertexAttrib4dv = (PFNGLVERTEXATTRIB4DV_PROC*)glfwGetProcAddress("glVertexAttrib4dv");
glpfVertexAttrib4f = (PFNGLVERTEXATTRIB4F_PROC*)glfwGetProcAddress("glVertexAttrib4f");
glpfVertexAttrib4fv = (PFNGLVERTEXATTRIB4FV_PROC*)glfwGetProcAddress("glVertexAttrib4fv");
glpfVertexAttrib4iv = (PFNGLVERTEXATTRIB4IV_PROC*)glfwGetProcAddress("glVertexAttrib4iv");
glpfVertexAttrib4s = (PFNGLVERTEXATTRIB4S_PROC*)glfwGetProcAddress("glVertexAttrib4s");
glpfVertexAttrib4sv = (PFNGLVERTEXATTRIB4SV_PROC*)glfwGetProcAddress("glVertexAttrib4sv");
glpfVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBV_PROC*)glfwGetProcAddress("glVertexAttrib4ubv");
glpfVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIV_PROC*)glfwGetProcAddress("glVertexAttrib4uiv");
glpfVertexAttrib4usv = (PFNGLVERTEXATTRIB4USV_PROC*)glfwGetProcAddress("glVertexAttrib4usv");
glpfVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTER_PROC*)glfwGetProcAddress("glVertexAttribPointer");
}
void Shader::staticInit()
{
if (_wasInited)
return;
_wasInited = true;
debugLog("Initializing shaders...");
#if defined(BBGE_BUILD_SHADERS) && defined(BBGE_BUILD_OPENGL)
char *ext = (char*)glGetString( GL_EXTENSIONS );
if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL )
{
//This extension string indicates that the OpenGL Shading Language,
// version 1.00, is supported.
debugLog("GL_ARB_shading_language_100 extension was not found");
/*
MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found",
"ERROR",MB_OK|MB_ICONEXCLAMATION);
*/
goto end;
}
if( strstr( ext, "GL_ARB_shader_objects" ) == NULL )
{
debugLog("GL_ARB_shader_objects extension was not found");
goto end;
}
else
{
#ifdef BBGE_BUILD_GLFW
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glfwGetProcAddress("glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glUseProgramObjectARB");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glfwGetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glfwGetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glfwGetProcAddress("glCompileShaderARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glfwGetProcAddress("glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glfwGetProcAddress("glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glfwGetProcAddress("glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glfwGetProcAddress("glLinkProgramARB");
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glfwGetProcAddress("glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glfwGetProcAddress("glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glfwGetProcAddress("glUniform1iARB");
#endif
#ifdef BBGE_BUILD_SDL
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)SDL_GL_GetProcAddress("glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glUseProgramObjectARB");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)SDL_GL_GetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)SDL_GL_GetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)SDL_GL_GetProcAddress("glCompileShaderARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)SDL_GL_GetProcAddress("glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)SDL_GL_GetProcAddress("glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)SDL_GL_GetProcAddress("glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)SDL_GL_GetProcAddress("glLinkProgramARB");
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)SDL_GL_GetProcAddress("glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)SDL_GL_GetProcAddress("glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)SDL_GL_GetProcAddress("glUniform1iARB");
#endif
if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB ||
!glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB ||
!glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB ||
!glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB ||
!glUniform1iARB )
{
glCreateProgramObjectARB = 0;
debugLog("One or more GL_ARB_shader_objects functions were not found");
goto end;
}
}
// everything fine when we are here
_useShaders = true;
#endif
end:
if (_useShaders)
debugLog("Shader support enabled.");
else
debugLog("Shader support not enabled.");
}
static GrGLFuncPtr glfw_get(void* ctx, const char name[]) {
SkASSERT(nullptr == ctx);
SkASSERT(glfwGetCurrentContext());
return glfwGetProcAddress(name);
}
int main()
{
GLFWwindow *window;
char *userptr = "userptr";
glfwSetErrorCallback(errorcb);
assert(glfwInit() == GL_TRUE);
assert(!strcmp(glfwGetVersionString(), "3.2.1 JS WebGL Emscripten"));
assert(glfwGetCurrentContext() == NULL);
{
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
assert(major == 3);
assert(minor == 2);
assert(rev == 1);
}
{
int count, x, y, w, h;
GLFWmonitor **monitors = glfwGetMonitors(&count);
assert(count == 1);
for (int i = 0; i < count; ++i) {
assert(monitors[i] != NULL);
}
assert(glfwGetPrimaryMonitor() != NULL);
glfwGetMonitorPos(monitors[0], &x, &y);
glfwGetMonitorPhysicalSize(monitors[0], &w, &h);
assert(glfwGetMonitorName(monitors[0]) != NULL);
glfwSetMonitorCallback(monitcb);
// XXX: not implemented
// assert(glfwGetVideoModes(monitors[0], &count) != NULL);
// assert(glfwGetVideoMode(monitors[0]) != NULL);
// glfwSetGamma(monitors[0], 1.0f);
// assert(glfwGetGammaRamp(monitors[0]) != NULL);
// glfwSetGammaRamp(monitors[0], ramp);
}
{
int x, y, w, h;
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
glfwSetWindowPosCallback(window, wposicb);
glfwSetWindowSizeCallback(window, wsizecb);
glfwSetWindowCloseCallback(window, wcloscb);
glfwSetWindowRefreshCallback(window, wrfrscb);
glfwSetWindowFocusCallback(window, wfocucb);
glfwSetWindowIconifyCallback(window, wiconcb);
glfwSetFramebufferSizeCallback(window, wfsizcb);
assert(glfwWindowShouldClose(window) == 0);
glfwSetWindowShouldClose(window, 1);
assert(glfwWindowShouldClose(window) == 1);
glfwSetWindowTitle(window, "test");
glfwSetWindowTitle(window, "glfw3.c");
// XXX: not implemented
// glfwSetWindowPos(window, 1, 1);
glfwGetWindowPos(window, &x, &y); // stub
glfwGetWindowSize(window, &w, &h);
assert(w == 640 && h == 480);
glfwSetWindowSize(window, 1, 1);
glfwGetWindowSize(window, &w, &h);
assert(w == 1 && h == 1);
glfwSetWindowSize(window, 640, 480);
glfwGetFramebufferSize(window, &w, &h);
// XXX: not implemented
// glfwIconifyWindow(window);
// glfwRestoreWindow(window);
// glfwShowWindow(window);
// glfwHideWindow(window);
assert(glfwGetWindowMonitor(window) == NULL);
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", glfwGetPrimaryMonitor(), NULL);
assert(window != NULL);
assert(glfwGetWindowMonitor(window) == glfwGetPrimaryMonitor());
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
assert(glfwGetWindowAttrib(window, GLFW_CLIENT_API) == GLFW_OPENGL_ES_API);
assert(glfwGetWindowUserPointer(window) == NULL);
glfwSetWindowUserPointer(window, userptr);
assert(glfwGetWindowUserPointer(window) == userptr);
}
{
double x, y;
glfwSetKeyCallback(window, wkeypcb);
glfwSetCharCallback(window, wcharcb);
glfwSetMouseButtonCallback(window, wmbutcb);
glfwSetCursorPosCallback(window, wcurpcb);
glfwSetCursorEnterCallback(window, wcurecb);
glfwSetScrollCallback(window, wscrocb);
// XXX: stub, events come immediatly
// glfwPollEvents();
// glfwWaitEvents();
assert(glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_NORMAL);
// XXX: not implemented
// glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
glfwGetKey(window, GLFW_KEY_A);
glfwGetMouseButton(window, 0);
glfwGetCursorPos(window, &x, &y);
// XXX: not implemented
// glfwSetCursorPos(window, 0, 0);
}
{
// XXX: not implemented
// glfwJoystickPresent(joy);
// glfwGetJoystickAxes(joy, &count);
// glfwGetJoystickButtons(joy, &count);
// glfwGetJoystickName(joy);
}
{
// XXX: not implemented
// glfwSetClipboardString(window, "string");
// glfwGetClipboardString(window);
}
{
glfwGetTime();
glfwSetTime(0);
}
{
glfwMakeContextCurrent(window); // stub
assert(glfwGetCurrentContext() == window);
glfwSwapBuffers(window); // stub
glfwSwapInterval(0); // stub
}
{
assert(glfwExtensionSupported("nonexistant") == 0);
assert(glfwGetProcAddress("nonexistant") == NULL);
}
glfwTerminate();
#ifdef REPORT_RESULT
REPORT_RESULT(1);
#endif
return 0;
}
/*
* loadExtensions - Load the required OpenGL extensions.
*/
void loadExtensions() {
// These extension strings indicate that the OpenGL Shading Language,
// GLSL shader objects and floating-point textures are supported.
if(!glfwExtensionSupported("GL_ARB_shading_language_100"))
{
printError("GL init error", "GL_ARB_shading_language_100 extension was not found");
return;
}
if(!glfwExtensionSupported("GL_ARB_shader_objects"))
{
printError("GL init error", "GL_ARB_shader_objects extension was not found");
return;
}
// else
#ifdef __WIN32__
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glfwGetProcAddress("glActiveTextureARB");
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glfwGetProcAddress("glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glUseProgramObjectARB");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glfwGetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glfwGetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glfwGetProcAddress("glCompileShaderARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glfwGetProcAddress("glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glfwGetProcAddress("glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glfwGetProcAddress("glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glfwGetProcAddress("glLinkProgramARB");
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glfwGetProcAddress("glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glfwGetProcAddress("glUniform4fARB");
glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glfwGetProcAddress("glUniform1fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glfwGetProcAddress("glUniform1iARB");
if( !glActiveTextureARB ||
!glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB ||
!glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB ||
!glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB ||
!glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB ||
!glUniform1fARB || !glUniform1iARB )
{
printError("GL init error", "One or more GL_ARB_shader_objects functions were not found");
return;
}
#endif
}
void Shader::load(const std::string &file, const std::string &fragFile)
{
debugLog("Shader::load("+file+", "+fragFile+")");
loaded = false;
#ifdef BBGE_BUILD_SHADERS
g_location_texture = 0;
g_location_mode = 0;
g_location_value = 0;
try
{
debugLog("Shader::load 1");
this->vertFile = file;
this->fragFile = fragFile;
//
// If the required extension is present, get the addresses of its
// functions that we wish to use...
//
debugLog("Shader::load 2");
char *ext = (char*)glGetString( GL_EXTENSIONS );
if( strstr( ext, "GL_ARB_shading_language_100" ) == NULL )
{
//This extension string indicates that the OpenGL Shading Language,
// version 1.00, is supported.
debugLog("GL_ARB_shading_language_100 extension was not found");
/*
MessageBox(NULL,"GL_ARB_shading_language_100 extension was not found",
"ERROR",MB_OK|MB_ICONEXCLAMATION);
*/
return;
}
debugLog("Shader::load 3");
if( strstr( ext, "GL_ARB_shader_objects" ) == NULL )
{
debugLog("GL_ARB_shader_objects extension was not found");
return;
}
else
{
// only do this once if it works
if (!glCreateProgramObjectARB)
{
#ifdef BBGE_BUILD_GLFW
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glfwGetProcAddress("glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glUseProgramObjectARB");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glfwGetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glfwGetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glfwGetProcAddress("glCompileShaderARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glfwGetProcAddress("glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glfwGetProcAddress("glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glfwGetProcAddress("glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glfwGetProcAddress("glLinkProgramARB");
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glfwGetProcAddress("glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glfwGetProcAddress("glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glfwGetProcAddress("glUniform1iARB");
#endif
#ifdef BBGE_BUILD_SDL
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)SDL_GL_GetProcAddress("glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)SDL_GL_GetProcAddress("glUseProgramObjectARB");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)SDL_GL_GetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)SDL_GL_GetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)SDL_GL_GetProcAddress("glCompileShaderARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)SDL_GL_GetProcAddress("glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)SDL_GL_GetProcAddress("glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)SDL_GL_GetProcAddress("glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)SDL_GL_GetProcAddress("glLinkProgramARB");
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)SDL_GL_GetProcAddress("glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)SDL_GL_GetProcAddress("glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)SDL_GL_GetProcAddress("glUniform1iARB");
#endif
if( !glCreateProgramObjectARB || !glDeleteObjectARB || !glUseProgramObjectARB ||
!glCreateShaderObjectARB || !glCreateShaderObjectARB || !glCompileShaderARB ||
!glGetObjectParameterivARB || !glAttachObjectARB || !glGetInfoLogARB ||
!glLinkProgramARB || !glGetUniformLocationARB || !glUniform4fARB ||
!glUniform1iARB )
{
glCreateProgramObjectARB = 0;
debugLog("One or more GL_ARB_shader_objects functions were not found");
return;
}
}
}
debugLog("Shader::load 4");
const char *vertexShaderStrings[1];
const char *fragmentShaderStrings[1];
GLint bVertCompiled;
GLint bFragCompiled;
GLint bLinked;
char str[4096];
//
// Create the vertex shader...
//
debugLog("Shader::load 5");
g_vertexShader = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );
unsigned char *vertexShaderAssembly = readShaderFile( file.c_str() );
vertexShaderStrings[0] = (char*)vertexShaderAssembly;
glShaderSourceARB( g_vertexShader, 1, vertexShaderStrings, NULL );
glCompileShaderARB( g_vertexShader);
delete[] vertexShaderAssembly;
glGetObjectParameterivARB( g_vertexShader, GL_OBJECT_COMPILE_STATUS_ARB,
&bVertCompiled );
if( bVertCompiled == false )
//if (true)
{
glGetInfoLogARB(g_vertexShader, sizeof(str), NULL, str);
std::ostringstream os;
os << "Vertex Shader Compile Error: " << str;
debugLog(os.str());
return;
}
//
// Create the fragment shader...
//
debugLog("Shader::load 6");
g_fragmentShader = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
unsigned char *fragmentShaderAssembly = readShaderFile( fragFile.c_str() );
fragmentShaderStrings[0] = (char*)fragmentShaderAssembly;
glShaderSourceARB( g_fragmentShader, 1, fragmentShaderStrings, NULL );
glCompileShaderARB( g_fragmentShader );
delete[] fragmentShaderAssembly;
glGetObjectParameterivARB( g_fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB,
&bFragCompiled );
if( bFragCompiled == false )
{
glGetInfoLogARB( g_fragmentShader, sizeof(str), NULL, str );
std::ostringstream os;
os << "Fragment Shader Compile Error: " << str;
debugLog(os.str());
return;
}
debugLog("Shader::load 7");
//
// Create a program object and attach the two compiled shaders...
//
g_programObj = glCreateProgramObjectARB();
if (!g_programObj || !g_vertexShader || !g_fragmentShader)
{
debugLog("programObj / vertexShader / fragmentShader problem");
return;
}
glAttachObjectARB( g_programObj, g_vertexShader );
glAttachObjectARB( g_programObj, g_fragmentShader );
//
// Link the program object and print out the info log...
//
glLinkProgramARB( g_programObj );
glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked );
debugLog("Shader::load 8");
if( bLinked == false )
{
glGetInfoLogARB( g_programObj, sizeof(str), NULL, str );
std::ostringstream os;
os << "Shader Linking Error: " << str;
debugLog(os.str());
return;
}
//
// Locate some parameters by name so we can set them later...
//
debugLog("Shader::load 9");
g_location_texture = glGetUniformLocationARB( g_programObj, "tex" );
g_location_mode = glGetUniformLocationARB( g_programObj, "mode" );
g_location_value = glGetUniformLocationARB( g_programObj, "value" );
debugLog("Shader::load 10");
loaded = true;
}
catch(...)
{
debugLog("caught exception in shader::load");
loaded = false;
}
#endif
debugLog("End Shader::load()");
}
GLboolean _glfwRefreshContextAttribs(const _GLFWctxconfig* ctxconfig)
{
_GLFWwindow* window = _glfwPlatformGetCurrentContext();
window->GetIntegerv = (PFNGLGETINTEGERVPROC) glfwGetProcAddress("glGetIntegerv");
window->GetString = (PFNGLGETSTRINGPROC) glfwGetProcAddress("glGetString");
window->Clear = (PFNGLCLEARPROC) glfwGetProcAddress("glClear");
if (!parseVersionString(&window->context.api,
&window->context.major,
&window->context.minor,
&window->context.revision))
{
return GL_FALSE;
}
#if defined(_GLFW_USE_OPENGL)
if (window->context.major > 2)
{
// OpenGL 3.0+ uses a different function for extension string retrieval
// We cache it here instead of in glfwExtensionSupported mostly to alert
// users as early as possible that their build may be broken
window->GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
if (!window->GetStringi)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Entry point retrieval is broken");
return GL_FALSE;
}
}
if (window->context.api == GLFW_OPENGL_API)
{
// Read back context flags (OpenGL 3.0 and above)
if (window->context.major >= 3)
{
GLint flags;
window->GetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
window->context.forward = GL_TRUE;
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
window->context.debug = GL_TRUE;
else if (glfwExtensionSupported("GL_ARB_debug_output") &&
ctxconfig->debug)
{
// HACK: This is a workaround for older drivers (pre KHR_debug)
// not setting the debug bit in the context flags for
// debug contexts
window->context.debug = GL_TRUE;
}
}
// Read back OpenGL context profile (OpenGL 3.2 and above)
if (window->context.major > 3 ||
(window->context.major == 3 && window->context.minor >= 2))
{
GLint mask;
window->GetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
window->context.profile = GLFW_OPENGL_CORE_PROFILE;
else if (glfwExtensionSupported("GL_ARB_compatibility"))
{
// HACK: This is a workaround for the compatibility profile bit
// not being set in the context flags if an OpenGL 3.2+
// context was created without having requested a specific
// version
window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
}
}
// Read back robustness strategy
if (glfwExtensionSupported("GL_ARB_robustness"))
{
// NOTE: We avoid using the context flags for detection, as they are
// only present from 3.0 while the extension applies from 1.1
GLint strategy;
window->GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->context.robustness = GLFW_NO_RESET_NOTIFICATION;
}
}
else
{
// Read back robustness strategy
if (glfwExtensionSupported("GL_EXT_robustness"))
{
// NOTE: The values of these constants match those of the OpenGL ARB
// one, so we can reuse them here
GLint strategy;
window->GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->context.robustness = GLFW_NO_RESET_NOTIFICATION;
}
}
if (glfwExtensionSupported("GL_KHR_context_flush_control"))
{
GLint behavior;
window->GetIntegerv(GL_CONTEXT_RELEASE_BEHAVIOR, &behavior);
if (behavior == GL_NONE)
window->context.release = GLFW_RELEASE_BEHAVIOR_NONE;
else if (behavior == GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH)
window->context.release = GLFW_RELEASE_BEHAVIOR_FLUSH;
}
#endif // _GLFW_USE_OPENGL
return GL_TRUE;
}
GLproc getGLProcAddress(const char* procname) {
return glfwGetProcAddress(procname);
}
/*
* loadExtensions() - Load OpenGL extensions for anything above OpenGL
* version 1.1. (This is a requirement only on Windows, so on other
* platforms, this function just checks for the required extensions.)
*/
void loadExtensions() {
//These extension strings indicate that the OpenGL Shading Language
// and GLSL shader objects are supported.
if(!glfwExtensionSupported("GL_ARB_shading_language_100"))
{
printError("GL init error", "GL_ARB_shading_language_100 extension was not found");
return;
}
if(!glfwExtensionSupported("GL_ARB_shader_objects"))
{
printError("GL init error", "GL_ARB_shader_objects extension was not found");
return;
}
else
{
#ifdef __WIN32__
glCreateProgram = (PFNGLCREATEPROGRAMPROC)glfwGetProcAddress("glCreateProgram");
glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glfwGetProcAddress("glDeleteProgram");
glUseProgram = (PFNGLUSEPROGRAMPROC)glfwGetProcAddress("glUseProgram");
glCreateShader = (PFNGLCREATESHADERPROC)glfwGetProcAddress("glCreateShader");
glDeleteShader = (PFNGLDELETESHADERPROC)glfwGetProcAddress("glDeleteShader");
glShaderSource = (PFNGLSHADERSOURCEPROC)glfwGetProcAddress("glShaderSource");
glCompileShader = (PFNGLCOMPILESHADERPROC)glfwGetProcAddress("glCompileShader");
glGetShaderiv = (PFNGLGETSHADERIVPROC)glfwGetProcAddress("glGetShaderiv");
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glfwGetProcAddress("glGetShaderInfoLog");
glAttachShader = (PFNGLATTACHSHADERPROC)glfwGetProcAddress("glAttachShader");
glLinkProgram = (PFNGLLINKPROGRAMPROC)glfwGetProcAddress("glLinkProgram");
glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glfwGetProcAddress("glGetProgramiv");
glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glfwGetProcAddress("glGetProgramInfoLog");
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glfwGetProcAddress("glGetUniformLocation");
glUniform1fv = (PFNGLUNIFORM1FVPROC)glfwGetProcAddress("glUniform1fv");
if( !glCreateProgram || !glDeleteProgram || !glUseProgram ||
!glCreateShader || !glDeleteShader || !glShaderSource || !glCompileShader ||
!glGetShaderiv || !glGetShaderInfoLog || !glAttachShader || !glLinkProgram ||
!glGetProgramiv || !glGetProgramInfoLog || !glGetUniformLocation ||
!glUniform1fv )
{
printError("GL init error", "One or more required OpenGL functions were not found");
return;
}
#endif
}
}
int setupGLSL() {
glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) glfwGetProcAddress("glVertexAttribPointerARB");
glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) glfwGetProcAddress("glEnableVertexAttribArrayARB");
glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) glfwGetProcAddress(
"glIsRenderbufferEXT");
glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) glfwGetProcAddress(
"glBindRenderbufferEXT");
glDeleteRenderbuffersEXT
= (PFNGLDELETERENDERBUFFERSEXTPROC) glfwGetProcAddress(
"glDeleteRenderbuffersEXT");
glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) glfwGetProcAddress(
"glGenRenderbuffersEXT");
glRenderbufferStorageEXT
= (PFNGLRENDERBUFFERSTORAGEEXTPROC) glfwGetProcAddress(
"glRenderbufferStorageEXT");
glGetRenderbufferParameterivEXT
= (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) glfwGetProcAddress(
"glGetRenderbufferParameterivEXT");
glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC) glfwGetProcAddress(
"glIsFramebufferEXT");
glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) glfwGetProcAddress(
"glBindFramebufferEXT");
glDeleteFramebuffersEXT
= (PFNGLDELETEFRAMEBUFFERSEXTPROC) glfwGetProcAddress(
"glDeleteFramebuffersEXT");
glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) glfwGetProcAddress(
"glGenFramebuffersEXT");
glCheckFramebufferStatusEXT
= (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) glfwGetProcAddress(
"glCheckFramebufferStatusEXT");
glFramebufferTexture1DEXT
= (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) glfwGetProcAddress(
"glFramebufferTexture1DEXT");
glFramebufferTexture2DEXT
= (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) glfwGetProcAddress(
"glFramebufferTexture2DEXT");
glFramebufferTexture3DEXT
= (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) glfwGetProcAddress(
"glFramebufferTexture3DEXT");
glFramebufferRenderbufferEXT
= (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) glfwGetProcAddress(
"glFramebufferRenderbufferEXT");
glGetFramebufferAttachmentParameterivEXT
= (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) glfwGetProcAddress(
"glGetFramebufferAttachmentParameterivEXT");
glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) glfwGetProcAddress(
"glGenerateMipmapEXT");
glCreateProgramObjectARB
= (PFNGLCREATEPROGRAMOBJECTARBPROC) glfwGetProcAddress(
"glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) glfwGetProcAddress(
"glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) glfwGetProcAddress(
"glUseProgramObjectARB");
glCreateShaderObjectARB
= (PFNGLCREATESHADEROBJECTARBPROC) glfwGetProcAddress(
"glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) glfwGetProcAddress(
"glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) glfwGetProcAddress(
"glCompileShaderARB");
glGetObjectParameterivARB
= (PFNGLGETOBJECTPARAMETERIVARBPROC) glfwGetProcAddress(
"glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) glfwGetProcAddress(
"glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) glfwGetProcAddress(
"glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) glfwGetProcAddress(
"glLinkProgramARB");
glGetUniformLocationARB
= (PFNGLGETUNIFORMLOCATIONARBPROC) glfwGetProcAddress(
"glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC) glfwGetProcAddress(
"glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC) glfwGetProcAddress(
"glUniform1iARB");
glCreateProgramObjectARB
= (PFNGLCREATEPROGRAMOBJECTARBPROC) glfwGetProcAddress(
"glCreateProgramObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) glfwGetProcAddress(
"glDeleteObjectARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) glfwGetProcAddress(
"glUseProgramObjectARB");
glCreateShaderObjectARB
= (PFNGLCREATESHADEROBJECTARBPROC) glfwGetProcAddress(
"glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) glfwGetProcAddress(
"glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) glfwGetProcAddress(
"glCompileShaderARB");
glGetObjectParameterivARB
= (PFNGLGETOBJECTPARAMETERIVARBPROC) glfwGetProcAddress(
"glGetObjectParameterivARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) glfwGetProcAddress(
"glAttachObjectARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) glfwGetProcAddress(
"glGetInfoLogARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) glfwGetProcAddress(
"glLinkProgramARB");
glGetUniformLocationARB
= (PFNGLGETUNIFORMLOCATIONARBPROC) glfwGetProcAddress(
"glGetUniformLocationARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC) glfwGetProcAddress(
"glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC) glfwGetProcAddress(
"glUniform1iARB");
glUniform1fARB = (PFNGLUNIFORM1FARBPROC) glfwGetProcAddress(
"glUniform1fARB");
glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) glfwGetProcAddress(
"glGenBuffersARB");
glBindBufferARB = (PFNGLBINDBUFFERARBPROC) glfwGetProcAddress(
"glBindBufferARB");
glBufferDataARB = (PFNGLBUFFERDATAARBPROC) glfwGetProcAddress(
"glBufferDataARB");
glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) glfwGetProcAddress(
"glDeleteBuffersARB");
glMapBufferARB = (PFNGLMAPBUFFERARBPROC) glfwGetProcAddress("glMapBufferARB");
glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC) glfwGetProcAddress("glUnmapBufferARB");
}
GLFWAPI int GLFWAPIENTRY glfwOpenWindow( int width, int height,
int redbits, int greenbits, int bluebits, int alphabits,
int depthbits, int stencilbits, int mode )
{
_GLFWfbconfig fbconfig;
_GLFWwndconfig wndconfig;
if( !_glfwInitialized || _glfwWin.opened )
{
return GL_FALSE;
}
// Set up desired framebuffer config
fbconfig.redBits = Max( redbits, 0 );
fbconfig.greenBits = Max( greenbits, 0 );
fbconfig.blueBits = Max( bluebits, 0 );
fbconfig.alphaBits = Max( alphabits, 0 );
fbconfig.depthBits = Max( depthbits, 0 );
fbconfig.stencilBits = Max( stencilbits, 0 );
fbconfig.accumRedBits = Max( _glfwLibrary.hints.accumRedBits, 0 );
fbconfig.accumGreenBits = Max( _glfwLibrary.hints.accumGreenBits, 0 );
fbconfig.accumBlueBits = Max( _glfwLibrary.hints.accumBlueBits, 0 );
fbconfig.accumAlphaBits = Max( _glfwLibrary.hints.accumAlphaBits, 0 );
fbconfig.auxBuffers = Max( _glfwLibrary.hints.auxBuffers, 0 );
fbconfig.stereo = _glfwLibrary.hints.stereo ? GL_TRUE : GL_FALSE;
fbconfig.samples = Max( _glfwLibrary.hints.samples, 0 );
// Set up desired window config
wndconfig.mode = mode;
wndconfig.refreshRate = Max( _glfwLibrary.hints.refreshRate, 0 );
wndconfig.windowNoResize = _glfwLibrary.hints.windowNoResize ? GL_TRUE : GL_FALSE;
wndconfig.glMajor = Max( _glfwLibrary.hints.glMajor, 1 );
wndconfig.glMinor = Max( _glfwLibrary.hints.glMinor, 0 );
wndconfig.glForward = _glfwLibrary.hints.glForward ? GL_TRUE : GL_FALSE;
wndconfig.glDebug = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE;
wndconfig.glProfile = _glfwLibrary.hints.glProfile;
if( wndconfig.glMajor == 1 && wndconfig.glMinor > 5 )
{
// OpenGL 1.x series ended with version 1.5
return GL_FALSE;
}
else if( wndconfig.glMajor == 2 && wndconfig.glMinor > 1 )
{
// OpenGL 2.x series ended with version 2.1
return GL_FALSE;
}
else if( wndconfig.glMajor == 3 && wndconfig.glMinor > 3 )
{
// OpenGL 3.x series ended with version 3.3
return GL_FALSE;
}
else
{
// For now, let everything else through
}
if( wndconfig.glProfile &&
( wndconfig.glMajor < 3 || ( wndconfig.glMajor == 3 && wndconfig.glMinor < 2 ) ) )
{
// Context profiles are only defined for OpenGL version 3.2 and above
return GL_FALSE;
}
if( wndconfig.glForward && wndconfig.glMajor < 3 )
{
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
return GL_FALSE;
}
// Clear for next open call
_glfwClearWindowHints();
// Check input arguments
if( mode != GLFW_WINDOW && mode != GLFW_FULLSCREEN )
{
return GL_FALSE;
}
// Clear GLFW window state
_glfwWin.active = GL_TRUE;
_glfwWin.iconified = GL_FALSE;
_glfwWin.mouseLock = GL_FALSE;
_glfwWin.autoPollEvents = GL_TRUE;
_glfwClearInput();
// Unregister all callback functions
_glfwWin.windowSizeCallback = NULL;
_glfwWin.windowCloseCallback = NULL;
_glfwWin.windowRefreshCallback = NULL;
_glfwWin.keyCallback = NULL;
_glfwWin.charCallback = NULL;
_glfwWin.mousePosCallback = NULL;
_glfwWin.mouseButtonCallback = NULL;
_glfwWin.mouseWheelCallback = NULL;
// Check width & height
if( width > 0 && height <= 0 )
{
// Set the window aspect ratio to 4:3
height = (width * 3) / 4;
}
else if( width <= 0 && height > 0 )
{
// Set the window aspect ratio to 4:3
width = (height * 4) / 3;
}
else if( width <= 0 && height <= 0 )
{
// Default window size
width = 640;
height = 480;
}
// Remember window settings
_glfwWin.width = width;
_glfwWin.height = height;
_glfwWin.fullscreen = (mode == GLFW_FULLSCREEN ? GL_TRUE : GL_FALSE);
// Platform specific window opening routine
if( !_glfwPlatformOpenWindow( width, height, &wndconfig, &fbconfig ) )
{
glfwCloseWindow();
return GL_FALSE;
}
// Flag that window is now opened
_glfwWin.opened = GL_TRUE;
// Read back window and context parameters
_glfwPlatformRefreshWindowParams();
_glfwRefreshContextParams();
if( _glfwWin.glMajor < wndconfig.glMajor ||
( _glfwWin.glMajor == wndconfig.glMajor &&
_glfwWin.glMinor < wndconfig.glMinor ) )
{
glfwCloseWindow();
return GL_FALSE;
}
// Do we have non-power-of-two textures (added to core in version 2.0)?
_glfwWin.has_GL_ARB_texture_non_power_of_two =
( _glfwWin.glMajor >= 2 ) ||
glfwExtensionSupported( "GL_ARB_texture_non_power_of_two" );
// Do we have automatic mipmap generation (added to core in version 1.4)?
_glfwWin.has_GL_SGIS_generate_mipmap =
( _glfwWin.glMajor >= 2 ) || ( _glfwWin.glMinor >= 4 ) ||
glfwExtensionSupported( "GL_SGIS_generate_mipmap" );
if( _glfwWin.glMajor > 2 )
{
_glfwWin.GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress( "glGetStringi" );
if( !_glfwWin.GetStringi )
{
// This is a very common problem among people who compile GLFW
// on X11/GLX using custom build systems, as the glfwGetProcAddress
// code path selection needs explicit configuration
//
// See readme.html section 2.2 for details
glfwCloseWindow();
return GL_FALSE;
}
}
// If full-screen mode was requested, disable mouse cursor
if( mode == GLFW_FULLSCREEN )
{
glfwDisable( GLFW_MOUSE_CURSOR );
}
// Start by clearing the front buffer to black (avoid ugly desktop
// remains in our OpenGL window)
glClear( GL_COLOR_BUFFER_BIT );
_glfwPlatformSwapBuffers();
return GL_TRUE;
}
//»ñÈ¡OpenGLº¯ÊýµØÖ·
void InitGLProc() {
glTexImage3D = (PFNGLTEXIMAGE3DPROC)glfwGetProcAddress("glTexImage3DEXT");
glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glfwGetProcAddress("glTexSubImage3DEXT");
glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glfwGetProcAddress("glActiveTextureARB");
glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glfwGetProcAddress("glEnableVertexAttribArrayARB");
glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glfwGetProcAddress("glDisableVertexAttribArrayARB");
glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glfwGetProcAddress("glGetAttribLocationARB");
glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glfwGetProcAddress("glBindAttribLocationARB");
glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glfwGetProcAddress("glVertexAttribPointerARB");
glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glfwGetProcAddress("glGenBuffersARB");
glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glfwGetProcAddress("glBindBufferARB");
glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glfwGetProcAddress("glBufferDataARB");
glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glfwGetProcAddress("glDeleteBuffersARB");
glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glfwGetProcAddress("glGenFramebuffersEXT");
glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glfwGetProcAddress("glBindFramebufferEXT");
glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glfwGetProcAddress("glDeleteFramebuffersEXT");
glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glfwGetProcAddress("glFramebufferTexture2DEXT");
glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glfwGetProcAddress("glFramebufferTexture3DEXT");
glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glfwGetProcAddress("glCheckFramebufferStatusEXT");
glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glfwGetProcAddress("glCreateShaderObjectARB");
glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glfwGetProcAddress("glShaderSourceARB");
glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glfwGetProcAddress("glCompileShaderARB");
glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glCreateProgramObjectARB");
glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glfwGetProcAddress("glAttachObjectARB");
glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glfwGetProcAddress("glLinkProgramARB");
glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glfwGetProcAddress("glUseProgramObjectARB");
glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glfwGetProcAddress("glGetObjectParameterivARB");
glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glfwGetProcAddress("glGetInfoLogARB");
glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glfwGetProcAddress("glDetachObjectARB");
glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glfwGetProcAddress("glDeleteObjectARB");
glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glfwGetProcAddress("glGetUniformLocationARB");
glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glfwGetProcAddress("glUniform1fARB");
glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glfwGetProcAddress("glUniform2fARB");
glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glfwGetProcAddress("glUniform3fARB");
glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glfwGetProcAddress("glUniform4fARB");
glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glfwGetProcAddress("glUniform1iARB");
glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glfwGetProcAddress("glUniform2iARB");
glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glfwGetProcAddress("glUniform3iARB");
glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glfwGetProcAddress("glUniform4iARB");
glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glfwGetProcAddress("glUniform1fvARB");
glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glfwGetProcAddress("glUniform2fvARB");
glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glfwGetProcAddress("glUniform3fvARB");
glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glfwGetProcAddress("glUniform4fvARB");
glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glfwGetProcAddress("glUniform1ivARB");
glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glfwGetProcAddress("glUniform2ivARB");
glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glfwGetProcAddress("glUniform3ivARB");
glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glfwGetProcAddress("glUniform4ivARB");
glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glfwGetProcAddress("glUniformMatrix2fvARB");
glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glfwGetProcAddress("glUniformMatrix3fvARB");
glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glfwGetProcAddress("glUniformMatrix4fvARB");
glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glfwGetProcAddress("glGetUniformfvARB");
glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glfwGetProcAddress("glGetUniformivARB");
}
void PullInfo(){
printf("================================================================================\n");
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
printf("GLFW version is %i.%i.%i\n", major, minor, rev);
int width, height;
glfwGetWindowSize(&width, &height);
printf("Window size is %i %i\n", width, height);
int status = glfwGetKey(GLFW_KEY_LCTRL);
if(status == GLFW_PRESS)
printf("Left control is pressed\n");
else
printf("Left control is released\n");
status = glfwGetMouseButton(GLFW_MOUSE_BUTTON_1);
if(status == GLFW_PRESS)
printf("Mouse button 1 is pressed\n");
else
printf("Mouse button 1 is released\n");
int x, y;
glfwGetMousePos(&x, &y);
printf("Mouse position is %i %i\n", x, y);
int wheel = glfwGetMouseWheel();
printf("Mouse wheel pos is %i\n", wheel);
double time = glfwGetTime();
printf("Time is %f\n", time);
glfwGetGLVersion(&major, &minor, &rev);
printf("GL version is %i.%i.%i\n", major, minor, rev);
int proc = glfwGetNumberOfProcessors();
printf("%i processors are available\n", proc);
unsigned int i;
for(i = 0; i<nb_params; i++)
printf(" - %-27s : %i\n", GetParamName(params[i]), glfwGetWindowParam(params[i]));
const char* extension = "MOZ_WEBGL_compressed_texture_s3tc";
printf("'%s' extension is %s.\n", extension, glfwExtensionSupported(extension) ? "supported" : "not supported");
extension = "GL_EXT_framebuffer_object";
printf("'%s' extension is %s.\n", extension, glfwExtensionSupported(extension) ? "supported" : "not supported");
extension = "glBindBuffer";
void* proc_addr = glfwGetProcAddress(extension);
printf("'%s' extension proc address is %p.\n", extension, proc_addr);
printf("Sleeping 1 sec...\n");
glfwSleep(1);
printf("...Done.\n");
printf("================================================================================\n");
#ifdef REPORT_RESULT
int result = 1;
REPORT_RESULT();
#endif
}
static void
testBufferStorage(void)
{
if (!GLAD_GL_VERSION_4_4 &&
!glfwExtensionSupported("GL_ARB_buffer_storage")) {
fprintf(stderr, "error: GL_ARB_buffer_storage not supported\n");
glfwTerminate();
exit(EXIT_SKIP);
}
GLbitfield map_trace_explicit_bit = 0;
if (glfwExtensionSupported("GL_VMWX_map_buffer_debug")) {
glNotifyMappedBufferRangeVMWX = (PFNGLNOTIFYMAPPEDBUFFERRANGEVMWXPROC)glfwGetProcAddress("glNotifyMappedBufferRangeVMWX");
assert(glNotifyMappedBufferRangeVMWX);
map_trace_explicit_bit = GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX;
}
GLuint buffer = 0;
glGenBuffers(1, &buffer);
glBindBuffer(target, buffer);
GLsizeiptr size = 1000;
void *data = malloc(size);
memset(data, 0, size);
while ((glGetError() != GL_NO_ERROR))
;
glBufferStorage(target, size, data,
GL_MAP_WRITE_BIT |
GL_MAP_PERSISTENT_BIT |
GL_MAP_COHERENT_BIT |
map_trace_explicit_bit);
free(data);
GLenum error = glGetError();
switch (error) {
case GL_NO_ERROR:
break;
case GL_OUT_OF_MEMORY:
exit(EXIT_SKIP);
default:
exit(EXIT_FAILURE);
}
GLubyte *map;
// straightforward mapping
map = (GLubyte *)glMapBufferRange(target, 100, 100, GL_MAP_WRITE_BIT);
memset(map, 1, 100);
glUnmapBuffer(target);
// persistent mapping w/ explicit flush
map = (GLubyte *)glMapBufferRange(target, 200, 300, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
memset(map + 20, 2, 30);
glFlushMappedBufferRange(target, 20, 30);
memset(map + 50, 3, 50);
glFlushMappedBufferRange(target, 50, 50);
glUnmapBuffer(target);
// persistent & coherent mapping
map = (GLubyte *)glMapBufferRange(target, 500, 100, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | map_trace_explicit_bit);
memset(map + 20, 4, 30);
glNotifyMappedBufferRangeVMWX(map + 20, 30);
memset(map + 50, 5, 50);
glNotifyMappedBufferRangeVMWX(map + 50, 50);
glUnmapBuffer(target);
glBindBuffer(target, 0);
glDeleteBuffers(1, &buffer);
}
GLFWView::GLFWView(bool fullscreen) : fullscreen(fullscreen) {
#ifdef NVIDIA
glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXTPROC)glfwGetProcAddress("glDiscardFramebufferEXT");
#endif
}
bool DrawDelegate::SetupOpenGL() {
#ifndef MACOSX
glCreateShader = (PFNGLCREATESHADERPROC) glfwGetProcAddress( "glCreateShader" );
glShaderSource = (PFNGLSHADERSOURCEPROC) glfwGetProcAddress( "glShaderSource" );
glCompileShader = (PFNGLCOMPILESHADERPROC) glfwGetProcAddress( "glCompileShader" );
glGetShaderiv = (PFNGLGETSHADERIVPROC) glfwGetProcAddress( "glGetShaderiv" );
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) glfwGetProcAddress( "glGetShaderInfoLog" );
glDeleteShader = (PFNGLDELETESHADERPROC) glfwGetProcAddress( "glDeleteShader" );
glCreateProgram = (PFNGLCREATEPROGRAMPROC) glfwGetProcAddress( "glCreateProgram" );
glAttachShader = (PFNGLATTACHSHADERPROC) glfwGetProcAddress( "glAttachShader" );
glDetachShader = (PFNGLDETACHSHADERPROC) glfwGetProcAddress( "glDetachShader" );
glLinkProgram = (PFNGLLINKPROGRAMPROC) glfwGetProcAddress( "glLinkProgram" );
glGetProgramiv = (PFNGLGETPROGRAMIVPROC) glfwGetProcAddress( "glGetProgramiv" );
glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) glfwGetProcAddress( "glGetProgramInfoLog" );
glUseProgram = (PFNGLUSEPROGRAMPROC) glfwGetProcAddress( "glUseProgram" );
glDeleteProgram = (PFNGLDELETEPROGRAMPROC) glfwGetProcAddress( "glDeleteProgram" );
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) glfwGetProcAddress( "glGetUniformLocation" );
glUniform1i = (PFNGLUNIFORM1IPROC) glfwGetProcAddress( "glUniform1i" );
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) glfwGetProcAddress( "glEnableVertexAttribArray" );
glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) glfwGetProcAddress("glGetAttribLocation");
glGenBuffers = (PFNGLGENBUFFERSPROC) glfwGetProcAddress("glGenBuffers");
glBindBuffer = (PFNGLBINDBUFFERPROC) glfwGetProcAddress("glBindBuffer");
glBufferData = (PFNGLBUFFERDATAPROC) glfwGetProcAddress("glBufferData");
glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) glfwGetProcAddress("glDeleteBuffers");
glBufferSubData = (PFNGLBUFFERSUBDATAPROC) glfwGetProcAddress("glBufferSubData");
glUniform2f = (PFNGLUNIFORM2FPROC) glfwGetProcAddress("glUniform2f");
glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) glfwGetProcAddress("glVertexAttribPointer");
glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) glfwGetProcAddress("glUniformMatrix4fv");
glUniform3f = (PFNGLUNIFORM3FPROC) glfwGetProcAddress("glUniform3f");
glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) glfwGetProcAddress("glBlendEquationSeparate");
if (!(glActiveTexture && glCreateShader && glShaderSource && glCompileShader &&
glGetShaderiv && glGetShaderInfoLog && glDeleteShader && glCreateProgram &&
glAttachShader && glDetachShader && glLinkProgram && glGetProgramiv && glGetProgramInfoLog &&
glUseProgram && glDeleteProgram && glGetUniformLocation && glUniform1i &&
glGetAttribLocation && glGenBuffers && glBindBuffer && glBufferData && glDeleteBuffers && glEnableVertexAttribArray &&
glUniform2f && glVertexAttribPointer && glUniformMatrix4fv && glUniform3f))
return 0;
#endif
//glEnable(GL_TEXTURE_2D);
//glEnable(GL_ALPHA_TEST);
//glAlphaFunc(GL_GREATER,0.1f);
glEnable(GL_DEPTH_TEST);
//glDisable(GL_CULL_FACE);
/* Set up shaders */
GLuint vertexShader, fragmentShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vertexShader, 1, (const char**)&vertexSource, NULL);
glShaderSource(fragmentShader, 1,(const char**)&fragmentSource, NULL);
char buffer[10000];
int l;
printf("%s\n%s\n",glGetString(GL_VERSION),glGetString(GL_SHADING_LANGUAGE_VERSION));
/* Compile our shader objects */
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
glGetShaderInfoLog(vertexShader,10000,&l,buffer);
if (buffer[0] != 0) {
//MessageBox(NULL,buffer,"VERTEX", MB_OK);
fprintf(stderr, "VERTEX:\n%s",buffer);
}
glGetShaderInfoLog(fragmentShader,10000,&l,buffer);
if (buffer[0] != 0) {
//MessageBox(NULL,buffer,"FRAGMENT", MB_OK);
fprintf(stderr, "FRAGMENT:\n%s",buffer);
}
shaderProgram = glCreateProgram();
/* Attach our shaders to our program */
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
/* Bind attribute index 0 (shaderAtribute) to in_Position*/
/* "in_Position" will represent "data" array's contents in the vertex shader */
//glBindAttribLocation(shaderProgram, shaderAtribute, "in_Position");
/* Link shader program*/
glLinkProgram(shaderProgram);
GLint status;
glGetProgramiv (shaderProgram, GL_LINK_STATUS, &status);
if (status == GL_FALSE)
{
GLint infoLogLength;
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &infoLogLength);
char *strInfoLog = new char[infoLogLength + 1];
glGetProgramInfoLog(shaderProgram, infoLogLength, NULL, strInfoLog);
fprintf(stderr, "Linker failure: %s\n", strInfoLog);
delete[] strInfoLog;
exit(1);
}
/* Set shader program as being actively used */
glUseProgram(shaderProgram);
positionAttribute = glGetAttribLocation(shaderProgram,"position");
colorAttribute = glGetAttribLocation(shaderProgram,"colorQ");
viewMatrixUniform = glGetUniformLocation(shaderProgram, "viewMatrix");
glEnableVertexAttribArray(positionAttribute);
glEnableVertexAttribArray(colorAttribute);
/*-------------------------------------------------------------------------------------------------------*/
glGenBuffers(1, &colorVBO);
glBindBuffer(GL_ARRAY_BUFFER, colorVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*DDcolorbufferSize, NULL, GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &pointVBO);
glBindBuffer(GL_ARRAY_BUFFER, pointVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*DDbufferSize, NULL, GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, colorVBO);
glVertexAttribPointer(colorAttribute, 3, GL_FLOAT, false, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, pointVBO);
glVertexAttribPointer(positionAttribute, 3, GL_FLOAT, false, 0, 0);
glClearColor(1,1,1,1);
glColor4f(1.0,1.0,1.0,1.0);
//glLineWidth(5);
glPointSize(10);
GLenum temp = glGetError();
if (temp != GL_NO_ERROR) {
fprintf(stderr, "Got GL error: %x line %i\n", temp, __LINE__);
}
return 1;
}
void load_opengl_functions() {
glActiveTexture = (PFNGLACTIVETEXTUREPROC)glfwGetProcAddress("glActiveTexture");
glAttachShader = (PFNGLATTACHSHADERPROC)glfwGetProcAddress("glAttachShader");
glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glfwGetProcAddress("glBindAttribLocation");
glBindBuffer = (PFNGLBINDBUFFERPROC)glfwGetProcAddress("glBindBuffer");
glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glfwGetProcAddress("glBindFramebuffer");
glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glfwGetProcAddress("glBindRenderbuffer");
glBindTexture = (PFNGLBINDTEXTUREPROC)glfwGetProcAddress("glBindTexture");
glBlendColor = (PFNGLBLENDCOLORPROC)glfwGetProcAddress("glBlendColor");
glBlendEquation = (PFNGLBLENDEQUATIONPROC)glfwGetProcAddress("glBlendEquation");
glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glfwGetProcAddress("glBlendEquationSeparate");
glBlendFunc = (PFNGLBLENDFUNCPROC)glfwGetProcAddress("glBlendFunc");
glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glfwGetProcAddress("glBlendFuncSeparate");
glBufferData = (PFNGLBUFFERDATAPROC)glfwGetProcAddress("glBufferData");
glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glfwGetProcAddress("glBufferSubData");
glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glfwGetProcAddress("glCheckFramebufferStatus");
glClear = (PFNGLCLEARPROC)glfwGetProcAddress("glClear");
glClearColor = (PFNGLCLEARCOLORPROC)glfwGetProcAddress("glClearColor");
glClearDepthf = (PFNGLCLEARDEPTHFPROC)glfwGetProcAddress("glClearDepthf");
glClearStencil = (PFNGLCLEARSTENCILPROC)glfwGetProcAddress("glClearStencil");
glColorMask = (PFNGLCOLORMASKPROC)glfwGetProcAddress("glColorMask");
glCompileShader = (PFNGLCOMPILESHADERPROC)glfwGetProcAddress("glCompileShader");
glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glfwGetProcAddress("glCompressedTexImage2D");
glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glfwGetProcAddress("glCompressedTexSubImage2D");
glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)glfwGetProcAddress("glCopyTexImage2D");
glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)glfwGetProcAddress("glCopyTexSubImage2D");
glCreateProgram = (PFNGLCREATEPROGRAMPROC)glfwGetProcAddress("glCreateProgram");
glCreateShader = (PFNGLCREATESHADERPROC)glfwGetProcAddress("glCreateShader");
glCullFace = (PFNGLCULLFACEPROC)glfwGetProcAddress("glCullFace");
glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glfwGetProcAddress("glDeleteBuffers");
glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glfwGetProcAddress("glDeleteFramebuffers");
glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glfwGetProcAddress("glDeleteProgram");
glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glfwGetProcAddress("glDeleteRenderbuffers");
glDeleteShader = (PFNGLDELETESHADERPROC)glfwGetProcAddress("glDeleteShader");
glDeleteTextures = (PFNGLDELETETEXTURESPROC)glfwGetProcAddress("glDeleteTextures");
glDepthFunc = (PFNGLDEPTHFUNCPROC)glfwGetProcAddress("glDepthFunc");
glDepthMask = (PFNGLDEPTHMASKPROC)glfwGetProcAddress("glDepthMask");
glDepthRangef = (PFNGLDEPTHRANGEFPROC)glfwGetProcAddress("glDepthRangef");
glDetachShader = (PFNGLDETACHSHADERPROC)glfwGetProcAddress("glDetachShader");
glDisable = (PFNGLDISABLEPROC)glfwGetProcAddress("glDisable");
glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glfwGetProcAddress("glDisableVertexAttribArray");
glDrawArrays = (PFNGLDRAWARRAYSPROC)glfwGetProcAddress("glDrawArrays");
glDrawElements = (PFNGLDRAWELEMENTSPROC)glfwGetProcAddress("glDrawElements");
glEnable = (PFNGLENABLEPROC)glfwGetProcAddress("glEnable");
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glfwGetProcAddress("glEnableVertexAttribArray");
glFinish = (PFNGLFINISHPROC)glfwGetProcAddress("glFinish");
glFlush = (PFNGLFLUSHPROC)glfwGetProcAddress("glFlush");
glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glfwGetProcAddress("glFramebufferRenderbuffer");
glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glfwGetProcAddress("glFramebufferTexture2D");
glFrontFace = (PFNGLFRONTFACEPROC)glfwGetProcAddress("glFrontFace");
glGenBuffers = (PFNGLGENBUFFERSPROC)glfwGetProcAddress("glGenBuffers");
glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glfwGetProcAddress("glGenerateMipmap");
glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glfwGetProcAddress("glGenFramebuffers");
glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glfwGetProcAddress("glGenRenderbuffers");
glGenTextures = (PFNGLGENTEXTURESPROC)glfwGetProcAddress("glGenTextures");
glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glfwGetProcAddress("glGetActiveAttrib");
glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glfwGetProcAddress("glGetActiveUniform");
glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glfwGetProcAddress("glGetAttachedShaders");
glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glfwGetProcAddress("glGetAttribLocation");
glGetBooleanv = (PFNGLGETBOOLEANVPROC)glfwGetProcAddress("glGetBooleanv");
glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glfwGetProcAddress("glGetBufferParameteriv");
glGetError = (PFNGLGETERRORPROC)glfwGetProcAddress("glGetError");
glGetFloatv = (PFNGLGETFLOATVPROC)glfwGetProcAddress("glGetFloatv");
glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glfwGetProcAddress("glGetFramebufferAttachmentParameteriv");
glGetIntegerv = (PFNGLGETINTEGERVPROC)glfwGetProcAddress("glGetIntegerv");
glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glfwGetProcAddress("glGetProgramiv");
glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glfwGetProcAddress("glGetProgramInfoLog");
glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glfwGetProcAddress("glGetRenderbufferParameteriv");
glGetShaderiv = (PFNGLGETSHADERIVPROC)glfwGetProcAddress("glGetShaderiv");
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glfwGetProcAddress("glGetShaderInfoLog");
glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glfwGetProcAddress("glGetShaderPrecisionFormat");
glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glfwGetProcAddress("glGetShaderSource");
glGetString = (PFNGLGETSTRINGPROC)glfwGetProcAddress("glGetString");
glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)glfwGetProcAddress("glGetTexParameterfv");
glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)glfwGetProcAddress("glGetTexParameteriv");
glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glfwGetProcAddress("glGetUniformfv");
glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glfwGetProcAddress("glGetUniformiv");
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glfwGetProcAddress("glGetUniformLocation");
glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glfwGetProcAddress("glGetVertexAttribfv");
glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glfwGetProcAddress("glGetVertexAttribiv");
glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glfwGetProcAddress("glGetVertexAttribPointerv");
glHint = (PFNGLHINTPROC)glfwGetProcAddress("glHint");
glIsBuffer = (PFNGLISBUFFERPROC)glfwGetProcAddress("glIsBuffer");
glIsEnabled = (PFNGLISENABLEDPROC)glfwGetProcAddress("glIsEnabled");
glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glfwGetProcAddress("glIsFramebuffer");
glIsProgram = (PFNGLISPROGRAMPROC)glfwGetProcAddress("glIsProgram");
glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glfwGetProcAddress("glIsRenderbuffer");
glIsShader = (PFNGLISSHADERPROC)glfwGetProcAddress("glIsShader");
glIsTexture = (PFNGLISTEXTUREPROC)glfwGetProcAddress("glIsTexture");
glLineWidth = (PFNGLLINEWIDTHPROC)glfwGetProcAddress("glLineWidth");
glLinkProgram = (PFNGLLINKPROGRAMPROC)glfwGetProcAddress("glLinkProgram");
glPixelStorei = (PFNGLPIXELSTOREIPROC)glfwGetProcAddress("glPixelStorei");
glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)glfwGetProcAddress("glPolygonOffset");
glReadPixels = (PFNGLREADPIXELSPROC)glfwGetProcAddress("glReadPixels");
glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glfwGetProcAddress("glReleaseShaderCompiler");
glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glfwGetProcAddress("glRenderbufferStorage");
glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glfwGetProcAddress("glSampleCoverage");
glScissor = (PFNGLSCISSORPROC)glfwGetProcAddress("glScissor");
glShaderBinary = (PFNGLSHADERBINARYPROC)glfwGetProcAddress("glShaderBinary");
glShaderSource = (PFNGLSHADERSOURCEPROC)glfwGetProcAddress("glShaderSource");
glStencilFunc = (PFNGLSTENCILFUNCPROC)glfwGetProcAddress("glStencilFunc");
glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glfwGetProcAddress("glStencilFuncSeparate");
glStencilMask = (PFNGLSTENCILMASKPROC)glfwGetProcAddress("glStencilMask");
glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glfwGetProcAddress("glStencilMaskSeparate");
glStencilOp = (PFNGLSTENCILOPPROC)glfwGetProcAddress("glStencilOp");
glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glfwGetProcAddress("glStencilOpSeparate");
glTexImage2D = (PFNGLTEXIMAGE2DPROC)glfwGetProcAddress("glTexImage2D");
glTexParameterf = (PFNGLTEXPARAMETERFPROC)glfwGetProcAddress("glTexParameterf");
glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)glfwGetProcAddress("glTexParameterfv");
glTexParameteri = (PFNGLTEXPARAMETERIPROC)glfwGetProcAddress("glTexParameteri");
glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)glfwGetProcAddress("glTexParameteriv");
glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)glfwGetProcAddress("glTexSubImage2D");
glUniform1f = (PFNGLUNIFORM1FPROC)glfwGetProcAddress("glUniform1f");
glUniform1fv = (PFNGLUNIFORM1FVPROC)glfwGetProcAddress("glUniform1fv");
glUniform1i = (PFNGLUNIFORM1IPROC)glfwGetProcAddress("glUniform1i");
glUniform1iv = (PFNGLUNIFORM1IVPROC)glfwGetProcAddress("glUniform1iv");
glUniform2f = (PFNGLUNIFORM2FPROC)glfwGetProcAddress("glUniform2f");
glUniform2fv = (PFNGLUNIFORM2FVPROC)glfwGetProcAddress("glUniform2fv");
glUniform2i = (PFNGLUNIFORM2IPROC)glfwGetProcAddress("glUniform2i");
glUniform2iv = (PFNGLUNIFORM2IVPROC)glfwGetProcAddress("glUniform2iv");
glUniform3f = (PFNGLUNIFORM3FPROC)glfwGetProcAddress("glUniform3f");
glUniform3fv = (PFNGLUNIFORM3FVPROC)glfwGetProcAddress("glUniform3fv");
glUniform3i = (PFNGLUNIFORM3IPROC)glfwGetProcAddress("glUniform3i");
glUniform3iv = (PFNGLUNIFORM3IVPROC)glfwGetProcAddress("glUniform3iv");
glUniform4f = (PFNGLUNIFORM4FPROC)glfwGetProcAddress("glUniform4f");
glUniform4fv = (PFNGLUNIFORM4FVPROC)glfwGetProcAddress("glUniform4fv");
glUniform4i = (PFNGLUNIFORM4IPROC)glfwGetProcAddress("glUniform4i");
glUniform4iv = (PFNGLUNIFORM4IVPROC)glfwGetProcAddress("glUniform4iv");
glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glfwGetProcAddress("glUniformMatrix2fv");
glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glfwGetProcAddress("glUniformMatrix3fv");
glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glfwGetProcAddress("glUniformMatrix4fv");
glUseProgram = (PFNGLUSEPROGRAMPROC)glfwGetProcAddress("glUseProgram");
glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glfwGetProcAddress("glValidateProgram");
glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glfwGetProcAddress("glVertexAttrib1f");
glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glfwGetProcAddress("glVertexAttrib1fv");
glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glfwGetProcAddress("glVertexAttrib2f");
glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glfwGetProcAddress("glVertexAttrib2fv");
glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glfwGetProcAddress("glVertexAttrib3f");
glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glfwGetProcAddress("glVertexAttrib3fv");
glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glfwGetProcAddress("glVertexAttrib4f");
glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glfwGetProcAddress("glVertexAttrib4fv");
glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glfwGetProcAddress("glVertexAttribPointer");
glViewport = (PFNGLVIEWPORTPROC)glfwGetProcAddress("glViewport");
}
int main(void)
{
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
GLFWmonitor *monitor = glfwGetPrimaryMonitor();
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
printf("monitor mode: %d, %d\n", mode->width, mode->height);
// if DEBUG {
// glfw.WindowHint(glfw.OpenGLDebugContext, gl.TRUE)
// }
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 1);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
GLFWwindow *window = glfwCreateWindow(mode->width, mode->height, "Hialin", NULL, NULL);
if (!window) {
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwSetKeyCallback(window, key_callback);
glfwMakeContextCurrent(window);
glfwSwapInterval(0);
p_glBindFragDataLocation = (glBindFragDataLocation_t)glfwGetProcAddress("glBindFragDataLocation");
if (!p_glBindFragDataLocation) {
printf("\n failed glBindFragDataLocation");
glfwTerminate();
exit(EXIT_FAILURE);
}
p_glGenVertexArrays = (glGenVertexArrays_t)glfwGetProcAddress("glGenVertexArrays");
if (!p_glGenVertexArrays) {
printf("\n failed glGenVertexArrays");
glfwTerminate();
exit(EXIT_FAILURE);
}
p_glBindVertexArray = (glBindVertexArray_t)glfwGetProcAddress("glBindVertexArray");
if (!p_glBindVertexArray) {
printf("\n failed glBindVertexArray");
glfwTerminate();
exit(EXIT_FAILURE);
}
GLuint vsh = glCreateShader(GL_VERTEX_SHADER);
{
glShaderSource(vsh, 1, &vertex_shader_text, NULL);
glCompileShader(vsh);
int result;
glGetShaderiv(vsh, GL_COMPILE_STATUS, &result );
if (result == GL_FALSE) {
int logLength;
glGetShaderiv(vsh, GL_INFO_LOG_LENGTH, &logLength);
char log[10*1024] = {0};
glGetShaderInfoLog(vsh, logLength, NULL, log);
printf("\nvertex shader compile: %s", log);
glfwTerminate();
exit(EXIT_FAILURE);
}
}
glCheck();
GLuint fsh = glCreateShader(GL_FRAGMENT_SHADER);
{
glShaderSource(fsh, 1, &fragment_shader_text, NULL);
glCompileShader(fsh);
int result;
glGetShaderiv(fsh, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
int logLength;
glGetShaderiv(fsh, GL_INFO_LOG_LENGTH, &logLength);
char log[10*1024] = {0};
glGetShaderInfoLog(fsh, logLength, NULL, log);
printf("\nfragment shader compile: %s", log);
glfwTerminate();
exit(EXIT_FAILURE);
}
}
glCheck();
GLuint program = glCreateProgram();
{
glAttachShader(program, vsh);
glAttachShader(program, fsh);
glLinkProgram(program);
int result;
glGetProgramiv(program, GL_LINK_STATUS, &result);
if (result == GL_FALSE) {
int logLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
char log[10*1024] = {0};
glGetProgramInfoLog(program, logLength, NULL, log);
printf("\nprogram link: \n%s", log);
glfwTerminate();
exit(EXIT_FAILURE);
}
}
glCheck();
glUseProgram(program);
glCheck();
GLint projectionU = glGetUniformLocation(program, "projection");
mat4x4 camera;
vec3 eye = {3, 3, 3}, center = {0, 0, 0}, up = {0, 1, 0};
mat4x4_look_at(camera, eye, center, up);
GLint cameraU = glGetUniformLocation(program, "camera");
glUniformMatrix4fv(cameraU, 1, GL_FALSE, (const float*)camera);
glCheck();
mat4x4 model;
mat4x4_identity(model);
GLint modelU = glGetUniformLocation(program, "model");
glUniformMatrix4fv(modelU, 1, GL_FALSE, (const float*)model);
glCheck();
GLint texU = glGetUniformLocation(program, "tex");
glUniform1i(texU, 0);
p_glBindFragDataLocation(program, 0, "outputColor");
glCheck();
// Load the texture
// char *texturePath = "./Resources/code.png"
// GLuint texture = MakeTexture(0, texturePath);
GLuint texture = MakeTexture(0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glCheck();
// Configure the vertex data
GLuint vao;
p_glGenVertexArrays(1, &vao);
p_glBindVertexArray(vao);
glCheck();
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
glCheck();
GLuint val = glGetAttribLocation(program, "vert");
glEnableVertexAttribArray(val);
glVertexAttribPointer(val, 3, GL_FLOAT, GL_FALSE, 5*4, (const void *)(0*4));
glCheck();
GLuint valTC = glGetAttribLocation(program, "vertTexCoord");
glEnableVertexAttribArray(valTC);
glVertexAttribPointer(valTC, 2, GL_FLOAT, GL_FALSE, 5*4, (const void *)(3*4));
glCheck();
// Configure global settings
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glClearColor(0.0, 0.0, 0.0, 1.0);
glCheck();
long time0 = tick();
float angle = 0.01;
int width = 0, height = 0;
int i = 0;
while (!glfwWindowShouldClose(window))
{
int w, h;
glfwGetFramebufferSize(window, &w, &h);
if (w != width || h != height) {
width = w;
height = h;
glViewport(0, 0, width, height);
printf("buffer size: %d %d\n", w, h);
}
float ratio = width/(float)height;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mat4x4_rotate_Y(model, model, angle);
mat4x4 projection;
mat4x4_perspective(projection, 0.785, ratio, 0.1, 10.0); // 45 degrees == 0.785 radians
glUniformMatrix4fv(projectionU, 1, GL_FALSE, (const float*)projection);
glUniformMatrix4fv(modelU, 1, GL_FALSE, (const float*)model);
for (int i = 0; i < 1*1000; i++) {
glDrawArrays(GL_TRIANGLES, 0, 6*2*3); // 12 triangles
}
i++;
if (i == 100) {
printf("time for 100 frames: %ld\n", tick()-time0);
} else if (i == 1000) {
printf("time for 1000 frames: %ld\n", tick()-time0);
break;
}
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
