kc3-lang/angle/src/libGL/entry_points_gl_1_2_autogen.cpp

• Show log

  Commit

• Hash : d8529380
  Author :
  Date : 2020-10-20T13:55:23
  

  Generate CONTEXT_LOST errors on every GL call.
  
  The robustness spec states that all GL calls should generate context
  lost errors when the context is lost. This behaviour was lost due to
  some context lookup optimizations but can be re-added at no cost by
  updating the autogenerated entry points.
  
  Updated the ContextLostTest to cover the repeated error generation
  behaviour.
  
  Bug: chromium:1137241
  Change-Id: I0b8d1cf4d2a37f13c466c8dd0e66edfe852f7e59
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2488180
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libGL/entry_points_gl_1_2_autogen.cpp

• // GENERATED FILE - DO NOT EDIT.
  // Generated by generate_entry_points.py using data from gl.xml.
  //
  // Copyright 2020 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // entry_points_gl_1_2_autogen.cpp:
  //   Defines the GL 1.2 entry points.
  
  #include "libGL/entry_points_gl_1_2_autogen.h"
  
  #include "libANGLE/Context.h"
  #include "libANGLE/Context.inl.h"
  #include "libANGLE/entry_points_utils.h"
  #include "libANGLE/gl_enum_utils.h"
  #include "libANGLE/validationEGL.h"
  #include "libANGLE/validationES.h"
  #include "libANGLE/validationES1.h"
  #include "libANGLE/validationES2.h"
  #include "libANGLE/validationES3.h"
  #include "libANGLE/validationES31.h"
  #include "libANGLE/validationES32.h"
  #include "libANGLE/validationESEXT.h"
  #include "libANGLE/validationGL12_autogen.h"
  #include "libGLESv2/global_state.h"
  
  namespace gl
  {
  void GL_APIENTRY CopyTexSubImage3D(GLenum target,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, gl::EntryPoint::CopyTexSubImage3D, "glCopyTexSubImage3D",
            "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
            "%d, GLint zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height "
            "= %d",
            CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
            zoffset, x, y, width, height);
  
      if (context)
      {
          TextureTarget targetPacked                            = FromGL<TextureTarget>(target);
          std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                                      = (context->skipValidation() ||
                              ValidateCopyTexSubImage3D(context, targetPacked, level, xoffset,
                                                        yoffset, zoffset, x, y, width, height));
          if (isCallValid)
          {
              context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
                                         height);
          }
          ANGLE_CAPTURE(CopyTexSubImage3D, isCallValid, context, targetPacked, level, xoffset,
                        yoffset, zoffset, x, y, width, height);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
  }
  
  void GL_APIENTRY DrawRangeElements(GLenum mode,
                                     GLuint start,
                                     GLuint end,
                                     GLsizei count,
                                     GLenum type,
                                     const void *indices)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, gl::EntryPoint::DrawRangeElements, "glDrawRangeElements",
            "context = %d, GLenum mode = %s, GLuint start = %u, GLuint end = %u, GLsizei count = %d, "
            "GLenum type = %s, const void *indices = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count,
            GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices);
  
      if (context)
      {
          PrimitiveMode modePacked                              = FromGL<PrimitiveMode>(mode);
          DrawElementsType typePacked                           = FromGL<DrawElementsType>(type);
          std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() || ValidateDrawRangeElements(context, modePacked, start, end,
                                                                      count, typePacked, indices));
          if (isCallValid)
          {
              context->drawRangeElements(modePacked, start, end, count, typePacked, indices);
          }
          ANGLE_CAPTURE(DrawRangeElements, isCallValid, context, modePacked, start, end, count,
                        typePacked, indices);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
  }
  
  void GL_APIENTRY TexImage3D(GLenum target,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLsizei height,
                              GLsizei depth,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, gl::EntryPoint::TexImage3D, "glTexImage3D",
            "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei "
            "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = "
            "%s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat,
            width, height, depth, border, GLenumToString(GLenumGroup::PixelFormat, format),
            GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
  
      if (context)
      {
          TextureTarget targetPacked                            = FromGL<TextureTarget>(target);
          std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid                                      = (context->skipValidation() ||
                              ValidateTexImage3D(context, targetPacked, level, internalformat, width,
                                                 height, depth, border, format, type, pixels));
          if (isCallValid)
          {
              context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
                                  format, type, pixels);
          }
          ANGLE_CAPTURE(TexImage3D, isCallValid, context, targetPacked, level, internalformat, width,
                        height, depth, border, format, type, pixels);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
  }
  
  void GL_APIENTRY TexSubImage3D(GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint zoffset,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, gl::EntryPoint::TexSubImage3D, "glTexSubImage3D",
            "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = "
            "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
            "GLenum format = %s, GLenum type = %s, const void *pixels = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset,
            zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format),
            GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
  
      if (context)
      {
          TextureTarget targetPacked                            = FromGL<TextureTarget>(target);
          std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset, width,
                                     height, depth, format, type, pixels));
          if (isCallValid)
          {
              context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
                                     depth, format, type, pixels);
          }
          ANGLE_CAPTURE(TexSubImage3D, isCallValid, context, targetPacked, level, xoffset, yoffset,
                        zoffset, width, height, depth, format, type, pixels);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
  }
  }  // namespace gl
  

Download