]> git.cworth.org Git - glenv/blob - glwrap.c
9c9f3093b304078438d2e212a5c52d84473513e9
[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 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 }