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