コミット: b66b36f2487d0e3a19333992d0be262a9bdfee0e - Saffron (git)

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

コミットメタ情報

• リビジョン: b66b36f2487d0e3a19333992d0be262a9bdfee0e (tree)
• 日時: 2022-06-14 08:04:06
• 作者: AlaskanEmily <emily@alas...>
• コミッター: AlaskanEmily

ログメッセージ

Make supports_extension a generic function on any GL context that has a gl_load_func_ctx.

This prevents the circular dependency on needing a gl_ctx for the context to test, and needing to test for extensions to create the context.

変更サマリ

• modified: saffron.gl.buffer.inc
• modified: saffron.gl.buffer.m
• modified: saffron.gl.m
• modified: saffron.gl.shader.inc
• modified: saffron.gl.shader.m
• modified: saffron.gl2.m
• modified: saffron.gl_gen.awk

差分

--- a/saffron.gl.buffer.inc
+++ b/saffron.gl.buffer.inc
@@ -71,6 +71,7 @@ int SaffronGL_LoadBufferCtx(MR_Word gl_ctx, struct SaffronGL_BufferCtx **ctx_ptr
 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_Bool have_ext;
     MR_String err = NULL;
     MR_Integer major, minor;
     SaffronGL_Version(gl_ctx, &major, &minor);
@@ -80,7 +81,8 @@ int SaffronGL_LoadBufferCtx(MR_Word gl_ctx, struct SaffronGL_BufferCtx **ctx_ptr
         return 0;
     }while(0);
 #define SAFFRON_GL_LOAD_FUNC_BUFFER_ARB(X) SAFFRON_GL_FUNC_LOAD(X, "ARB")
-    if(SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_vertex_buffer_object")){
+    SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_vertex_buffer_object", &have_ext);
+    if(have_ext){
         do{
             SAFFRON_GL_BUFFER_FUNCS(SAFFRON_GL_LOAD_FUNC_BUFFER_ARB)
             *ctx_ptr = ctx;

--- a/saffron.gl.buffer.m
+++ b/saffron.gl.buffer.m
@@ -41,8 +41,7 @@
 %-----------------------------------------------------------------------------%
 
 :- pred create_buffer_ctx(Ctx, maybe.maybe_error(buffer_ctx), io.io, io.io)
-    <= (saffron.gl.context(Ctx),
-        saffron.gl.supports_extensions(Ctx)).
+    <= saffron.gl.context(Ctx).
 :- mode create_buffer_ctx(in, out, di, uo) is det.
 
 %-----------------------------------------------------------------------------%

--- a/saffron.gl.m
+++ b/saffron.gl.m
@@ -61,9 +61,9 @@
 
 %-----------------------------------------------------------------------------%
 
-:- typeclass supports_extensions(Ctx) where [
-    pred supports_extension(Ctx::in, string::in) is semidet
-].
+:- pred supports_extension(Ctx, string, bool.bool, io.io, io.io)
+    <= saffron.gl.context(Ctx).
+:- mode supports_extension(in, in, uo, di, uo) is det.
 
 %-----------------------------------------------------------------------------%
 
@@ -153,6 +153,7 @@ typedef char SaffronGLchar;
 #else
 
 # if (defined __linux__) || (defined __OpenBSD__) || (defined __FreeBSD__)
+#   define SAFFRON_GL_EXPECT_GL3
 #   define SAFFRON_GL_EXPECT_BUFFER
 #   define SAFFRON_GL_EXPECT_SHADER
 #   define GL_GLEXT_PROTOTYPES
@@ -208,7 +209,6 @@ typedef void(APIENTRY*SaffronGL_DrawTextureNV_PROC)(
 # define SAFFRON_GL_RAW_INTS
 #endif
 
-
 ").
 
 %-----------------------------------------------------------------------------%
@@ -242,6 +242,39 @@ primitive_type(saffron.geometry.triangle_fan, saffron.gl.triangle_fan).
 
 %-----------------------------------------------------------------------------%
 
+:- pred supports_extension_inner(string, bool.bool, io.io, io.io).
+:- mode supports_extension_inner(in, uo, di, uo) is det.
+
+supports_extension_inner(_, bool.no, !IO).
+:- pragma foreign_proc("C",
+    supports_extension_inner(Ext::in, Supports::uo, IOi::di, IOo::uo),
+    [will_not_call_mercury, promise_pure, thread_safe, will_not_throw_exception,
+    may_duplicate, does_not_affect_liveness],
+    "
+    const MR_Integer len = strnlen(Ext, 512);
+    const char *str = (void*)glGetString(GL_EXTENSIONS);
+    Supports = MR_NO;
+    IOo = IOi;
+    if(str != NULL){
+        do{
+            if(strncmp(str, Ext, len) != 0 &&
+                (str[len] == ' ' || str[len] == 0)){
+                
+                Supports = MR_YES;
+                break;
+            }
+        }while((str = strchr(str, ' ')) != NULL && *(++str) != 0);
+    }
+    ").
+
+%-----------------------------------------------------------------------------%
+
+supports_extension(Ctx, Ext, Supports, !IO) :-
+    saffron.make_current(Ctx, !IO),
+    supports_extension_inner(Ext, Supports, !IO).
+
+%-----------------------------------------------------------------------------%
+
 float_bytes = 8.
 
 :- pragma foreign_proc("C", float_bytes = (N::out),
@@ -378,8 +411,7 @@ texture_upload_at(_Ctx, Tex, B, X, Y, W, H, !IO) :-
 :- type gl_load_func_ctx --->
     some [Ctx] (gl_load_func_ctx(Ctx)
         => (saffron.context(Ctx),
-            saffron.gl.context(Ctx),
-            saffron.gl.supports_extensions(Ctx))).
+            saffron.gl.context(Ctx))).
 
 %-----------------------------------------------------------------------------%
 % A non-higher-typed version of load_function that takes gl_load_func_ctx.
@@ -434,13 +466,22 @@ gl_version(gl_load_func_ctx(Ctx), Major, Minor, !IO) :-
     gl_version(in, out, out, di, uo),
     "SaffronGL_Version").
 
-:- pred gl_supports_extension(gl_load_func_ctx::in, string::in) is semidet.
+:- pred gl_supports_extension(
+    gl_load_func_ctx,
+    string,
+    bool.bool,
+    io.io, io.io).
+:- mode gl_supports_extension(
+    in,
+    in,
+    uo,
+    di, uo) is det.
 
-gl_supports_extension(gl_load_func_ctx(Ctx), Ext) :-
-    saffron.gl.supports_extension(Ctx, Ext).
+gl_supports_extension(gl_load_func_ctx(Ctx), Ext, Supports, !IO) :-
+    supports_extension(Ctx, Ext, Supports, !IO).
 
 :- pragma foreign_export("C",
-    gl_supports_extension(in, in),
+    gl_supports_extension(in, in, uo, di, uo),
     "SaffronGL_SupportsExtension").
 
 %-----------------------------------------------------------------------------%

--- a/saffron.gl.shader.inc
+++ b/saffron.gl.shader.inc
@@ -210,6 +210,7 @@ int SaffronGL_LoadShaderCoreCtx(MR_Word gl_ctx, struct SaffronGL_ShaderCoreCtx *
 int SaffronGL_LoadShaderCoreCtx(MR_Word gl_ctx, struct SaffronGL_ShaderCoreCtx **ctx_ptr){
     struct SaffronGL_ShaderCoreCtx *ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_ShaderCoreCtx));
     MR_Word maybe_func, func;
+    MR_Bool have_ext;
     MR_String err = NULL;
     MR_Integer major, minor;
     SaffronGL_Version(gl_ctx, &major, &minor);
@@ -310,9 +311,11 @@ int SaffronGL_LoadShaderFP64Ctx(MR_Word gl_ctx, struct SaffronGL_ShaderFP64Ctx *
 int SaffronGL_LoadShaderFP64Ctx(MR_Word gl_ctx, struct SaffronGL_ShaderFP64Ctx **ctx_ptr){
     struct SaffronGL_ShaderFP64Ctx *ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_ShaderFP64Ctx));
     MR_Word maybe_func, func;
+    MR_Bool have_ext;
     MR_String err = NULL;
 #define SAFFRON_GL_LOAD_FUNC_SHADERFP64_ARB(X) SAFFRON_GL_FUNC_LOAD(X, "ARB")
-    if(SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_gpu_shader_fp64")){
+    SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_gpu_shader_fp64", &have_ext);
+    if(have_ext){
         do{
             SAFFRON_GL_SHADERFP64_FUNCS(SAFFRON_GL_LOAD_FUNC_SHADERFP64_ARB)
             *ctx_ptr = ctx;
@@ -370,6 +373,7 @@ int SaffronGL_LoadProgramBinaryCtx(MR_Word gl_ctx, struct SaffronGL_ProgramBinar
 int SaffronGL_LoadProgramBinaryCtx(MR_Word gl_ctx, struct SaffronGL_ProgramBinaryCtx **ctx_ptr){
     struct SaffronGL_ProgramBinaryCtx *ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_ProgramBinaryCtx));
     MR_Word maybe_func, func;
+    MR_Bool have_ext;
     MR_String err = NULL;
     MR_Integer major, minor;
     SaffronGL_Version(gl_ctx, &major, &minor);
@@ -379,7 +383,8 @@ int SaffronGL_LoadProgramBinaryCtx(MR_Word gl_ctx, struct SaffronGL_ProgramBinar
         return 0;
     }while(0);
 #define SAFFRON_GL_LOAD_FUNC_PROGRAMBINARY_ARB(X) SAFFRON_GL_FUNC_LOAD(X, "ARB")
-    if(SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_get_program_binary")){
+    SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_get_program_binary", &have_ext);
+    if(have_ext){
         do{
             SAFFRON_GL_PROGRAMBINARY_FUNCS(SAFFRON_GL_LOAD_FUNC_PROGRAMBINARY_ARB)
             *ctx_ptr = ctx;
@@ -415,9 +420,11 @@ int SaffronGL_LoadSPIRVCtx(MR_Word gl_ctx, struct SaffronGL_SPIRVCtx **ctx_ptr);
 int SaffronGL_LoadSPIRVCtx(MR_Word gl_ctx, struct SaffronGL_SPIRVCtx **ctx_ptr){
     struct SaffronGL_SPIRVCtx *ctx = MR_GC_malloc_atomic(sizeof(struct SaffronGL_SPIRVCtx));
     MR_Word maybe_func, func;
+    MR_Bool have_ext;
     MR_String err = NULL;
 #define SAFFRON_GL_LOAD_FUNC_SPIRV_ARB(X) SAFFRON_GL_FUNC_LOAD(X, "ARB")
-    if(SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_gl_spirv")){
+    SaffronGL_SupportsExtension(gl_ctx, (MR_String)"GL_ARB_gl_spirv", &have_ext);
+    if(have_ext){
         do{
             SAFFRON_GL_SPIRV_FUNCS(SAFFRON_GL_LOAD_FUNC_SPIRV_ARB)
             *ctx_ptr = ctx;

--- a/saffron.gl.shader.m
+++ b/saffron.gl.shader.m
@@ -27,8 +27,7 @@
 %-----------------------------------------------------------------------------%
 
 :- pred create_shader_ctx(Ctx, maybe.maybe_error(shader_ctx), io.io, io.io)
-    <= (saffron.gl.context(Ctx),
-        saffron.gl.supports_extensions(Ctx)).
+    <= saffron.gl.context(Ctx).
 :- mode create_shader_ctx(in, out, di, uo) is det.
 
 %-----------------------------------------------------------------------------%

--- a/saffron.gl2.m
+++ b/saffron.gl2.m
@@ -35,11 +35,6 @@
 
 %-----------------------------------------------------------------------------%
 
-:- instance saffron.gl.supports_extensions(context(Ctx))
-    <= saffron.gl.context(Ctx).
-
-%-----------------------------------------------------------------------------%
-
 :- instance saffron.draw.basic_transform(context(Ctx))
     <= saffron.gl.context(Ctx).
 
@@ -253,36 +248,6 @@ const char *Saffron_GL2_DebugError(void){
 
 %-----------------------------------------------------------------------------%
 
-:- pred supports_extension(_::in, string::in) is semidet.
-
-supports_extension(_, _) :- false.
-
-:- pragma foreign_proc("C", supports_extension(Ctx::in, Ext::in),
-    [will_not_call_mercury, promise_pure, thread_safe, will_not_throw_exception,
-    tabled_for_io, may_duplicate, does_not_affect_liveness],
-    "
-    const char *str = (void*)glGetString(GL_EXTENSIONS);
-    const MR_Integer len = strlen(Ext);
-    (void)Ctx;
-    SUCCESS_INDICATOR = 0;
-    while((str = strstr(str, Ext)) != NULL){
-        if(str[len] == ' ' || str[len] == 0){
-            SUCCESS_INDICATOR = 1;
-            break;
-        }
-    }
-    ").
-
-%-----------------------------------------------------------------------------%
-
-:- instance saffron.gl.supports_extensions(context(Ctx))
-    <= saffron.gl.context(Ctx) where [
-    
-    pred(saffron.gl.supports_extension/2) is saffron.gl2.supports_extension
-].
-
-%-----------------------------------------------------------------------------%
-
 :- pragma foreign_export("C",
     saffron.draw.raise_matrix_stack_error,
     "Saffron_GL2_RaiseMatrixStackError").
@@ -859,8 +824,6 @@ init(Ctx,
     !IO) :-
     
     saffron.make_current(Ctx, !IO),
-    % Get the supports_extension implementation for GL 2 contexts.
-    TempCtx = context(Ctx, maybe.no, maybe.no),
     saffron.gl.shader_model_version(Ctx, MaybeGLSLVersion, !IO),
     % TODO: Should this live inside create_shader_ctx?
     ( if
@@ -868,12 +831,12 @@ init(Ctx,
         saffron.sem_ver_compare(GLSLCmp, GLSLVersion, saffron.sem_ver(1, 20)),
         GLSLCmp \= (<)
     then
-        saffron.gl.shader.create_shader_ctx(TempCtx, MaybeErrShaderCtx, !IO),
+        saffron.gl.shader.create_shader_ctx(Ctx, MaybeErrShaderCtx, !IO),
         MaybeShaderCtx = complete_load_ctx("shader", MaybeErrShaderCtx)
     else
         MaybeShaderCtx = maybe.no
     ),
-    saffron.gl.buffer.create_buffer_ctx(TempCtx, MaybeErrBufferCtx, !IO),
+    saffron.gl.buffer.create_buffer_ctx(Ctx, MaybeErrBufferCtx, !IO),
     MaybeBufferCtx = complete_load_ctx("buffer", MaybeErrBufferCtx),
     init(!IO).
 

--- a/saffron.gl_gen.awk
+++ b/saffron.gl_gen.awk
@@ -104,6 +104,7 @@ $1 == "load" {
     print(sig "{\n\
     " struct " *ctx = MR_GC_malloc_atomic(sizeof(" struct "));\n\
     MR_Word maybe_func, func;\n\
+    MR_Bool have_ext;\n\
     MR_String err = NULL;");
     if(core != 0){
         print("\
@@ -130,7 +131,8 @@ $1 == "load" {
             macro = "SAFFRON_GL_LOAD_FUNC_" upper2 "_" sfx;
             print("\
 #define " macro "(X) SAFFRON_GL_FUNC_LOAD(X, \"" sfx "\")\n\
-    if(SaffronGL_SupportsExtension(gl_ctx, (MR_String)\"" ext "\")){\n\
+    SaffronGL_SupportsExtension(gl_ctx, (MR_String)\"" ext "\", &have_ext);\n\
+    if(have_ext){\n\
         do{\n\
             SAFFRON_GL_" upper2 "_FUNCS(" macro ")\n\
             *ctx_ptr = ctx;\n\