mesa/gallium: add dric option to allow overriding GL vendor string
[mesa.git] / src / mesa / main / getstring.c
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 *
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
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
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
234 /**
235 * Return pointer-valued state, such as a vertex array pointer.
236 *
237 * \param pname names state to be queried
238 * \param params returns the pointer value
239 *
240 * \sa glGetPointerv().
241 *
242 * Tries to get the specified pointer via dd_function_table::GetPointerv,
243 * otherwise gets the specified pointer from the current context.
244 */
245 void GLAPIENTRY
246 _mesa_GetPointerv( GLenum pname, GLvoid **params )
247 {
248 GET_CURRENT_CONTEXT(ctx);
249 const GLuint clientUnit = ctx->Array.ActiveTexture;
250 const char *callerstr;
251
252 if (_mesa_is_desktop_gl(ctx))
253 callerstr = "glGetPointerv";
254 else
255 callerstr = "glGetPointervKHR";
256
257 if (!params)
258 return;
259
260 if (MESA_VERBOSE & VERBOSE_API)
261 _mesa_debug(ctx, "%s %s\n", callerstr, _mesa_enum_to_string(pname));
262
263 switch (pname) {
264 case GL_VERTEX_ARRAY_POINTER:
265 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
266 goto invalid_pname;
267 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Ptr;
268 break;
269 case GL_NORMAL_ARRAY_POINTER:
270 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
271 goto invalid_pname;
272 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_NORMAL].Ptr;
273 break;
274 case GL_COLOR_ARRAY_POINTER:
275 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
276 goto invalid_pname;
277 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0].Ptr;
278 break;
279 case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT:
280 if (ctx->API != API_OPENGL_COMPAT)
281 goto invalid_pname;
282 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1].Ptr;
283 break;
284 case GL_FOG_COORDINATE_ARRAY_POINTER_EXT:
285 if (ctx->API != API_OPENGL_COMPAT)
286 goto invalid_pname;
287 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_FOG].Ptr;
288 break;
289 case GL_INDEX_ARRAY_POINTER:
290 if (ctx->API != API_OPENGL_COMPAT)
291 goto invalid_pname;
292 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Ptr;
293 break;
294 case GL_TEXTURE_COORD_ARRAY_POINTER:
295 if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES)
296 goto invalid_pname;
297 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(clientUnit)].Ptr;
298 break;
299 case GL_EDGE_FLAG_ARRAY_POINTER:
300 if (ctx->API != API_OPENGL_COMPAT)
301 goto invalid_pname;
302 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Ptr;
303 break;
304 case GL_FEEDBACK_BUFFER_POINTER:
305 if (ctx->API != API_OPENGL_COMPAT)
306 goto invalid_pname;
307 *params = ctx->Feedback.Buffer;
308 break;
309 case GL_SELECTION_BUFFER_POINTER:
310 if (ctx->API != API_OPENGL_COMPAT)
311 goto invalid_pname;
312 *params = ctx->Select.Buffer;
313 break;
314 case GL_POINT_SIZE_ARRAY_POINTER_OES:
315 if (ctx->API != API_OPENGLES)
316 goto invalid_pname;
317 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Ptr;
318 break;
319 case GL_DEBUG_CALLBACK_FUNCTION_ARB:
320 case GL_DEBUG_CALLBACK_USER_PARAM_ARB:
321 *params = _mesa_get_debug_state_ptr(ctx, pname);
322 break;
323 default:
324 goto invalid_pname;
325 }
326
327 return;
328
329 invalid_pname:
330 _mesa_error( ctx, GL_INVALID_ENUM, "%s", callerstr);
331 return;
332 }
333
334
335 void GLAPIENTRY
336 _mesa_GetPointerIndexedvEXT( GLenum pname, GLuint index, GLvoid **params )
337 {
338 GET_CURRENT_CONTEXT(ctx);
339
340 if (!params)
341 return;
342
343 if (MESA_VERBOSE & VERBOSE_API)
344 _mesa_debug(ctx, "%s %s\n", "glGetPointerIndexedvEXT", _mesa_enum_to_string(pname));
345
346 switch (pname) {
347 case GL_TEXTURE_COORD_ARRAY_POINTER:
348 *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(index)].Ptr;
349 break;
350 default:
351 goto invalid_pname;
352 }
353
354 return;
355
356 invalid_pname:
357 _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerIndexedvEXT");
358 return;
359 }
360
361 /**
362 * Returns the current GL error code, or GL_NO_ERROR.
363 * \return current error code
364 *
365 * Returns __struct gl_contextRec::ErrorValue.
366 */
367 GLenum GLAPIENTRY
368 _mesa_GetError( void )
369 {
370 GET_CURRENT_CONTEXT(ctx);
371 GLenum e = ctx->ErrorValue;
372 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
373
374 /* From Issue (3) of the KHR_no_error spec:
375 *
376 * "Should glGetError() always return NO_ERROR or have undefined
377 * results?
378 *
379 * RESOLVED: It should for all errors except OUT_OF_MEMORY."
380 */
381 if (_mesa_is_no_error_enabled(ctx) && e != GL_OUT_OF_MEMORY) {
382 e = GL_NO_ERROR;
383 }
384
385 if (MESA_VERBOSE & VERBOSE_API)
386 _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_enum_to_string(e));
387
388 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
389 ctx->ErrorDebugCount = 0;
390 return e;
391 }