コミット: 8a215ba90197900dd702c858e19a9984ed357516 - Saffron (git)

Graphics library for Mercury, including OpenGL bindings, TGA image reading, and X11, Win32, and SDL2 windowing and input.

コミットメタ情報

• リビジョン: 8a215ba90197900dd702c858e19a9984ed357516 (tree)
• 日時: 2022-04-27 10:28:29
• 作者: AlaskanEmily <emily@alas...>
• コミッター: AlaskanEmily

ログメッセージ

Generate OpenGL extension and post-1.1 bindings automatically

変更サマリ

• modified: makefile
• add: saffron.gl.buffer.csv
• add: saffron.gl.buffer.inc
• modified: saffron.gl.buffer.m
• modified: saffron.gl.m
• add: saffron.gl.shader.csv
• add: saffron.gl.shader.inc
• modified: saffron.gl.shader.m
• add: saffron.gl_gen.awk

差分

--- a/makefile
+++ b/makefile
@@ -11,6 +11,7 @@ PARALLEL_OPT=`if test ! -z '$(PARALLEL)' ; then echo ' -j $(PARALLEL)' ; fi`
 SAFFRON_MMC_OPTS=$(MMC_OPTS) $(GRADE_OPT) $(PARALLEL_OPT)
 SHARED_MMC_FLAGS=--linkage shared --lib-linkage shared
 STATIC_MMC_FLAGS=--linkage static --lib-linkage static
+AWK?=awk
 
 ALL=build_saffron
 all: $(ALL)
@@ -32,11 +33,20 @@ SAFFRON_TGA_LINK_FLAGS=--search-lib-files-dir "$$ROOT/util/tga" --init-file "$$R
 SAFFRON_GLOW_LINK_FLAGS=--search-lib-files-dir "$$ROOT/util/glow" --init-file "$$ROOT/util/glow/saffron_glow.init" $(GLOW_INCLUDE_FLAGS)
 SAFFRON_WINDOW_LINK_FLAGS=--search-lib-files-dir "$$ROOT/util/window" --init-file "$$ROOT/util/window/saffron_window.init"
 
+# Generated source.
+saffron.gl.buffer.inc: saffron.gl_gen.awk saffron.gl.buffer.csv
+	$(AWK) -F, -f saffron.gl_gen.awk < saffron.gl.buffer.csv > '$@'
+	@touch saffron.gl.buffer.m # Force the Mercury compiler to rebuild this...
+
+saffron.gl.shader.inc: saffron.gl_gen.awk saffron.gl.shader.csv
+	$(AWK) -F, -f saffron.gl_gen.awk < saffron.gl.shader.csv > '$@'
+	@touch saffron.gl.shader.m # Force the Mercury compiler to rebuild this...
+
 # Primary libraries.
 # Each is preceded by the shared object they create (if any, some like the TGA reader is only built static).
 # This is used to copy the shared objects to target directories.
 libsaffron.$(SO): build_saffron
-build_saffron: build_mmath
+build_saffron: build_mmath saffron.gl.buffer.inc saffron.gl.shader.inc
 	ROOT=`pwd` && $(MMC) $(SAFFRON_MMC_OPTS) $(MMATH_LINK_FLAGS) --make libsaffron $(STATIC_MMC_FLAGS)
 	ROOT=`pwd` && $(MMC) $(SAFFRON_MMC_OPTS) $(MMATH_LINK_FLAGS) --make libsaffron $(SHARED_MMC_FLAGS) -L "$$ROOT/mmath" -lmmath -lGL -lX11
 	install libsaffron.$(SO) demo/

--- /dev/null
+++ b/saffron.gl.buffer.csv
@@ -0,0 +1,22 @@
+func,GenBuffers,GLsizei,GLuint*
+func,DeleteBuffers,GLsizei,const GLuint*
+func,BindBuffer,GLenum,GLuint
+func,BufferData,GLenum,SaffronGLsizeiptr,const void*,GLenum
+func,MapBuffer,GLenum,GLenum,=void*
+func,UnmapBuffer,GLenum,=GLboolean
+
+struct,Buffer,GenBuffers,DeleteBuffers,BindBuffer,BufferData,MapBuffer,UnmapBuffer
+
+load,Buffer,core 2.0,ext GL_ARB_vertex_buffer_object ARB
+
+const,GL_ARRAY_BUFFER,0x8892
+const,GL_ELEMENT_ARRAY_BUFFER,0x8893
+const,GL_STREAM_DRAW,0x88E0
+const,GL_STREAM_READ,0x88E1
+const,GL_STREAM_COPY,0x88E2
+const,GL_STATIC_DRAW,0x88E4
+const,GL_STATIC_READ,0x88E5
+const,GL_STATIC_COPY,0x88E6
+const,GL_DYNAMIC_DRAW,0x88E8
+const,GL_DYNAMIC_READ,0x88E9
+const,GL_DYNAMIC_COPY,0x88EA

--- /dev/null
+++ b/saffron.gl.buffer.inc
@@ -0,0 +1,124 @@
+#ifndef SAFFRON_GL_FUNC_VAR
+#define SAFFRON_GL_FUNC_VAR(X) SaffronGL_ ## X ## _PROC X;
+#endif
+#ifndef SAFFRON_GL_FUNC_LOAD
+#define SAFFRON_GL_FUNC_LOAD(X, EXT) \
+    SaffronGL_LoadFunction(gl_ctx, (char*)("gl" #X EXT), &maybe_func); \
+    if(!Saffron_GetCtxFunctionOK(maybe_func, &func)) break; \
+    (ctx->X) = (SaffronGL_ ## X ## _PROC)func; 
+
+#define SAFFRON_GL_LOAD_FUNC_CORE(X) SAFFRON_GL_FUNC_LOAD(X, "")
+#endif
+
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_GenBuffers_PROC)(
+    GLsizei,
+    GLuint*);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_DeleteBuffers_PROC)(
+    GLsizei,
+    const GLuint*);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_BindBuffer_PROC)(
+    GLenum,
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_BufferData_PROC)(
+    GLenum,
+    SaffronGLsizeiptr,
+    const void*,
+    GLenum);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void*(APIENTRY*SaffronGL_MapBuffer_PROC)(
+    GLenum,
+    GLenum);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef GLboolean(APIENTRY*SaffronGL_UnmapBuffer_PROC)(
+    GLenum);
+#endif
+#ifndef SAFFRON_GL_IMPL
+#define SAFFRON_GL_BUFFER_FUNCS(X) \
+    X(GenBuffers) \
+    X(DeleteBuffers) \
+    X(BindBuffer) \
+    X(BufferData) \
+    X(MapBuffer) \
+    X(UnmapBuffer) \
+/* */
+struct SaffronGL_BufferCtx{
+    SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_FUNC_VAR)
+};
+#endif
+#ifndef SAFFRON_GL_IMPL
+#ifdef SAFFRON_GL_EXPECT_BUFFER
+#define SAFFRON_GL_BUFFER_FUNC(CTX, X) (gl ## X)
+#define SAFFRON_GL_BUFFER_CTX MR_Word
+#define SAFFRON_GL_ALLOC_BUFFER_CTX() 0
+#define SAFFRON_GL_LOAD_BUFFER_CTX(GLCTX, CTX) (*(CTX) = 0)
+#else
+#define SAFFRON_GL_BUFFER_FUNC(CTX, X) ((CTX)->X)
+#define SAFFRON_GL_BUFFER_CTX struct SaffronGL_BufferCtx
+int SaffronGL_LoadBufferCtx(MR_Word gl_ctx, struct SaffronGL_BufferCtx **ctx_ptr);
+#define SAFFRON_GL_LOAD_BUFFER_CTX SaffronGL_LoadBufferCtx
+#endif
+#else
+#ifndef SAFFRON_GL_EXPECT_BUFFER
+int SaffronGL_LoadBufferCtx(MR_Word gl_ctx, struct SaffronGL_BufferCtx **ctx_ptr){
+    struct SaffronGL_BufferCtx *ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_BufferCtx));
+    MR_Word maybe_func, func;
+    MR_String err = NULL;
+    MR_Integer major, minor;
+    SaffronGL_Version(gl_ctx, &major, &minor);
+    if(major > 2 || (major == 2 && minor >= 0)) do{
+        SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_LOAD_FUNC_CORE)
+        *ctx_ptr = ctx;
+        return 0;
+    }while(0);
+#define SAFFRON_GL_LOAD_FUNC_BUFFER_ARB(X) SAFFRON_GL_FUNC_LOAD(X, "ARB")
+    if(SaffronGL_SupportsExtension("GL_ARB_vertex_buffer_object")) do{ 
+        SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_LOAD_FUNC_BUFFER_ARB)
+        *ctx_ptr = ctx;
+        return 0;
+    }while(0);
+    return 1;
+}
+#endif
+#endif
+#ifndef GL_ARRAY_BUFFER
+#define GL_ARRAY_BUFFER 0x8892
+#endif
+#ifndef GL_ELEMENT_ARRAY_BUFFER
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#endif
+#ifndef GL_STREAM_DRAW
+#define GL_STREAM_DRAW 0x88E0
+#endif
+#ifndef GL_STREAM_READ
+#define GL_STREAM_READ 0x88E1
+#endif
+#ifndef GL_STREAM_COPY
+#define GL_STREAM_COPY 0x88E2
+#endif
+#ifndef GL_STATIC_DRAW
+#define GL_STATIC_DRAW 0x88E4
+#endif
+#ifndef GL_STATIC_READ
+#define GL_STATIC_READ 0x88E5
+#endif
+#ifndef GL_STATIC_COPY
+#define GL_STATIC_COPY 0x88E6
+#endif
+#ifndef GL_DYNAMIC_DRAW
+#define GL_DYNAMIC_DRAW 0x88E8
+#endif
+#ifndef GL_DYNAMIC_READ
+#define GL_DYNAMIC_READ 0x88E9
+#endif
+#ifndef GL_DYNAMIC_COPY
+#define GL_DYNAMIC_COPY 0x88EA
+#endif

--- a/saffron.gl.buffer.m
+++ b/saffron.gl.buffer.m
@@ -110,112 +110,19 @@
 :- pragma foreign_import_module("C", saffron.gl).
 :- pragma foreign_import_module("C", saffron.geometry).
 
+%-----------------------------------------------------------------------------%
 % Define the native prototypes to handle buffers.
 :- pragma foreign_decl("C", "
+#include ""saffron.gl.buffer.inc""
+    ").
 
-#define SAFFRON_GL_BUFFER_FUNCS(X) \\
-    X(GenBuffers) \\
-    X(DeleteBuffers) \\
-    X(BindBuffer) \\
-    X(BufferData) \\
-    X(MapBuffer) \\
-    X(UnmapBuffer)
-
-typedef void(APIENTRY*SaffronGL_GenBuffers_PROC)(GLsizei, GLuint*);
-
-typedef void(APIENTRY*SaffronGL_DeleteBuffers_PROC)(GLsizei, const GLuint*);
-
-typedef void(APIENTRY*SaffronGL_BindBuffer_PROC)(GLenum, GLuint);
-
-typedef void(APIENTRY*SaffronGL_BufferData_PROC)(
-    GLenum,
-    SaffronGLsizeiptr,
-    const void *,
-    GLenum);
-
-typedef void*(APIENTRY*SaffronGL_MapBuffer_PROC)(GLenum, GLenum);
-
-typedef void(*APIENTRY*SaffronGL_UnmapBuffer_PROC)(GLenum);
-
-#ifdef SAFFRON_GL_EXPECT_BUFFERS
-
-/* TODO: Maybe we should be caching some info here? */
-# define SAFFRON_GL_BUFFER_CTX MR_Word
-# define SAFFRON_GL_BUFFER_FUNC(CTX, FN) gl ## FN
-
-#else
-
-# define SAFFRON_GL_BUFFER_FUNC_VAR(X) \\
-    SaffronGL_ ## X ## _PROC X;
-
-struct SaffronGL_BufferCtx{
-    SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_BUFFER_FUNC_VAR)
-};
-
-# undef SAFFRON_GL_BUFFER_FUNC_VAR
-
-# define SAFFRON_GL_BUFFER_CTX struct SaffronGL_BufferCtx*
-# define SAFFRON_GL_BUFFER_FUNC(CTX, FN) ((CTX)->FN)
-
-#endif
-
-#ifndef GL_ARRAY_BUFFER
-# define GL_ARRAY_BUFFER 0x8892
-#endif
-
-#ifndef GL_ELEMENT_ARRAY_BUFFER
-# define GL_ELEMENT_ARRAY_BUFFER 0x8893
-#endif
-
-#ifndef GL_STREAM_DRAW
-# define GL_STREAM_DRAW 0x88E0
-#endif
-
-#ifndef GL_STREAM_READ
-# define GL_STREAM_READ 0x88E1
-#endif
-
-#ifndef GL_STREAM_COPY
-# define GL_STREAM_COPY 0x88E2
-#endif
-
-#ifndef GL_STATIC_DRAW
-# define GL_STATIC_DRAW 0x88E4
-#endif
-
-#ifndef GL_STATIC_READ
-# define GL_STATIC_READ 0x88E5
-#endif
-
-#ifndef GL_STATIC_COPY
-# define GL_STATIC_COPY 0x88E6
-#endif
-
-#ifndef GL_DYNAMIC_DRAW
-# define GL_DYNAMIC_DRAW 0x88E8
-#endif
-
-#ifndef GL_DYNAMIC_READ
-# define GL_DYNAMIC_READ 0x88E9
-#endif
-
-#ifndef GL_DYNAMIC_COPY
-# define GL_DYNAMIC_COPY 0x88EA
-#endif
-
-#ifndef GL_READ_ONLY
-# define GL_READ_ONLY 0x88B8
-#endif
-
-#ifndef GL_WRITE_ONLY
-# define GL_WRITE_ONLY 0x88B9
-#endif
-
-#ifndef GL_READ_WRITE
-# define GL_READ_WRITE 0x88BA
-#endif
+%-----------------------------------------------------------------------------%
 
-").
+:- pragma foreign_code("C", "
+#define SAFFRON_GL_IMPL
+#include ""saffron.gl.buffer.inc""
+#undef SAFFRON_GL_IMPL
+    ").
 
 %-----------------------------------------------------------------------------%
 
@@ -252,89 +159,25 @@ create_buffer_ctx_error(E) = maybe.error(E).
 
 :- pred create_buffer_ctx_internal(
     gl_load_func_ctx,
-    bool.bool,
     maybe.maybe_error(buffer_ctx),
     io.io, io.io).
 :- mode create_buffer_ctx_internal(
     in,
-    in,
     out,
     di, uo) is det.
 
 :- pragma foreign_proc("C",
-    create_buffer_ctx_internal(Ctx::in, Old::in, MaybeBufferCtx::out, IOi::di, IOo::uo),
+    create_buffer_ctx_internal(Ctx::in, MaybeBufferCtx::out, IOi::di, IOo::uo),
     [may_call_mercury, promise_pure, thread_safe, will_not_throw_exception],
     "
-    
-#ifndef SAFFRON_GL_EXPECT_BUFFERS
-    MR_Bool New = !Old;
-
-    MR_Word maybe_func, func;
-    MR_String err = NULL;
-    struct SaffronGL_BufferCtx *buffer_ctx;
-    buffer_ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_BufferCtx));
-    
-#ifdef _WIN32
-    Old = MR_TRUE;
-#endif
-
-# define SAFFRON_GL_BUFFER_FUNC_LOAD(ERR, X, NAME) { \\
-    SaffronGL_LoadFunction(Ctx, (char*)(NAME), &maybe_func); \\
-    err = NULL; \\
-    if(Saffron_GetCtxFunctionOK(maybe_func, &func)) \\
-         buffer_ctx->X = (SaffronGL_ ## X ## _PROC)func; \\
-    else if(Saffron_GetCtxFunctionError(maybe_func, &err)) \\
-         goto ERR; \\
-    else \\
-        MR_assert(0); \\
-}
-
-# define SAFFRON_GL_BUFFER_FUNC_LOAD_ARB(X) \\
-    SAFFRON_GL_BUFFER_FUNC_LOAD( \\
-        saffron_gl_create_buffer_ctx_internal_no_arb, \\
-        X, \\
-        ""gl"" #X ""ARB"")
-
-# define SAFFRON_GL_BUFFER_FUNC_LOAD_NEW(X) \\
-    SAFFRON_GL_BUFFER_FUNC_LOAD( \\
-        saffron_gl_create_buffer_ctx_internal, \\
-        X, \\
-        ""gl"" #X)
-
-    /* For OpenGL versions before 2.1, only use the ARB version. */
-    if(Old){
-        /* Yes, this is slightly incorrect... */
-        if(strstr(
-            (char*)glGetString(GL_EXTENSIONS),
-            ""GL_ARB_vertex_buffer_object"") != NULL){
-            
-            SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_BUFFER_FUNC_LOAD_ARB)
-            
-            /* If we made it this far, just go to the end. */
-            goto saffron_gl_create_buffer_ctx_internal;
-        }
-    }
-saffron_gl_create_buffer_ctx_internal_no_arb:
-    if(New){
-        SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_BUFFER_FUNC_LOAD_NEW)
-    }
-saffron_gl_create_buffer_ctx_internal:
-
-#undef SAFFRON_GL_BUFFER_FUNC_LOAD_NEW
-#undef SAFFRON_GL_BUFFER_FUNC_LOAD_ARB
-#undef SAFFRON_GL_BUFFER_FUNC_LOAD
-
-    if(err == NULL){
-        MaybeBufferCtx = SaffronGL_CreateBufferCtxOK(buffer_ctx);
+    SAFFRON_GL_BUFFER_CTX ctx;
+    if(SAFFRON_GL_LOAD_BUFFER_CTX(Ctx, &ctx) == 0){
+        MaybeBufferCtx = SaffronGL_CreateBufferCtxOK(ctx);
     }
     else{
-        MR_GC_free(buffer_ctx);
-        MaybeBufferCtx = SaffronGL_CreateBufferCtxError(err);
+        MaybeBufferCtx = SaffronGL_CreateBufferCtxError(
+            (MR_String)""Could not create context"");
     }
-#else
-    MaybeBufferCtx = SaffronGL_CreateBufferCtxOK(0);
-#endif
-    
     IOo = IOi;
     ").
 
@@ -342,27 +185,8 @@ saffron_gl_create_buffer_ctx_internal:
 
 create_buffer_ctx(Ctx, MaybeBufferCtx, !IO) :-
     saffron.make_current(Ctx, !IO),
-    saffron.gl.opengl_version(Ctx, MaybeSemVer, !IO),
-    (
-        MaybeSemVer = maybe.ok(SemVer),
-        ( if
-            saffron.sem_ver_compare((<), SemVer, saffron.sem_ver(2, 1))
-        then
-            Old = bool.yes
-        else
-            Old = bool.no
-        )
-    ;
-        MaybeSemVer = maybe.error(Err),
-        trace [io(!XIO)] (
-            io.write_string("Error reading OpenGL version: ", !XIO),
-            io.write_string(Err, !XIO),
-            io.nl(!XIO)
-        ),
-        Old = bool.yes
-    ),
     LoadFuncCtx = 'new gl_load_func_ctx'(Ctx),
-    create_buffer_ctx_internal(LoadFuncCtx, Old, MaybeBufferCtx, !IO).
+    create_buffer_ctx_internal(LoadFuncCtx, MaybeBufferCtx, !IO).
 
 %-----------------------------------------------------------------------------%
 

--- a/saffron.gl.m
+++ b/saffron.gl.m
@@ -129,16 +129,20 @@ typedef char SaffronGLchar;
  *
  * See: http://support.apple.com/kb/TA22513
  */
-# define SAFFRON_GL_EXPECT_BUFFERS
+# define SAFFRON_GL_EXPECT_BUFFER
 # define GL_GLEXT_PROTOTYPES
 # include <OpenGL/gl.h>
 # include <OpenGL/glext.h>
 
+# ifndef APIENTRY
+#   define APIENTRY
+# endif
+
 #else
 
 # if (defined __linux__) || (defined __OpenBSD__) || (defined __FreeBSD__)
-#   define SAFFRON_GL_EXPECT_BUFFERS
-#   define SAFFRON_GL_EXPECT_SHADERS
+#   define SAFFRON_GL_EXPECT_BUFFER
+#   define SAFFRON_GL_EXPECT_SHADER
 #   define GL_GLEXT_PROTOTYPES
 # endif
 
@@ -165,16 +169,6 @@ typedef void(APIENTRY*SaffronGL_DrawTextureNV_PROC)(
     GLfloat,
     GLfloat);
 
-struct SaffronGL_DrawTextureNV_ext{
-    SaffronGL_DrawTextureNV_PROC draw_texture_nv;
-};
-
-# define SAFFRON_GL_DRAW_TEXTURE_NV_EXT ""GL_NV_draw_texture""
-
-# define SAFFRON_GL_DRAW_TEXTURE_NV_INIT(TO, LOAD) do{ \\
-    (TO)->draw_texture_nv = (LOAD(""glDrawTextureNV"")); \\
-}while(0)
-
 #ifndef GL_SHADING_LANGUAGE_VERSION
 # define GL_SHADING_LANGUAGE_VERSION 0x8B8C
 #endif

--- /dev/null
+++ b/saffron.gl.shader.csv
@@ -0,0 +1,26 @@
+func,CreateShader,GLenum,=GLuint
+func,DeleteShader,GLuint
+func,ShaderSource,GLuint,GLsizei,const SaffronGLchar**,const GLint
+func,CompileShader,GLuint
+func,GetShaderiv,GLuint,GLenum,GLint*
+func,GetShaderInfoLog,GLuint,GLsizei,GLsizei*,SaffronGLchar*
+func,CreateProgram,void,=GLuint
+func,DeleteProgram,GLuint
+func,LinkProgram,GLuint
+func,AttachShader,GLuint,GLuint
+func,UseProgram,GLuint
+func,GetProgramiv,GLuint,GLenum,GLint*
+
+struct,Shader,CreateShader,DeleteShader,ShaderSource,CompileShader,GetShaderiv,GetShaderInfoLog,CreateProgram,DeleteProgram,LinkProgram,AttachShader,UseProgram,GetProgramiv
+
+load,Shader,core 2.0
+
+const,GL_SHADING_LANGUAGE_VERSION,0x8B8C
+const,GL_VERTEX_SHADER,0x8B31
+const,GL_FRAGMENT_SHADER,0x8B30
+const,GL_GEOMETRY_SHADER,0x8DD9
+const,GL_COMPILE_STATUS,0x8B81
+const,GL_LINK_STATUS,0x8B82
+const,GL_VALIDATE_STATUS,0x8B83
+const,GL_INFO_LOG_LENGTH,0x8B84
+

--- /dev/null
+++ b/saffron.gl.shader.inc
@@ -0,0 +1,143 @@
+#ifndef SAFFRON_GL_FUNC_VAR
+#define SAFFRON_GL_FUNC_VAR(X) SaffronGL_ ## X ## _PROC X;
+#endif
+#ifndef SAFFRON_GL_FUNC_LOAD
+#define SAFFRON_GL_FUNC_LOAD(X, EXT) \
+    SaffronGL_LoadFunction(gl_ctx, (char*)("gl" #X EXT), &maybe_func); \
+    if(!Saffron_GetCtxFunctionOK(maybe_func, &func)) break; \
+    (ctx->X) = (SaffronGL_ ## X ## _PROC)func; 
+
+#define SAFFRON_GL_LOAD_FUNC_CORE(X) SAFFRON_GL_FUNC_LOAD(X, "")
+#endif
+
+#ifndef SAFFRON_GL_IMPL
+typedef GLuint(APIENTRY*SaffronGL_CreateShader_PROC)(
+    GLenum);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_DeleteShader_PROC)(
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_ShaderSource_PROC)(
+    GLuint,
+    GLsizei,
+    const SaffronGLchar**,
+    const GLint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_CompileShader_PROC)(
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_GetShaderiv_PROC)(
+    GLuint,
+    GLenum,
+    GLint*);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_GetShaderInfoLog_PROC)(
+    GLuint,
+    GLsizei,
+    GLsizei*,
+    SaffronGLchar*);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef GLuint(APIENTRY*SaffronGL_CreateProgram_PROC)(
+    void);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_DeleteProgram_PROC)(
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_LinkProgram_PROC)(
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_AttachShader_PROC)(
+    GLuint,
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_UseProgram_PROC)(
+    GLuint);
+#endif
+#ifndef SAFFRON_GL_IMPL
+typedef void(APIENTRY*SaffronGL_GetProgramiv_PROC)(
+    GLuint,
+    GLenum,
+    GLint*);
+#endif
+#ifndef SAFFRON_GL_IMPL
+#define SAFFRON_GL_SHADER_FUNCS(X) \
+    X(CreateShader) \
+    X(DeleteShader) \
+    X(ShaderSource) \
+    X(CompileShader) \
+    X(GetShaderiv) \
+    X(GetShaderInfoLog) \
+    X(CreateProgram) \
+    X(DeleteProgram) \
+    X(LinkProgram) \
+    X(AttachShader) \
+    X(UseProgram) \
+    X(GetProgramiv) \
+/* */
+struct SaffronGL_ShaderCtx{
+    SAFFRON_GL_SHADER_FUNCS(SAFFRON_GL_FUNC_VAR)
+};
+#endif
+#ifndef SAFFRON_GL_IMPL
+#ifdef SAFFRON_GL_EXPECT_SHADER
+#define SAFFRON_GL_SHADER_FUNC(CTX, X) (gl ## X)
+#define SAFFRON_GL_SHADER_CTX MR_Word
+#define SAFFRON_GL_ALLOC_SHADER_CTX() 0
+#define SAFFRON_GL_LOAD_SHADER_CTX(GLCTX, CTX) (*(CTX) = 0)
+#else
+#define SAFFRON_GL_SHADER_FUNC(CTX, X) ((CTX)->X)
+#define SAFFRON_GL_SHADER_CTX struct SaffronGL_ShaderCtx
+int SaffronGL_LoadShaderCtx(MR_Word gl_ctx, struct SaffronGL_ShaderCtx **ctx_ptr);
+#define SAFFRON_GL_LOAD_SHADER_CTX SaffronGL_LoadShaderCtx
+#endif
+#else
+#ifndef SAFFRON_GL_EXPECT_SHADER
+int SaffronGL_LoadShaderCtx(MR_Word gl_ctx, struct SaffronGL_ShaderCtx **ctx_ptr){
+    struct SaffronGL_ShaderCtx *ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_ShaderCtx));
+    MR_Word maybe_func, func;
+    MR_String err = NULL;
+    MR_Integer major, minor;
+    SaffronGL_Version(gl_ctx, &major, &minor);
+    if(major > 2 || (major == 2 && minor >= 0)) do{
+        SAFFRON_GL_SHADER_FUNCS(SAFFRON_GL_LOAD_FUNC_CORE)
+        *ctx_ptr = ctx;
+        return 0;
+    }while(0);
+    return 1;
+}
+#endif
+#endif
+#ifndef GL_SHADING_LANGUAGE_VERSION
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#endif
+#ifndef GL_VERTEX_SHADER
+#define GL_VERTEX_SHADER 0x8B31
+#endif
+#ifndef GL_FRAGMENT_SHADER
+#define GL_FRAGMENT_SHADER 0x8B30
+#endif
+#ifndef GL_GEOMETRY_SHADER
+#define GL_GEOMETRY_SHADER 0x8DD9
+#endif
+#ifndef GL_COMPILE_STATUS
+#define GL_COMPILE_STATUS 0x8B81
+#endif
+#ifndef GL_LINK_STATUS
+#define GL_LINK_STATUS 0x8B82
+#endif
+#ifndef GL_VALIDATE_STATUS
+#define GL_VALIDATE_STATUS 0x8B83
+#endif
+#ifndef GL_INFO_LOG_LENGTH
+#define GL_INFO_LOG_LENGTH 0x8B84
+#endif

--- a/saffron.gl.shader.m
+++ b/saffron.gl.shader.m
@@ -82,115 +82,13 @@
 
 % Define the native prototypes to handle shaders.
 :- pragma foreign_decl("C", "
+#include ""saffron.gl.shader.inc""
+").
 
-#define SAFFRON_GL_SHADER_FUNCS(X) \\
-    X(CreateShader) \\
-    X(DeleteShader) \\
-    X(ShaderSource) \\
-    X(CompileShader) \\
-    X(GetShaderiv) \\
-    X(GetShaderInfoLog) \\
-    X(CreateProgram) \\
-    X(DeleteProgram) \\
-    X(AttachShader) \\
-    X(LinkProgram) \\
-    X(UseProgram) \\
-    X(GetProgramiv)
-
-/* Shader function types */
-typedef GLuint(APIENTRY*SaffronGL_CreateShader_PROC)(GLenum);
-
-typedef void(APIENTRY*SaffronGL_DeleteShader_PROC)(GLuint);
-
-typedef void(APIENTRY*SaffronGL_ShaderSource_PROC)(
-    GLuint,
-    GLsizei,
-    const SaffronGLchar**,
-    const GLint*);
-
-typedef void(APIENTRY*SaffronGL_CompileShader_PROC)(GLuint);
-
-typedef void(APIENTRY*SaffronGL_GetShaderiv_PROC)(GLuint, GLenum, GLint*);
-
-typedef void(APIENTRY*SaffronGL_GetShaderInfoLog_PROC)(
-    GLuint,
-    GLsizei,
-    GLsizei*,
-    SaffronGLchar*);
-
-typedef GLuint(APIENTRY*SaffronGL_CreateProgram_PROC)(void);
-
-typedef void(APIENTRY*SaffronGL_DeleteProgram_PROC)(GLuint);
-
-typedef void(APIENTRY*SaffronGL_LinkProgram_PROC)(GLuint);
-
-typedef void(APIENTRY*SaffronGL_AttachShader_PROC)(GLuint, GLuint);
-
-typedef void(APIENTRY*SaffronGL_UseProgram_PROC)(GLuint);
-
-typedef void(APIENTRY*SaffronGL_GetProgramiv_PROC)(GLuint, GLenum, GLint*);
-
-#ifdef SAFFRON_GL_EXPECT_SHADERS
-
-/* TODO: Maybe we should be caching some info here? */
-# define SAFFRON_GL_SHADER_CTX MR_Word
-# define SAFFRON_GL_SHADER_FUNC(CTX, FN) gl ## FN
-
-#else
-
-# define SAFFRON_GL_SHADER_FUNC_VAR(X) \\
-    SaffronGL_ ## X ## _PROC X;
-
-struct SaffronGL_ShaderCtx{
-    SAFFRON_GL_SHADER_FUNCS(SAFFRON_GL_SHADER_FUNC_VAR)
-};
-
-# undef SAFFRON_GL_SHADER_FUNC_VAR
-
-# define SAFFRON_GL_SHADER_CTX struct SaffronGL_ShaderCtx*
-# define SAFFRON_GL_SHADER_FUNC(CTX, FN) ((CTX)->FN)
-
-#endif
-
-/* OpenGL constants for use with shaders */
-#ifndef GL_SHADING_LANGUAGE_VERSION
-# define GL_SHADING_LANGUAGE_VERSION 0x8B8C
-#endif
-
-#ifndef GL_VERTEX_SHADER
-# define GL_VERTEX_SHADER 0x8B31
-#endif
-
-#ifndef GL_FRAGMENT_SHADER
-# define GL_FRAGMENT_SHADER 0x8B30
-#endif
-
-#ifndef GL_GEOMETRY_SHADER
-# define GL_GEOMETRY_SHADER 0x8DD9
-#endif
-
-#ifndef GL_COMPILE_STATUS
-# define GL_COMPILE_STATUS 0x8B81
-#endif
-
-#ifndef GL_LINK_STATUS
-# define GL_LINK_STATUS 0x8B82
-#endif
-
-#ifndef GL_VALIDATE_STATUS
-# define GL_VALIDATE_STATUS 0x8B83
-#endif
-
-#ifndef GL_INFO_LOG_LENGTH
-# define GL_INFO_LOG_LENGTH 0x8B84
-#endif
-
-#ifdef MR_USE_SINGLE_PREC_FLOAT
-# define SAFFRON_GL_FLOAT_FUNC(NAME) NAME ## f
-#else
-# define SAFFRON_GL_FLOAT_FUNC(NAME) NAME ## d
-#endif
-
+:- pragma foreign_decl("C", "
+#define SAFFRON_GL_IMPL
+#include ""saffron.gl.shader.inc""
+#undef SAFFRON_GL_IMPL
 ").
 
 %-----------------------------------------------------------------------------%
@@ -244,38 +142,14 @@ create_shader_ctx_error(E) = maybe.error(E).
     create_shader_ctx_internal(Ctx::in, MaybeShaderCtx::out, IOi::di, IOo::uo),
     [may_call_mercury, promise_pure, thread_safe, will_not_throw_exception],
     "
-#ifndef SAFFRON_GL_EXPECT_SHADERS
-    MR_Word maybe_func, func;
-    MR_String err = NULL;
-    struct SaffronGL_ShaderCtx *shader_ctx;
-    shader_ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_ShaderCtx));
-    
-# define SAFFRON_GL_SHADER_FUNC_LOAD(X) { \\
-    SaffronGL_LoadFunction(Ctx, (char*)(""gl"" #X), &maybe_func); \\
-    err = NULL; \\
-    if(Saffron_GetCtxFunctionOK(maybe_func, &func)) \\
-         shader_ctx->X = (SaffronGL_ ## X ## _PROC)func; \\
-    else if(Saffron_GetCtxFunctionError(maybe_func, &err)) \\
-         goto create_shader_ctx_internal_error; \\
-    else \\
-        MR_assert(0); \\
-}
-    
-    SAFFRON_GL_SHADER_FUNCS(SAFFRON_GL_SHADER_FUNC_LOAD)
-
-# undef SAFFRON_GL_SHADER_FUNC_LOAD
-    
-create_shader_ctx_internal_error:
-    if(err == NULL){
-        MaybeShaderCtx = SaffronGL_CreateShaderCtxOK(shader_ctx);
+    SAFFRON_GL_SHADER_CTX ctx;
+    if(SAFFRON_GL_LOAD_SHADER_CTX(Ctx, &ctx) == 0){
+        MaybeShaderCtx = SaffronGL_CreateShaderCtxOK(ctx);
     }
     else{
-        MR_GC_free(shader_ctx);
-        MaybeShaderCtx = SaffronGL_CreateShaderCtxError(err);
+        MaybeShaderCtx = SaffronGL_CreateShaderCtxError(
+            (MR_String)""Could not create context"");
     }
-#else
-    MaybeShaderCtx = SaffronGL_CreateShaderCtxOK(0);
-#endif
     IOo = IOi;
     ").
 

--- /dev/null
+++ b/saffron.gl_gen.awk
@@ -0,0 +1,146 @@
+BEGIN{
+    print("\
+#ifndef SAFFRON_GL_FUNC_VAR\n\
+#define SAFFRON_GL_FUNC_VAR(X) SaffronGL_ ## X ## _PROC X;\n\
+#endif\n\
+#ifndef SAFFRON_GL_FUNC_LOAD\n\
+#define SAFFRON_GL_FUNC_LOAD(X, EXT) \\\n\
+    SaffronGL_LoadFunction(gl_ctx, (char*)(\"gl\" #X EXT), &maybe_func); \\\n\
+    if(!Saffron_GetCtxFunctionOK(maybe_func, &func)) break; \\\n\
+    (ctx->X) = (SaffronGL_ ## X ## _PROC)func; \n\
+\n\
+#define SAFFRON_GL_LOAD_FUNC_CORE(X) SAFFRON_GL_FUNC_LOAD(X, \"\")\n\
+#endif\n\
+");
+
+}
+
+$1 == "const" {
+    print("\
+#ifndef " $2 "\n\
+#define " $2 " " $3 "\n\
+#endif");
+    next;
+}
+
+$1 !~ /#/ && $0 != "" {
+    print("#ifndef SAFFRON_GL_IMPL");
+    upper2 = toupper($2);
+}
+
+$1 == "struct" || $1 == "load"{
+    struct = "struct SaffronGL_" $2 "Ctx";
+}
+
+$1 == "func" {
+    if($NF ~ /^=/){
+        last = NF - 1;
+        ret = substr($NF, 2);
+    }
+    else{
+        last = NF;
+        ret = "void";
+    }
+    sig = "typedef " ret "(APIENTRY*SaffronGL_" $2 "_PROC)(";
+    if(last < 3){
+        print(sig "void);");
+    }
+    else{
+        print(sig);
+        for(i = 3; i < last; i++)
+            print("    " $i ",");
+        print("    " $last ");");
+    }
+}
+
+$1 == "struct" {
+    print("#define SAFFRON_GL_" upper2 "_FUNCS(X) \\");
+    for(i = 3; i <= NF; i++){
+        print("    X(" $i ") \\");
+    }
+    print("/* */");
+    print(struct "{");
+    print("    SAFFRON_GL_" upper2 "_FUNCS(SAFFRON_GL_FUNC_VAR)");
+    print("};");
+}
+
+$1 == "load" {
+    # Check for "core" spec, and if we find it we should generate an 'expect'
+    # C preprocessor check to avoid unnecessary indirection.
+    core = 0;
+    for(i = 3; i <= NF; i++){
+        if($i ~ /^core [0-9]\.[0-9]$/){
+            core = i;
+            break;
+        }
+    }
+    if(core != 0){
+        print("\
+#ifdef SAFFRON_GL_EXPECT_" upper2 "\n\
+#define SAFFRON_GL_" upper2 "_FUNC(CTX, X) (gl ## X)\n\
+#define SAFFRON_GL_" upper2 "_CTX MR_Word\n\
+#define SAFFRON_GL_ALLOC_" upper2 "_CTX() 0\n\
+#define SAFFRON_GL_LOAD_" upper2 "_CTX(GLCTX, CTX) (*(CTX) = 0)\n\
+#else");
+    }
+    # Write the default, loader implementation.
+    sig = "int SaffronGL_Load" $2 "Ctx(MR_Word gl_ctx, " struct " **ctx_ptr)";
+    print("\
+#define SAFFRON_GL_" upper2 "_FUNC(CTX, X) ((CTX)->X)\n\
+#define SAFFRON_GL_" upper2 "_CTX " struct "\n\
+" sig ";\n\
+#define SAFFRON_GL_LOAD_" upper2 "_CTX SaffronGL_Load" $2 "Ctx");
+    if(core != ""){
+        print("#endif");
+    }
+    
+    # Write the impl (we are in an #ifdef for the interface)
+    print("#else");
+    print("#ifndef SAFFRON_GL_EXPECT_" upper2);
+
+    # Write the loader function
+    print(sig "{\n\
+    " struct " *ctx = MR_GC_malloc_atomic(sizeof(" struct "));\n\
+    MR_Word maybe_func, func;\n\
+    MR_String err = NULL;");
+    if(core != 0){
+        print("\
+    MR_Integer major, minor;\n\
+    SaffronGL_Version(gl_ctx, &major, &minor);");
+    }
+    for(i = 3; i <= NF; i++){
+        # Core has special handling.
+        if($i ~ /^core [0-9]\.[0-9]$/){
+            major = substr($i, 6, 1);
+            minor = substr($i, 8, 1);
+            print("\
+    if(major > " major " || (major == " major " && minor >= " minor ")) do{\n\
+        SAFFRON_GL_" upper2 "_FUNCS(SAFFRON_GL_LOAD_FUNC_CORE)\n\
+        *ctx_ptr = ctx;\n\
+        return 0;\n\
+    }while(0);");
+        }
+        else if($i ~ /^ext GL_[A-Za-z0-9_]+ [A-Za-z0-9_]+$/){
+            ext_i = match($i, / GL_/) + 1;
+            sfx_i = match($i, / [A-Za-z0-9_]+$/) + 1;
+            ext = substr($i, ext_i, sfx_i - ext_i - 1);
+            sfx = substr($i, sfx_i);
+            macro = "SAFFRON_GL_LOAD_FUNC_" upper2 "_" sfx;
+            print("\
+#define " macro "(X) SAFFRON_GL_FUNC_LOAD(X, \"" sfx "\")\n\
+    if(SaffronGL_SupportsExtension(\"" ext "\")) do{ \n\
+        SAFFRON_GL_" upper2 "_FUNCS(" macro ")\n\
+        *ctx_ptr = ctx;\n\
+        return 0;\n\
+    }while(0);");
+        }
+    }
+    print("    return 1;\n}");
+    print("#endif"); # SAFFRON_GL_EXPECT_
+}
+
+$1 !~ /#/ && $0 != "" {
+    print("#endif");
+}
+
+