]> git.cworth.org Git - glenv/blob - glwrap.c
faf6a81ef3285ec0814e34d99e87bebdc2a6b854
[glenv] / 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 static int
32 glenv_num_extensions (void)
33 {
34         /* FIXME */
35         return 0;
36 }
37
38 static int
39 glenv_major_version (void)
40 {
41         const char *version = getenv ("GLENV_GL_VERSION");
42         if (version == NULL)
43                 return 0;
44
45         return atoi (version);
46 }
47
48 static int
49 glenv_minor_version (void)
50 {
51         const char *version = getenv ("GLENV_GL_VERSION");
52         const char *decimal;
53
54         if (version == NULL)
55                 return 0;
56
57         decimal = strchr (version, '.');
58
59         if (decimal == NULL)
60                 return 0;
61
62         return atoi (decimal + 1);
63 }
64
65 void
66 glGetDoublev (GLenum pname, GLdouble *params)
67 {
68         switch (pname) {
69         case GL_NUM_EXTENSIONS:
70                 *params = glenv_num_extensions();
71                 break;
72         case GL_MAJOR_VERSION:
73                 if (getenv ("GLENV_GL_VERSION")) {
74                         *params = glenv_major_version();
75                         return;
76                 }
77                 break;
78         case GL_MINOR_VERSION:
79                 if (getenv ("GLENV_GL_VERSION")) {
80                         *params = glenv_minor_version();
81                         return;
82                 }
83                 break;
84         }
85
86         GLAZE_DEFER (glGetDoublev, pname, params);
87 }
88
89 void
90 glGetFloatv (GLenum pname, GLfloat *params)
91 {
92         switch (pname) {
93         case GL_NUM_EXTENSIONS:
94                 *params = glenv_num_extensions();
95                 break;
96         case GL_MAJOR_VERSION:
97                 if (getenv ("GLENV_GL_VERSION")) {
98                         *params = glenv_major_version();
99                         return;
100                 }
101                 break;
102         case GL_MINOR_VERSION:
103                 if (getenv ("GLENV_GL_VERSION")) {
104                         *params = glenv_minor_version();
105                         return;
106                 }
107                 break;
108         }
109
110         GLAZE_DEFER (glGetFloatv, pname, params);
111 }
112
113 void
114 glGetIntegerv (GLenum pname, GLint *params)
115 {
116         switch (pname) {
117         case GL_NUM_EXTENSIONS:
118                 *params = glenv_num_extensions();
119                 break;
120         case GL_MAJOR_VERSION:
121                 if (getenv ("GLENV_GL_VERSION")) {
122                         *params = glenv_major_version();
123                         return;
124                 }
125                 break;
126         case GL_MINOR_VERSION:
127                 if (getenv ("GLENV_GL_VERSION")) {
128                         *params = glenv_minor_version();
129                         return;
130                 }
131                 break;
132         }
133
134         GLAZE_DEFER (glGetIntegerv, pname, params);
135 }
136
137 void
138 glGetInteger64v (GLenum pname, GLint64 * params)
139 {
140         switch (pname) {
141         case GL_NUM_EXTENSIONS:
142                 *params = glenv_num_extensions();
143                 break;
144         case GL_MAJOR_VERSION:
145                 if (getenv ("GLENV_GL_VERSION")) {
146                         *params = glenv_major_version();
147                         return;
148                 }
149                 break;
150         case GL_MINOR_VERSION:
151                 if (getenv ("GLENV_GL_VERSION")) {
152                         *params = glenv_minor_version();
153                         return;
154                 }
155                 break;
156         }
157
158         GLAZE_DEFER (glGetInteger64v, pname, params);
159 }
160
161 const GLubyte *
162 glGetString (GLenum name)
163 {
164         const GLubyte *ret;
165
166         switch (name) {
167         case GL_VENDOR:
168                 ret = (GLubyte *) getenv ("GLENV_GL_VENDOR");
169                 if (ret)
170                         return ret;
171                 break;
172         case GL_RENDERER:
173                 ret = (GLubyte *) getenv ("GLENV_GL_RENDERER");
174                 if (ret)
175                         return ret;
176                 break;
177         case GL_VERSION:
178                 ret = (GLubyte *) getenv ("GLENV_GL_VERSION");
179                 if (ret)
180                         return ret;
181                 break;
182         case GL_SHADING_LANGUAGE_VERSION:
183                 ret = (GLubyte *) getenv ("GLENV_GL_SHADING_LANGUAGE_VERSION");
184                 if (ret)
185                         return ret;
186                 break;
187         case GL_EXTENSIONS:
188                 ret = (GLubyte *) getenv ("GLENV_GL_EXTENSIONS");
189                 if (ret)
190                         return ret;
191                 break;
192         }
193
194         GLAZE_DEFER_WITH_RETURN (ret, glGetString, name);
195
196         return ret;
197 }
198
199 const GLubyte *
200 glGetStringi (GLenum name, GLuint index)
201 {
202         const GLubyte *ret;
203
204         switch (name) {
205         case GL_EXTENSIONS:
206                 /* FIXME */
207                 break;
208         case GL_SHADING_LANGUAGE_VERSION:
209                 if (index == 0) {
210                         ret = (GLubyte *) getenv ("GLENV_GL_SHADING_LANGUAGE_VERSION");
211                         if (ret)
212                                 return ret;
213                 }
214                 break;
215         }
216
217         GLAZE_DEFER_WITH_RETURN (ret, glGetStringi, name, index);
218
219         return ret;
220 }