visualtest/src/variator_common.c
author Sam Lantinga
Tue, 10 Jan 2017 08:54:33 -0800
changeset 10806 36f40b8cc979
parent 7924 fcb86d323770
permissions -rw-r--r--
Fixed bugs 2570, 3145, improved OpenGL ES context support on Windows and X11

Mark Callow

The attached patch does the following for the X11 and Windows platforms, the only ones where SDL attempts to use context_create_es_profile:

- Adds SDL_HINT_OPENGL_ES_DRIVER by which the application can
say to use the OpenGL ES driver & EGL rather than the Open GL
driver. (For bug #2570)
- Adds code to {WIN,X11}_GL_InitExtensions to determine the maximum
OpenGL ES version supported by the OpenGL driver (for bug #3145)
- Modifies the test that determines whether to use the OpenGL
driver or the real OpenGL ES driver to take into account the
hint, the requested and supported ES version and whether ES 1.X
is being requested. (For bug #2570 & bug #3145)
- Enables the testgles2 test for __WINDOWS__ and __LINUX__ and adds
the test to the VisualC projects.

With the fix in place I have run testdraw2, testgl and testgles2 without any issues and have run my own apps that use OpenGL, OpenGL ES 3 and OpenGL ES 1.1.
     1 /* See COPYING.txt for the full license governing this code. */
     2 /**
     3  * \file variator_common.c
     4  *
     5  * Source file for some common functionality used by variators.
     6  */
     7 
     8 #include <SDL_test.h>
     9 #include "SDL_visualtest_variator_common.h"
    10 
    11 int
    12 SDLVisualTest_NextValue(SDLVisualTest_SUTOptionValue* var,
    13                         SDLVisualTest_SUTOption* opt)
    14 {
    15     if(!var)
    16     {
    17         SDLTest_LogError("var argument cannot be NULL");
    18         return -1;
    19     }
    20     if(!opt)
    21     {
    22         SDLTest_LogError("opt argument cannot be NULL");
    23         return -1;
    24     }
    25 
    26     switch(opt->type)
    27     {
    28         case SDL_SUT_OPTIONTYPE_BOOL:
    29             if(var->bool_value)
    30             {
    31                 var->bool_value = SDL_FALSE;
    32                 return 1;
    33             }
    34             else
    35             {
    36                 var->bool_value = SDL_TRUE;
    37                 return 0;
    38             }
    39         break;
    40 
    41         case SDL_SUT_OPTIONTYPE_ENUM:
    42             var->enumerated.index++;
    43             if(!opt->data.enum_values[var->enumerated.index])
    44             {
    45                 var->enumerated.index = 0;
    46                 return 1;
    47             }
    48             return 0;
    49         break;
    50 
    51         case SDL_SUT_OPTIONTYPE_INT:
    52         {
    53             int increment = (opt->data.range.max - opt->data.range.min) /
    54                             SDL_SUT_INTEGER_OPTION_TEST_STEPS;
    55             /* prevents infinite loop when rounding */
    56             if(increment == 0)
    57                 increment = 1;
    58             var->integer.value += increment;
    59             if(var->integer.value > opt->data.range.max)
    60             {
    61                 var->integer.value = opt->data.range.min;
    62                 return 1;
    63             }
    64             return 0;
    65         }
    66         break;
    67 
    68         case SDL_SUT_OPTIONTYPE_STRING:
    69             return 1;
    70         break;
    71     }
    72     return -1;
    73 }
    74 
    75 int
    76 SDLVisualTest_MakeStrFromVariation(SDLVisualTest_Variation* variation,
    77                                    SDLVisualTest_SUTConfig* config,
    78                                    char* buffer, int size)
    79 {
    80     int i, index;
    81     SDLVisualTest_SUTOptionValue* vars;
    82     SDLVisualTest_SUTOption* options;
    83     if(!variation)
    84     {
    85         SDLTest_LogError("variation argument cannot be NULL");
    86         return 0;
    87     }
    88     if(!config)
    89     {
    90         SDLTest_LogError("config argument cannot be NULL");
    91         return 0;
    92     }
    93     if(!buffer)
    94     {
    95         SDLTest_LogError("buffer argument cannot be NULL");
    96         return 0;
    97     }
    98     if(size <= 0)
    99     {
   100         SDLTest_LogError("size argument should be positive");
   101         return 0;
   102     }
   103 
   104     index = 0;
   105     buffer[0] = '\0';
   106     options = config->options;
   107     vars = variation->vars;
   108     for(i = 0; i < variation->num_vars; i++)
   109     {
   110         int n, enum_index;
   111         if(index >= size - 1)
   112         {
   113             SDLTest_LogError("String did not fit in buffer size");
   114             return 0;
   115         }
   116         switch(options[i].type)
   117         {
   118             case SDL_SUT_OPTIONTYPE_BOOL:
   119                 if(vars[i].bool_value)
   120                 {
   121                     n = SDL_snprintf(buffer + index, size - index, "%s ",
   122                                      options[i].name);
   123                     if(n <= 0)
   124                     {
   125                         SDLTest_LogError("SDL_snprintf() failed");
   126                         return 0;
   127                     }
   128                     index += n;
   129                 }
   130             break;
   131 
   132             case SDL_SUT_OPTIONTYPE_ENUM:
   133                 if(vars[i].enumerated.on)
   134                 {
   135                     enum_index = vars[i].enumerated.index;
   136                     n = SDL_snprintf(buffer + index, size - index, "%s %s ",
   137                         options[i].name, options[i].data.enum_values[enum_index]);
   138                     index += n;
   139                 }
   140             break;
   141 
   142             case SDL_SUT_OPTIONTYPE_INT:
   143                 if(vars[i].integer.on)
   144                 {
   145                     n = SDL_snprintf(buffer + index, size - index, "%s %d ",
   146                                      options[i].name, vars[i].integer.value);
   147                     index += n;
   148                 }
   149             break;
   150 
   151             case SDL_SUT_OPTIONTYPE_STRING:
   152                 if(vars[i].string.on)
   153                 {
   154                     n = SDL_snprintf(buffer + index, size - index, "%s %s ",
   155                                      options[i].name, vars[i].string.value);
   156                     index += n;
   157                 }
   158             break;
   159         }
   160     }
   161     return 1;
   162 }
   163 
   164 int
   165 SDLVisualTest_InitVariation(SDLVisualTest_Variation* variation,
   166                             SDLVisualTest_SUTConfig* config)
   167 {
   168     int i;
   169     SDLVisualTest_SUTOptionValue* vars;
   170     SDLVisualTest_SUTOption* options;
   171     if(!variation)
   172     {
   173         SDLTest_LogError("variation argument cannot be NULL");
   174         return 0;
   175     }
   176     if(!config)
   177     {
   178         SDLTest_LogError("config argument cannot be NULL");
   179         return 0;
   180     }
   181 
   182     /* initialize the first variation */
   183     if(config->num_options <= 0)
   184     {
   185         SDLTest_LogError("config->num_options must be positive");
   186         return 0;
   187     }
   188     variation->vars = (SDLVisualTest_SUTOptionValue*)SDL_malloc(config->num_options *
   189                      sizeof(SDLVisualTest_SUTOptionValue));
   190     if(!variation->vars)
   191     {
   192         SDLTest_LogError("malloc() failed");
   193         return 0;
   194     }
   195     variation->num_vars = config->num_options;
   196     vars = variation->vars;
   197     options = config->options;
   198     for(i = 0; i < variation->num_vars; i++)
   199     {
   200         switch(options[i].type)
   201         {
   202             case SDL_SUT_OPTIONTYPE_BOOL:
   203                 vars[i].bool_value = SDL_FALSE;
   204             break;
   205 
   206             case SDL_SUT_OPTIONTYPE_ENUM:
   207                 vars[i].enumerated.on = SDL_TRUE;
   208                 vars[i].enumerated.index = 0;
   209             break;
   210 
   211             case SDL_SUT_OPTIONTYPE_INT:
   212             {
   213                 vars[i].integer.on = SDL_TRUE;
   214                 vars[i].integer.value = options[i].data.range.min;
   215             }
   216             break;
   217 
   218             case SDL_SUT_OPTIONTYPE_STRING:
   219                 vars[i].string.on = SDL_TRUE;
   220                 vars[i].string.value = options[i].name;
   221             break;
   222         }
   223     }
   224     return 1;
   225 }