1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 #include <stdbool.h>
27 #include "glheader.h"
28 #include "context.h"
29 #include "debug_output.h"
30 #include "get.h"
31 #include "enums.h"
32 #include "extensions.h"
33 #include "mtypes.h"
34 #include "macros.h"
35 #include "version.h"
36 #include "spirv_extensions.h"
37
38 /**
39 * Return the string for a glGetString(GL_SHADING_LANGUAGE_VERSION) query.
40 */
41 static const GLubyte *
shading_language_version(struct gl_context * ctx)42 shading_language_version(struct gl_context *ctx)
43 {
44 switch (ctx->API) {
45 case API_OPENGL_COMPAT:
46 case API_OPENGL_CORE:
47 switch (ctx->Const.GLSLVersion) {
48 case 120:
49 return (const GLubyte *) "1.20";
50 case 130:
51 return (const GLubyte *) "1.30";
52 case 140:
53 return (const GLubyte *) "1.40";
54 case 150:
55 return (const GLubyte *) "1.50";
56 case 330:
57 return (const GLubyte *) "3.30";
58 case 400:
59 return (const GLubyte *) "4.00";
60 case 410:
61 return (const GLubyte *) "4.10";
62 case 420:
63 return (const GLubyte *) "4.20";
64 case 430:
65 return (const GLubyte *) "4.30";
66 case 440:
67 return (const GLubyte *) "4.40";
68 case 450:
69 return (const GLubyte *) "4.50";
70 case 460:
71 return (const GLubyte *) "4.60";
72 default:
73 _mesa_problem(ctx,
74 "Invalid GLSL version in shading_language_version()");
75 return (const GLubyte *) 0;
76 }
77 break;
78
79 case API_OPENGLES2:
80 switch (ctx->Version) {
81 case 20:
82 return (const GLubyte *) "OpenGL ES GLSL ES 1.0.16";
83 case 30:
84 return (const GLubyte *) "OpenGL ES GLSL ES 3.00";
85 case 31:
86 return (const GLubyte *) "OpenGL ES GLSL ES 3.10";
87 case 32:
88 return (const GLubyte *) "OpenGL ES GLSL ES 3.20";
89 default:
90 _mesa_problem(ctx,
91 "Invalid OpenGL ES version in shading_language_version()");
92 return (const GLubyte *) 0;
93 }
94 case API_OPENGLES:
95 /* fall-through */
96
97 default:
98 _mesa_problem(ctx, "Unexpected API value in shading_language_version()");
99 return (const GLubyte *) 0;
100 }
101 }
102
103
104 /**
105 * Query string-valued state. The return value should _not_ be freed by
106 * the caller.
107 *
108 * \param name the state variable to query.
109 *
110 * \sa glGetString().
111 *
112 * Tries to get the string from dd_function_table::GetString, otherwise returns
113 * the hardcoded strings.
114 */
115 const GLubyte * GLAPIENTRY
_mesa_GetString(GLenum name)116 _mesa_GetString( GLenum name )
117 {
118 GET_CURRENT_CONTEXT(ctx);
119 static const char *vendor = "Brian Paul";
120 static const char *renderer = "Mesa";
121
122 if (!ctx)
123 return NULL;
124
125 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
126
127 if (ctx->Const.VendorOverride && name == GL_VENDOR) {
128 return (const GLubyte *) ctx->Const.VendorOverride;
129 }
130
131 /* this is a required driver function */
132 assert(ctx->Driver.GetString);
133 {
134 /* Give the driver the chance to handle this query */
135 const GLubyte *str = ctx->Driver.GetString(ctx, name);
136 if (str)
137 return str;
138 }
139
140 switch (name) {
141 case GL_VENDOR:
142 return (const GLubyte *) vendor;
143 case GL_RENDERER:
144 return (const GLubyte *) renderer;
145 case GL_VERSION:
146 return (const GLubyte *) ctx->VersionString;
147 case GL_EXTENSIONS:
148 if (ctx->API == API_OPENGL_CORE) {
149 _mesa_error(ctx, GL_INVALID_ENUM, "glGetString(GL_EXTENSIONS)");
150 return (const GLubyte *) 0;
151 }
152 if (!ctx->Extensions.String)
153 ctx->Extensions.String = _mesa_make_extension_string(ctx);
154 return (const GLubyte *) ctx->Extensions.String;
155 case GL_SHADING_LANGUAGE_VERSION:
156 if (ctx->API == API_OPENGLES)
157 break;
158 return shading_language_version(ctx);
159 case GL_PROGRAM_ERROR_STRING_ARB:
160 if (ctx->API == API_OPENGL_COMPAT &&
161 (ctx->Extensions.ARB_fragment_program ||
162 ctx->Extensions.ARB_vertex_program)) {
163 return (const GLubyte *) ctx->Program.ErrorString;
164 }
165 break;
166 default:
167 break;
168 }
169
170 _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" );
171 return (const GLubyte *) 0;
172 }
173
174
175 /**
176 * GL3
177 */
178 const GLubyte * GLAPIENTRY
_mesa_GetStringi(GLenum name,GLuint index)179 _mesa_GetStringi(GLenum name, GLuint index)
180 {
181 GET_CURRENT_CONTEXT(ctx);
182
183 if (!ctx)
184 return NULL;
185
186 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
187
188 switch (name) {
189 case GL_EXTENSIONS:
190 if (index >= _mesa_get_extension_count(ctx)) {
191 _mesa_error(ctx, GL_INVALID_VALUE, "glGetStringi(index=%u)", index);
192 return (const GLubyte *) 0;
193 }
194 return _mesa_get_enabled_extension(ctx, index);
195 case GL_SHADING_LANGUAGE_VERSION:
196 {
197 char *version;
198 int num;
199 if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 43) {
200 _mesa_error(ctx, GL_INVALID_ENUM,
201 "glGetStringi(GL_SHADING_LANGUAGE_VERSION): "
202 "supported only in GL4.3 and later");
203 return (const GLubyte *) 0;
204 }
205 num = _mesa_get_shading_language_version(ctx, index, &version);
206 if (index >= num) {
207 _mesa_error(ctx, GL_INVALID_VALUE,
208 "glGetStringi(GL_SHADING_LANGUAGE_VERSION, index=%d)",
209 index);
210 return (const GLubyte *) 0;
211 }
212 return (const GLubyte *) version;
213 }
214 case GL_SPIR_V_EXTENSIONS:
215 if (!ctx->Extensions.ARB_spirv_extensions) {
216 _mesa_error(ctx, GL_INVALID_ENUM, "glGetStringi");
217 return (const GLubyte *) 0;
218 }
219
220 if (index >= _mesa_get_spirv_extension_count(ctx)) {
221 _mesa_error(ctx, GL_INVALID_VALUE, "glGetStringi(index=%u)", index);
222 return (const GLubyte *) 0;
223 }
224 return _mesa_get_enabled_spirv_extension(ctx, index);
225
226 default:
227 _mesa_error(ctx, GL_INVALID_ENUM, "glGetStringi");
228 return (const GLubyte *) 0;
229 }
230 }
231
232
233 void
_get_vao_pointerv(GLenum pname,struct gl_vertex_array_object * vao,GLvoid ** params,const char * callerstr)234 _get_vao_pointerv(GLenum pname, struct gl_vertex_array_object* vao,
235 GLvoid **params, const char* callerstr )
236 {
237 GET_CURRENT_CONTEXT(ctx);
238 const GLuint clientUnit = ctx->Array.ActiveTexture;
239
240 if (!params)
241 return;
242
243 if (MESA_VERBOSE & VERBOSE_API)
244 _mesa_debug(ctx, "%s %s\n", callerstr, _mesa_enum_to_string(pname));
245
246 switch (pname) {
247 case GL_VERTEX_ARRAY_POINTER:
248 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
249 goto invalid_pname;
250 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_POS].Ptr;
251 break;
252 case GL_NORMAL_ARRAY_POINTER:
253 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
254 goto invalid_pname;
255 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_NORMAL].Ptr;
256 break;
257 case GL_COLOR_ARRAY_POINTER:
258 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
259 goto invalid_pname;
260 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_COLOR0].Ptr;
261 break;
262 case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
263 if (ctx->API != API_OPENGL_COMPAT)
264 goto invalid_pname;
265 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_COLOR1].Ptr;
266 break;
267 case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
268 if (ctx->API != API_OPENGL_COMPAT)
269 goto invalid_pname;
270 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_FOG].Ptr;
271 break;
272 case GL_INDEX_ARRAY_POINTER:
273 if (ctx->API != API_OPENGL_COMPAT)
274 goto invalid_pname;
275 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Ptr;
276 break;
277 case GL_TEXTURE_COORD_ARRAY_POINTER:
278 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
279 goto invalid_pname;
280 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_TEX(clientUnit)].Ptr;
281 break;
282 case GL_EDGE_FLAG_ARRAY_POINTER:
283 if (ctx->API != API_OPENGL_COMPAT)
284 goto invalid_pname;
285 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Ptr;
286 break;
287 case GL_FEEDBACK_BUFFER_POINTER:
288 if (ctx->API != API_OPENGL_COMPAT)
289 goto invalid_pname;
290 *params = ctx->Feedback.Buffer;
291 break;
292 case GL_SELECTION_BUFFER_POINTER:
293 if (ctx->API != API_OPENGL_COMPAT)
294 goto invalid_pname;
295 *params = ctx->Select.Buffer;
296 break;
297 case GL_POINT_SIZE_ARRAY_POINTER_OES:
298 if (ctx->API != API_OPENGLES)
299 goto invalid_pname;
300 *params = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Ptr;
301 break;
302 case GL_DEBUG_CALLBACK_FUNCTION_ARB:
303 case GL_DEBUG_CALLBACK_USER_PARAM_ARB:
304 *params = _mesa_get_debug_state_ptr(ctx, pname);
305 break;
306 default:
307 goto invalid_pname;
308 }
309
310 return;
311
312 invalid_pname:
313 _mesa_error( ctx, GL_INVALID_ENUM, "%s", callerstr);
314 return;
315 }
316
317
318 /**
319 * Return pointer-valued state, such as a vertex array pointer.
320 *
321 * \param pname names state to be queried
322 * \param params returns the pointer value
323 *
324 * \sa glGetPointerv().
325 *
326 * Tries to get the specified pointer via dd_function_table::GetPointerv,
327 * otherwise gets the specified pointer from the current context.
328 */
329 void GLAPIENTRY
_mesa_GetPointerv(GLenum pname,GLvoid ** params)330 _mesa_GetPointerv( GLenum pname, GLvoid **params )
331 {
332 GET_CURRENT_CONTEXT(ctx);
333 const char *callerstr;
334
335 if (_mesa_is_desktop_gl(ctx))
336 callerstr = "glGetPointerv";
337 else
338 callerstr = "glGetPointervKHR";
339
340 if (!params)
341 return;
342
343 _get_vao_pointerv(pname, ctx->Array.VAO, params, callerstr);
344 }
345
346
347 void GLAPIENTRY
_mesa_GetPointerIndexedvEXT(GLenum pname,GLuint index,GLvoid ** params)348 _mesa_GetPointerIndexedvEXT( GLenum pname, GLuint index, GLvoid **params )
349 {
350 GET_CURRENT_CONTEXT(ctx);
351
352 if (!params)
353 return;
354
355 if (MESA_VERBOSE & VERBOSE_API)
356 _mesa_debug(ctx, "%s %s\n", "glGetPointerIndexedvEXT", _mesa_enum_to_string(pname));
357
358 switch (pname) {
359 case GL_TEXTURE_COORD_ARRAY_POINTER:
360 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(index)].Ptr;
361 break;
362 default:
363 goto invalid_pname;
364 }
365
366 return;
367
368 invalid_pname:
369 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerIndexedvEXT");
370 return;
371 }
372
373 /**
374 * Returns the current GL error code, or GL_NO_ERROR.
375 * \return current error code
376 *
377 * Returns __struct gl_contextRec::ErrorValue.
378 */
379 GLenum GLAPIENTRY
_mesa_GetError(void)380 _mesa_GetError( void )
381 {
382 GET_CURRENT_CONTEXT(ctx);
383 GLenum e = ctx->ErrorValue;
384 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
385
386 /* From Issue (3) of the KHR_no_error spec:
387 *
388 * "Should glGetError() always return NO_ERROR or have undefined
389 * results?
390 *
391 * RESOLVED: It should for all errors except OUT_OF_MEMORY."
392 */
393 if (_mesa_is_no_error_enabled(ctx) && e != GL_OUT_OF_MEMORY) {
394 e = GL_NO_ERROR;
395 }
396
397 if (MESA_VERBOSE & VERBOSE_API)
398 _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_enum_to_string(e));
399
400 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
401 ctx->ErrorDebugCount = 0;
402 return e;
403 }
404