git.cworth.org Git - glenv/blob - glwrap.c

   1 /* Copyright © 2013, Intel Corporation
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 #define GL_GLEXT_PROTOTYPES
  23 #include <GL/gl.h>
  24
  25 #include <glaze.h>
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 void glenv_query (void);
  32
  33 typedef GLubyte * (get_string_type_t) (GLenum);
  34
  35 void
  36 glenv_query (void)
  37 {
  38         printf ("--vendor=\"%s\"\n", glGetString (GL_VENDOR));
  39         printf ("--renderer=\"%s\"\n", glGetString (GL_RENDERER));
  40         printf ("--version=\"%s\"\n", glGetString (GL_VERSION));
  41         printf ("--shading-language-version=\"%s\"\n", glGetString (GL_SHADING_LANGUAGE_VERSION));
  42         printf ("--extensions=\"%s\"\n", glGetString (GL_EXTENSIONS));
  43
  44         exit (0);
  45 }
  46
  47 static int
  48 glenv_num_extensions (void)
  49 {
  50         /* FIXME */
  51         return 0;
  52 }
  53
  54 static int
  55 glenv_major_version (void)
  56 {
  57         const char *version = getenv ("GLENV_GL_VERSION");
  58         if (version == NULL)
  59                 return 0;
  60
  61         return atoi (version);
  62 }
  63
  64 static int
  65 glenv_minor_version (void)
  66 {
  67         const char *version = getenv ("GLENV_GL_VERSION");
  68         const char *decimal;
  69
  70         if (version == NULL)
  71                 return 0;
  72
  73         decimal = strchr (version, '.');
  74
  75         if (decimal == NULL)
  76                 return 0;
  77
  78         return atoi (decimal + 1);
  79 }
  80
  81 void
  82 glGetDoublev (GLenum pname, GLdouble *params)
  83 {
  84         switch (pname) {
  85         case GL_NUM_EXTENSIONS:
  86                 *params = glenv_num_extensions();
  87                 break;
  88         case GL_MAJOR_VERSION:
  89                 if (getenv ("GLENV_GL_VERSION")) {
  90                         *params = glenv_major_version();
  91                         return;
  92                 }
  93                 break;
  94         case GL_MINOR_VERSION:
  95                 if (getenv ("GLENV_GL_VERSION")) {
  96                         *params = glenv_minor_version();
  97                         return;
  98                 }
  99                 break;
 100         }
 101
 102         GLAZE_DEFER (glGetDoublev, pname, params);
 103 }
 104
 105 void
 106 glGetFloatv (GLenum pname, GLfloat *params)
 107 {
 108         switch (pname) {
 109         case GL_NUM_EXTENSIONS:
 110                 *params = glenv_num_extensions();
 111                 break;
 112         case GL_MAJOR_VERSION:
 113                 if (getenv ("GLENV_GL_VERSION")) {
 114                         *params = glenv_major_version();
 115                         return;
 116                 }
 117                 break;
 118         case GL_MINOR_VERSION:
 119                 if (getenv ("GLENV_GL_VERSION")) {
 120                         *params = glenv_minor_version();
 121                         return;
 122                 }
 123                 break;
 124         }
 125
 126         GLAZE_DEFER (glGetFloatv, pname, params);
 127 }
 128
 129 void
 130 glGetIntegerv (GLenum pname, GLint *params)
 131 {
 132         switch (pname) {
 133         case GL_NUM_EXTENSIONS:
 134                 *params = glenv_num_extensions();
 135                 break;
 136         case GL_MAJOR_VERSION:
 137                 if (getenv ("GLENV_GL_VERSION")) {
 138                         *params = glenv_major_version();
 139                         return;
 140                 }
 141                 break;
 142         case GL_MINOR_VERSION:
 143                 if (getenv ("GLENV_GL_VERSION")) {
 144                         *params = glenv_minor_version();
 145                         return;
 146                 }
 147                 break;
 148         }
 149
 150         GLAZE_DEFER (glGetIntegerv, pname, params);
 151 }
 152
 153 void
 154 glGetInteger64v (GLenum pname, GLint64 * params)
 155 {
 156         switch (pname) {
 157         case GL_NUM_EXTENSIONS:
 158                 *params = glenv_num_extensions();
 159                 break;
 160         case GL_MAJOR_VERSION:
 161                 if (getenv ("GLENV_GL_VERSION")) {
 162                         *params = glenv_major_version();
 163                         return;
 164                 }
 165                 break;
 166         case GL_MINOR_VERSION:
 167                 if (getenv ("GLENV_GL_VERSION")) {
 168                         *params = glenv_minor_version();
 169                         return;
 170                 }
 171                 break;
 172         }
 173
 174         GLAZE_DEFER (glGetInteger64v, pname, params);
 175 }
 176
 177 const GLubyte *
 178 glGetString (GLenum name)
 179 {
 180         const GLubyte *ret;
 181
 182         switch (name) {
 183         case GL_VENDOR:
 184                 ret = (GLubyte *) getenv ("GLENV_GL_VENDOR");
 185                 if (ret)
 186                         return ret;
 187                 break;
 188         case GL_RENDERER:
 189                 ret = (GLubyte *) getenv ("GLENV_GL_RENDERER");
 190                 if (ret)
 191                         return ret;
 192                 break;
 193         case GL_VERSION:
 194                 ret = (GLubyte *) getenv ("GLENV_GL_VERSION");
 195                 if (ret)
 196                         return ret;
 197                 break;
 198         case GL_SHADING_LANGUAGE_VERSION:
 199                 ret = (GLubyte *) getenv ("GLENV_GL_SHADING_LANGUAGE_VERSION");
 200                 if (ret)
 201                         return ret;
 202                 break;
 203         case GL_EXTENSIONS:
 204                 ret = (GLubyte *) getenv ("GLENV_GL_EXTENSIONS");
 205                 if (ret)
 206                         return ret;
 207                 break;
 208         }
 209
 210         GLAZE_DEFER_WITH_RETURN (ret, glGetString, name);
 211
 212         return ret;
 213 }
 214
 215 const GLubyte *
 216 glGetStringi (GLenum name, GLuint index)
 217 {
 218         const GLubyte *ret;
 219
 220         switch (name) {
 221         case GL_EXTENSIONS:
 222                 /* FIXME */
 223                 break;
 224         case GL_SHADING_LANGUAGE_VERSION:
 225                 if (index == 0) {
 226                         ret = (GLubyte *) getenv ("GLENV_GL_SHADING_LANGUAGE_VERSION");
 227                         if (ret)
 228                                 return ret;
 229                 }
 230                 break;
 231         }
 232
 233         GLAZE_DEFER_WITH_RETURN (ret, glGetStringi, name, index);
 234
 235         return ret;
 236 }