X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fgetstring.c;h=9873fdbf1a42a1f8beb1f6ca670647c730dbbad9;hb=b319fd7c14707ff345b7ce1461e5fee81b75a4cf;hp=51dd5f779572ee045139349c9c907d1a08953854;hpb=653a83445f94620673f747a4ace6847a2c7fdb4d;p=mesa.git diff --git a/src/mesa/main/getstring.c b/src/mesa/main/getstring.c index 51dd5f77957..9873fdbf1a4 100644 --- a/src/mesa/main/getstring.c +++ b/src/mesa/main/getstring.c @@ -1,6 +1,5 @@ /* * Mesa 3-D graphics library - * Version: 7.1 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * @@ -17,18 +16,82 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. */ - +#include #include "glheader.h" #include "context.h" #include "get.h" #include "enums.h" #include "extensions.h" +#include "mtypes.h" + + +/** + * Return the string for a glGetString(GL_SHADING_LANGUAGE_VERSION) query. + */ +static const GLubyte * +shading_language_version(struct gl_context *ctx) +{ + switch (ctx->API) { + case API_OPENGL_COMPAT: + case API_OPENGL_CORE: + switch (ctx->Const.GLSLVersion) { + case 120: + return (const GLubyte *) "1.20"; + case 130: + return (const GLubyte *) "1.30"; + case 140: + return (const GLubyte *) "1.40"; + case 150: + return (const GLubyte *) "1.50"; + case 330: + return (const GLubyte *) "3.30"; + case 400: + return (const GLubyte *) "4.00"; + case 410: + return (const GLubyte *) "4.10"; + case 420: + return (const GLubyte *) "4.20"; + case 430: + return (const GLubyte *) "4.30"; + case 440: + return (const GLubyte *) "4.40"; + case 450: + return (const GLubyte *) "4.50"; + default: + _mesa_problem(ctx, + "Invalid GLSL version in shading_language_version()"); + return (const GLubyte *) 0; + } + break; + + case API_OPENGLES2: + switch (ctx->Version) { + case 20: + return (const GLubyte *) "OpenGL ES GLSL ES 1.0.16"; + case 30: + return (const GLubyte *) "OpenGL ES GLSL ES 3.00"; + case 31: + return (const GLubyte *) "OpenGL ES GLSL ES 3.10"; + default: + _mesa_problem(ctx, + "Invalid OpenGL ES version in shading_language_version()"); + return (const GLubyte *) 0; + } + case API_OPENGLES: + /* fall-through */ + + default: + _mesa_problem(ctx, "Unexpected API value in shading_language_version()"); + return (const GLubyte *) 0; + } +} /** @@ -71,35 +134,28 @@ _mesa_GetString( GLenum name ) case GL_VERSION: return (const GLubyte *) ctx->VersionString; case GL_EXTENSIONS: - if (!ctx->Extensions.String) - ctx->Extensions.String = _mesa_make_extension_string(ctx); + if (ctx->API == API_OPENGL_CORE) { + _mesa_error(ctx, GL_INVALID_ENUM, "glGetString(GL_EXTENSIONS)"); + return (const GLubyte *) 0; + } return (const GLubyte *) ctx->Extensions.String; -#if FEATURE_ARB_shading_language_100 - case GL_SHADING_LANGUAGE_VERSION_ARB: - if (ctx->Extensions.ARB_shading_language_120) - return (const GLubyte *) "1.20"; - else if (ctx->Extensions.ARB_shading_language_100) - return (const GLubyte *) "1.10"; - goto error; -#endif -#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program || \ - FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program - case GL_PROGRAM_ERROR_STRING_NV: - if (ctx->Extensions.NV_fragment_program || - ctx->Extensions.ARB_fragment_program || - ctx->Extensions.NV_vertex_program || - ctx->Extensions.ARB_vertex_program) { + case GL_SHADING_LANGUAGE_VERSION: + if (ctx->API == API_OPENGLES) + break; + return shading_language_version(ctx); + case GL_PROGRAM_ERROR_STRING_ARB: + if (ctx->API == API_OPENGL_COMPAT && + (ctx->Extensions.ARB_fragment_program || + ctx->Extensions.ARB_vertex_program)) { return (const GLubyte *) ctx->Program.ErrorString; } - /* FALL-THROUGH */ -#endif -#if FEATURE_ARB_shading_language_100 - error: -#endif + break; default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" ); - return (const GLubyte *) 0; + break; } + + _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" ); + return (const GLubyte *) 0; } @@ -124,7 +180,7 @@ _mesa_GetStringi(GLenum name, GLuint index) } return _mesa_get_enabled_extension(ctx, index); default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetString" ); + _mesa_error(ctx, GL_INVALID_ENUM, "glGetStringi"); return (const GLubyte *) 0; } } @@ -147,58 +203,85 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params ) { GET_CURRENT_CONTEXT(ctx); const GLuint clientUnit = ctx->Array.ActiveTexture; - ASSERT_OUTSIDE_BEGIN_END(ctx); if (!params) return; if (MESA_VERBOSE & VERBOSE_API) - _mesa_debug(ctx, "glGetPointerv %s\n", _mesa_lookup_enum_by_nr(pname)); - - if (ctx->Driver.GetPointerv - && (*ctx->Driver.GetPointerv)(ctx, pname, params)) - return; + _mesa_debug(ctx, "glGetPointerv %s\n", _mesa_enum_to_string(pname)); switch (pname) { case GL_VERTEX_ARRAY_POINTER: - *params = (GLvoid *) ctx->Array.ArrayObj->Vertex.Ptr; + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Ptr; break; case GL_NORMAL_ARRAY_POINTER: - *params = (GLvoid *) ctx->Array.ArrayObj->Normal.Ptr; + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_NORMAL].Ptr; break; case GL_COLOR_ARRAY_POINTER: - *params = (GLvoid *) ctx->Array.ArrayObj->Color.Ptr; + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0].Ptr; break; case GL_SECONDARY_COLOR_ARRAY_POINTER_EXT: - *params = (GLvoid *) ctx->Array.ArrayObj->SecondaryColor.Ptr; + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1].Ptr; break; case GL_FOG_COORDINATE_ARRAY_POINTER_EXT: - *params = (GLvoid *) ctx->Array.ArrayObj->FogCoord.Ptr; + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_FOG].Ptr; break; case GL_INDEX_ARRAY_POINTER: - *params = (GLvoid *) ctx->Array.ArrayObj->Index.Ptr; + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Ptr; break; case GL_TEXTURE_COORD_ARRAY_POINTER: - *params = (GLvoid *) ctx->Array.ArrayObj->TexCoord[clientUnit].Ptr; + if (ctx->API != API_OPENGL_COMPAT && ctx->API != API_OPENGLES) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(clientUnit)].Ptr; break; case GL_EDGE_FLAG_ARRAY_POINTER: - *params = (GLvoid *) ctx->Array.ArrayObj->EdgeFlag.Ptr; + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Ptr; break; case GL_FEEDBACK_BUFFER_POINTER: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_pname; *params = ctx->Feedback.Buffer; break; case GL_SELECTION_BUFFER_POINTER: + if (ctx->API != API_OPENGL_COMPAT) + goto invalid_pname; *params = ctx->Select.Buffer; break; -#if FEATURE_point_size_array case GL_POINT_SIZE_ARRAY_POINTER_OES: - *params = (GLvoid *) ctx->Array.ArrayObj->PointSize.Ptr; + if (ctx->API != API_OPENGLES) + goto invalid_pname; + *params = (GLvoid *) ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POINT_SIZE].Ptr; + break; + case GL_DEBUG_CALLBACK_FUNCTION_ARB: + case GL_DEBUG_CALLBACK_USER_PARAM_ARB: + if (!_mesa_is_desktop_gl(ctx)) + goto invalid_pname; + else + *params = _mesa_get_debug_state_ptr(ctx, pname); break; -#endif default: - _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" ); - return; + goto invalid_pname; } + + return; + +invalid_pname: + _mesa_error( ctx, GL_INVALID_ENUM, "glGetPointerv" ); + return; } @@ -206,7 +289,7 @@ _mesa_GetPointerv( GLenum pname, GLvoid **params ) * Returns the current GL error code, or GL_NO_ERROR. * \return current error code * - * Returns __GLcontextRec::ErrorValue. + * Returns __struct gl_contextRec::ErrorValue. */ GLenum GLAPIENTRY _mesa_GetError( void ) @@ -216,9 +299,65 @@ _mesa_GetError( void ) ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0); if (MESA_VERBOSE & VERBOSE_API) - _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_lookup_enum_by_nr(e)); + _mesa_debug(ctx, "glGetError <-- %s\n", _mesa_enum_to_string(e)); ctx->ErrorValue = (GLenum) GL_NO_ERROR; ctx->ErrorDebugCount = 0; return e; } + +/** + * Returns an error code specified by GL_ARB_robustness, or GL_NO_ERROR. + * \return current context status + */ +GLenum GLAPIENTRY +_mesa_GetGraphicsResetStatusARB( void ) +{ + GET_CURRENT_CONTEXT(ctx); + GLenum status = GL_NO_ERROR; + + /* The ARB_robustness specification says: + * + * "If the reset notification behavior is NO_RESET_NOTIFICATION_ARB, + * then the implementation will never deliver notification of reset + * events, and GetGraphicsResetStatusARB will always return NO_ERROR." + */ + if (ctx->Const.ResetStrategy == GL_NO_RESET_NOTIFICATION_ARB) { + if (MESA_VERBOSE & VERBOSE_API) + _mesa_debug(ctx, + "glGetGraphicsResetStatusARB always returns GL_NO_ERROR " + "because reset notifictation was not requested at context " + "creation.\n"); + + return GL_NO_ERROR; + } + + if (ctx->Driver.GetGraphicsResetStatus) { + /* Query the reset status of this context from the driver core. + */ + status = ctx->Driver.GetGraphicsResetStatus(ctx); + + mtx_lock(&ctx->Shared->Mutex); + + /* If this context has not been affected by a GPU reset, check to see if + * some other context in the share group has been affected by a reset. + * If another context saw a reset but this context did not, assume that + * this context was not guilty. + */ + if (status != GL_NO_ERROR) { + ctx->Shared->ShareGroupReset = true; + } else if (ctx->Shared->ShareGroupReset && !ctx->ShareGroupReset) { + status = GL_INNOCENT_CONTEXT_RESET_ARB; + } + + ctx->ShareGroupReset = ctx->Shared->ShareGroupReset; + mtx_unlock(&ctx->Shared->Mutex); + } + + if (!ctx->Driver.GetGraphicsResetStatus && (MESA_VERBOSE & VERBOSE_API)) + _mesa_debug(ctx, + "glGetGraphicsResetStatusARB always returns GL_NO_ERROR " + "because the driver doesn't track reset status.\n"); + + return status; +}