kc3-lang/angle/src/libANGLE/context_private_call_gl.cpp

• Show log

  Commit

• Hash : 9962f078
  Author :
  Date : 2023-07-11T15:39:50
  

  Pass only context-private state to private entry points
  
  This change ensures that the implementation for these entry points
  cannot access anything other than context-private state.
  
  Bug: angleproject:8224
  Change-Id: I988672b138d861db25e91d71ab8c34baa4e8ebee
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4678783
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/context_private_call_gl.cpp

• //
  // Copyright 2023 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.
  //
  
  // context_private_call_gl.cpp:
  //   Helpers that set/get state that is entirely locally accessed by the context.
  
  #include "libANGLE/context_private_call_gl_autogen.h"
  #include "libANGLE/context_private_call_gles_autogen.h"
  
  #include "common/debug.h"
  
  namespace gl
  {
  void ContextPrivateVertexAttrib1d(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLdouble x)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib1dv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib1s(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLshort x)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib1sv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLshort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib2d(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLdouble x,
                                    GLdouble y)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib2dv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib2s(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLshort x,
                                    GLshort y)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib2sv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLshort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib3d(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLdouble x,
                                    GLdouble y,
                                    GLdouble z)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib3dv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib3s(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLshort x,
                                    GLshort y,
                                    GLshort z)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib3sv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLshort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Nbv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLbyte *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Niv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Nsv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLshort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Nub(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLubyte x,
                                      GLubyte y,
                                      GLubyte z,
                                      GLubyte w)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Nubv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLubyte *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Nuiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLuint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4Nusv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLushort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4bv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLbyte *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4d(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLdouble x,
                                    GLdouble y,
                                    GLdouble z,
                                    GLdouble w)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4dv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4iv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4s(PrivateState *privateState,
                                    PrivateStateCache *privateStateCache,
                                    GLuint index,
                                    GLshort x,
                                    GLshort y,
                                    GLshort z,
                                    GLshort w)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4sv(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     const GLshort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4ubv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLubyte *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4uiv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLuint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttrib4usv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLushort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI1i(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLint x)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI1iv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI1ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLuint x)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI1uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLuint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI2i(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLint x,
                                     GLint y)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI2iv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI2ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLuint x,
                                      GLuint y)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI2uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLuint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI3i(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLint x,
                                     GLint y,
                                     GLint z)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI3iv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI3ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLuint x,
                                      GLuint y,
                                      GLuint z)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI3uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLuint *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI4bv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLbyte *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI4sv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLshort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI4ubv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLubyte *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribI4usv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       const GLushort *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP1ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLenum type,
                                      GLboolean normalized,
                                      GLuint value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP1uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       GLenum type,
                                       GLboolean normalized,
                                       const GLuint *value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP2ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLenum type,
                                      GLboolean normalized,
                                      GLuint value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP2uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       GLenum type,
                                       GLboolean normalized,
                                       const GLuint *value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP3ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLenum type,
                                      GLboolean normalized,
                                      GLuint value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP3uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       GLenum type,
                                       GLboolean normalized,
                                       const GLuint *value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP4ui(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      GLenum type,
                                      GLboolean normalized,
                                      GLuint value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribP4uiv(PrivateState *privateState,
                                       PrivateStateCache *privateStateCache,
                                       GLuint index,
                                       GLenum type,
                                       GLboolean normalized,
                                       const GLuint *value)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL1d(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLdouble x)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL1dv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL2d(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLdouble x,
                                     GLdouble y)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL2dv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL3d(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLdouble x,
                                     GLdouble y,
                                     GLdouble z)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL3dv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL4d(PrivateState *privateState,
                                     PrivateStateCache *privateStateCache,
                                     GLuint index,
                                     GLdouble x,
                                     GLdouble y,
                                     GLdouble z,
                                     GLdouble w)
  {
      UNIMPLEMENTED();
  }
  
  void ContextPrivateVertexAttribL4dv(PrivateState *privateState,
                                      PrivateStateCache *privateStateCache,
                                      GLuint index,
                                      const GLdouble *v)
  {
      UNIMPLEMENTED();
  }
  }  // namespace gl
  

Download